哪位大牛能否给讲解一下Uevent 上报event事件给上层，上层是怎么调用的？

哪位大牛能否给讲解一下Uevent 上报event事件给上层，上层是怎么调用的?

#ifdef CONFIG_I_LOVE_PBJ30
void headphone_event(int state)
{
       switch_set_state(&wired_switch_dev, state);
}
EXPORT_SYMBOL_GPL(headphone_event);
#endif
//headphone_event 函数会调用switch_set_state函数进行上报事件
static struct switch_dev wired_switch_dev = {
       .name = "h2w",
};

void switch_set_state(struct switch_dev *sdev, int state)
{
       char name_buf[120];
       char state_buf[120];
       char *prop_buf;
       char *envp[3];
       int env_offset = 0;
       int length;

       if (sdev->state ！= state) {
              sdev->state = state;

              prop_buf = (char *)get_zeroed_page(GFP_KERNEL);
              if (prop_buf) {
                     length = name_show(sdev->dev, NULL, prop_buf);
                     if (length > 0) {
                           if (prop_buf[length - 1] == '\n')
                                  prop_buf[length - 1] = 0;
                           snprintf(name_buf, sizeof(name_buf),
                                  "SWITCH_NAME=%s", prop_buf);
                           envp[env_offset++] = name_buf;
                     }
                     length = state_show(sdev->dev, NULL, prop_buf);
                     if (length > 0) {
                           if (prop_buf[length - 1] == '\n')
                                  prop_buf[length - 1] = 0;
                           snprintf(state_buf, sizeof(state_buf),
                                  "SWITCH_STATE=%s", prop_buf);
                           envp[env_offset++] = state_buf;
                     }
                     envp[env_offset] = NULL;
                     kobject_uevent_env(&sdev->dev->kobj, KOBJ_CHANGE, envp);
                     free_page((unsignedlong)prop_buf);
              } else {
                     printk(KERN_ERR "out of memory in switch_set_state\n");
                     kobject_uevent(&sdev->dev->kobj, KOBJ_CHANGE);
              }
       }
}
EXPORT_SYMBOL_GPL(switch_set_state);
//讲解下上的switch_set_state函数
//我们首先会判断sdev里面的状态和我们需要设置的状态是否一样，如果一样的话，那么就不需要去管它，如果不一样的话，那么就将state的值修改


//上面主要会调用以下几个函数：
//name_show:
//state_show:
//kobject_uevent_env:

//在switch_set_state函数里面，会申请一个buffer，然后调用name_show函数
static ssize_t name_show(struct device *dev, struct device_attribute *attr,
              char *buf)
{
       struct switch_dev *sdev = (struct switch_dev *)
              dev_get_drvdata(dev);

       if (sdev->print_name) {
              int ret = sdev->print_name(sdev, buf);
              if (ret >= 0)
                     return ret;
       }
       return sprintf(buf, "%s\n", sdev->name);
}

//name_show函数会判断sdev里面的print_name函数有没有被实现，如果没有实现的话，那么就将sdev->name的值输入到buf中去
//我们的sdev里面实现的如下：
static struct switch_dev wired_switch_dev = {
       .name = "h2w",
};
//所以就直接将name 输入到buf中去
//然后将输入到buf里面的值赋值到envp数组里面去：envp[env_offset++] = name_buf;

//接下来的state_show函数的执行和上面的name_show函数是一样的，只是一个输出的是name，另外一个是state
//也是将state的值赋值到envp 的数组里面去

//接下来会调用kobject_uevent_env函数进行上报事件
//kobject_uevent_env(&sdev->dev->kobj, KOBJ_CHANGE, envp);
//kobject_uevent_env函数会首先判断 我这个kobject是属于哪个kset里面的，然后找出这个kset里面的uevent_ops

