Uevent 上报event事件给上层的详细讲解

                                                headphone_event 上报事件的分析

 本文章讲解插入headphone的时候，向上层上报event函数的整个过程

headphone_event(wm8903->hp_state);

当有headphone 插入的时候，那么就将hp_state的状态设置为1

 

#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函数进行上报事件

 

staticstruct 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里面实现的如下：

staticstruct 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]; i++) {

                     retval = add_uevent_var(env, "%s", envp_ext[i]);//将我们设置的参数，添加到环境变量中去

                     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[i]) + 1;

                           scratch = skb_put(skb, len);

                           strcpy(scratch, env->envp[i]);

                     }

 

                     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[i]);

**

 * 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