//kobject_uevent_env函数的实现全部过程如下：

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                     char *envp_ext[])
{
       struct kobj_uevent_env *env;
       constchar *action_string = kobject_actions[action];
       constchar *devpath = NULL;
       constchar *subsystem;
       struct kobject *top_kobj;
       struct kset *kset;
       conststruct kset_uevent_ops *uevent_ops;
       u64 seq;
       int i = 0;
       int retval = 0;
#ifdef CONFIG_NET
       struct uevent_sock *ue_sk;
#endif

       pr_debug("kobject: '%s' (%p): %s\n",
               kobject_name(kobj), kobj, __func__);

       /* search the kset we belong to */
       top_kobj = kobj;
       while (！top_kobj->kset && top_kobj->parent)//取出这个kobject属于哪一个kset
              top_kobj = top_kobj->parent;

       if (！top_kobj->kset) {
              pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "
                      "without kset！\n", kobject_name(kobj), kobj,
                      __func__);
              return -EINVAL;
       }

       kset = top_kobj->kset;//找到这个kobject的kset成员
       uevent_ops = kset->uevent_ops; //找到这个kset创建的时候，kset里面的uevent_ops成员

       /* skip the event, if uevent_suppress is set*/
       if (kobj->uevent_suppress) {//判断kobject里面有没有uvent_supress，如果有那么就代表这个
//event是忽略的
              pr_debug("kobject: '%s' (%p): %s: uevent_suppress "
                            "caused the event to drop！\n",
                            kobject_name(kobj), kobj, __func__);
              return 0;
       }
       /* skip the event, if the fiLTEr returns zero. */
       if (uevent_ops && uevent_ops->filter)
              if (！uevent_ops->filter(kset, kobj)) {//kset里面的uevent_ops里面的filter成员决定是否将事件传递到用户空间去，如果返回0的话，那么就直接忽略，通过代码看的出来
                     pr_debug("kobject: '%s' (%p): %s: filter function "
                            "caused the event to drop！\n",
                            kobject_name(kobj), kobj, __func__);
                     return 0;
              }

       /* originating subsystem */
       if (uevent_ops && uevent_ops->name)
              subsystem = uevent_ops->name(kset, kobj);//调用uevent_ops里面的name成员将字符串传递给用户空间的热插拔程序
       else
              subsystem = kobject_name(&kset->kobj);
       if (！subsystem) {
              pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "
                      "event to drop！\n", kobject_name(kobj), kobj,
                      __func__);
              return 0;
       }

       /* environment buffer */
       env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
       if (！env)
              return -ENOMEM;

       /* complete object path */
       devpath = kobject_get_path(kobj, GFP_KERNEL);
       if (！devpath) {
              retval = -ENOENT;
              goto exit;
       }

       /* default keys */
       retval = add_uevent_var(env, "ACTION=%s", action_string);
       if (retval)
              goto exit;
       retval = add_uevent_var(env, "DEVPATH=%s", devpath);
       if (retval)
              goto exit;
       retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
       if (retval)
              goto exit;

       /* keys passed in fROM the caller */
       if (envp_ext) {
              for (i = 0; envp_ext; i++) {
                     retval = add_uevent_var(env, "%s", envp_ext);//将我们设置的参数，添加到环境变量中去
                     if (retval)
                           goto exit;
              }
       }

       /* let the kset specific function add its stuff */
       if (uevent_ops && uevent_ops->uevent) {
              retval = uevent_ops->uevent(kset, kobj, env);
              if (retval) {
                     pr_debug("kobject: '%s' (%p): %s: uevent() returned "
                            "%d\n", kobject_name(kobj), kobj,
                            __func__, retval);
                     goto exit;
              }
       }

       /*
        * Mark "add" and "remove" events in the object to ensure proper
        * events to userspace during automatic cleanup. If the object did
        * send an "add" event, "remove" will automatically generated by
        * the core, if not already done by the caller.
        */
       if (action == KOBJ_ADD)
              kobj->state_add_uevent_sent = 1;
       elseif (action == KOBJ_REMOVE)
              kobj->state_remove_uevent_sent = 1;

       /* we will send an event, so request a new sequence number */
       SPIn_lock(&sequence_lock);
       seq = ++uevent_seqnum;
       spin_unlock(&sequence_lock);
       retval = add_uevent_var(env, "SEQNUM=%llu", (unsignedlonglong)seq);
       if (retval)
              goto exit;

#if defined(CONFIG_NET)
       /* send netlink message */
       mutex_lock(&uevent_sock_mutex);
       list_for_each_entry(ue_sk, &uevent_sock_list, list) {
              struct sock *uevent_sock = ue_sk->sk;
              struct sk_buff *skb;
              size_t len;

              /* allocate message with the maximum possible size */
              len = strlen(action_string) + strlen(devpath) + 2;
              skb = alloc_skb(len + env->buflen, GFP_KERNEL);
              if (skb) {
                     char *scratch;

                     /* add header */
                     scratch = skb_put(skb, len);
                     sprintf(scratch, "%s@%s", action_string, devpath);

                     /* copy keys to our continuous event payload buffer */
                     for (i = 0; i < env->envp_idx; i++) {
                           len = strlen(env->envp) + 1;
                           scratch = skb_put(skb, len);
                           strcpy(scratch, env->envp);
                     }

                     NETLINK_CB(skb).dst_group = 1;
                     retval = netlink_broADCast_filtered(uevent_sock, skb,
                                                    0, 1, GFP_KERNEL,
                                                    kobj_bcast_filter,
                                                    kobj);
                     /* ENOBUFS should be handled in userspace */
                     if (retval == -ENOBUFS)
                           retval = 0;
              } else
                     retval = -ENOMEM;
       }
       mutex_unlock(&uevent_sock_mutex);
#endif

       /* call uevent_helper, usually only enabled during early boot */
       if (uevent_helper[0] && ！kobj_usermode_filter(kobj)) {
              char *argv [3];

              argv [0] = uevent_helper;
              argv [1] = (char *)subsystem;
              argv [2] = NULL;
              retval = add_uevent_var(env, "HOME=/");
              if (retval)
                     goto exit;
              retval = add_uevent_var(env,
                                  "PATH=/sbin:/bin:/usr/sbin:/usr/bin");
              if (retval)
                     goto exit;

              retval = call_usermodehelper(argv[0], argv,
                                       env->envp, UMH_WAIT_EXEC);
       }

exit:
       kfree(devpath);
       kfree(env);
       return retval;
}
EXPORT_SYMBOL_GPL(kobject_uevent_env);


//看下如何将用户空间需要的参数添加到环境变量中去的?
///传进去需要的参数
//add_uevent_var(env, "%s", envp_ext);
//**
// * add_uevent_var - add key value string to the environment buffer
//* @env: environment buffer structure
// * @format: printf format for the key=value pair
// *
//* Returns 0 if environment variable was added successfully or -ENOMEM
// * if no space was available.
// */
int add_uevent_var(struct kobj_uevent_env *env, constchar *format, ...)
{
       va_list args;
       int len;

       if (env->envp_idx >= ARRAY_SIZE(env->envp)) {
              WARN(1, KERN_ERR "add_uevent_var: too many keys\n");
              return -ENOMEM;
       }

       va_start(args, format);
       len = vsnprintf(&env->buf[env->buflen],
                     sizeof(env->buf) - env->buflen,
                     format, args);
       va_end(args);

       if (len >= (sizeof(env->buf) - env->buflen)) {
              WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");
              return -ENOMEM;
       }

       env->envp[env->envp_idx++] = &env->buf[env->buflen];
       env->buflen += len + 1;
       return 0;
}
EXPORT_SYMBOL_GPL(add_uevent_var);
//上面的函数在将参数添加到环境变量中去，如果添加添加成功的话，那么就返回0
//http://blog.csdn.net/sunweizhong1024/article/details/7928530

怎么没有人回复呀！ 难都没有接触过这个。 5555555555555555555555555