内核设备模型分析

最新推荐文章于 2024-06-23 09:44:30 发布

转载最新推荐文章于 2024-06-23 09:44:30 发布 · 383 阅读

Sysfs文件系统

内核设备模型主要的模块和用户之间能看到的相关部分就是sysfs文件系统了。内核在启动的时候会注册sysfs文件系统，并且在启动系统的初期。通过mount命令挂载sysfs文件系统到/sys挂载点。

Mount -t sysfs sysfs /sys

那么sysfs文件系统的作用是什么呢。概括的说有三点：

1、建立系统中总线、驱动、设备三者之间的桥梁

2、像用户空间展示内核中各种设备的拓扑图

3、提供给用户空间对设备获取信息和操作的接口，部分取代ioctl功能。

Kobject

Sysfs文件系统中最基本的结构就是kobject，kobject可以代表一个设备，一条总线等。在sys目录下直观的以一个目录表示出来。

struct kobject
{
    const char *name;                   /* 对应sysfs的目录名 */
    struct list_head entry;             /* kobjetct双向链表 */
    struct kobject *parent;             /* 指向kset中的kobject，相当于指向父目录 */
    struct kset *kset;                     /*指向所属的kset */
    struct kobj_type *ktype;             /*负责对kobject结构跟踪*/
    struct sysfs_dirent *sd;             /*在 /sys 目录下对应的目录实例*/
    struct kref kref;                     /*kobject引用计数*/
    unsigned int state_initialized: 1;
    unsigned int state_in_sysfs: 1;
    unsigned int state_add_uevent_sent: 1;
    unsigned int state_remove_uevent_sent: 1;
    unsigned int uevent_suppress: 1;
};

Kobject结构中还有一个 kobj_type数据结构成员，该成员保护了kobject的属性和属性相关的操作函数。一个属性对应于kobject目录下的一个文件。在用户态可以通过读写来操作这个属性。

struct kobj_type
{
    void (*release)(struct kobject *kobj);
    struct sysfs_ops *sysfs_ops;
    struct attribute **default_attrs;
};

Kset

Kset可以认为是一组kobject的集合，kset首先自己是一个kobject。Kset处理将同类型的kobject组合到一起外，还有一个重要的作用就是当kset中的某些kobject对象发生了状态的改变需要通知到用户空间时，就会调用其中uevent相关的函数向用户空间发送消息来完成。

struct kset
{
    struct list_head list;
    spinlock_t list_lock;
    struct kobject kobj;
    struct kset_uevent_ops *uevent_ops;
};

下图描述了kset下挂接多个kobject时相应的数据结构连接。

Uevent机制

上面的分析其实只是对linux设备模型做了一些基础性的了解。也就是一个穿针引线的作用，如果要细致了解，需要仔细阅读代码。有了上面对于sysfs的基础。接下来我们来比较详细的了解一下uevent机制。

什么是uevent机制。这个得从热插拔设备开始说起。最简单的一个例子就是U盘了。当我们在计算机上插上一个U盘的时候，系统的USB hub会检测到U盘设备接入，并且完成设备枚举过程(从设备上读出相应的设备信息)，并在内核中创建相应的设备结构体。但是，usb设备千奇百态，内核不可能预先将所有usb设备驱动都增加到内存中来。也就是当插入U盘设备的时候，内核中不一定存在对应这个设备的usb驱动。这个时候USB驱动也许以模块的形式保存在硬盘上。载入驱动必然只能从用户态来进行，那这时候应该怎么办呢？

看到这里的时候，有人一定会想，人工敲入命令载入驱动，呵呵。这必然是一种方法，但是是一种很古老的方法。Linux对类似的情况设计了一种uevent的机制。当有新的设备加入的时候，将设备的信息发送消息到用户态。而用户态有一个udev的进程监听这个信息。当收到信息后做一定的解析，根据解析到的结果和用户程序的配置做一些处理，也包括加载驱动程序。

上图就是usb设备插入到主机后，usb hub检测到设备并添加设备，会调用到device_add函数，该函数会调用到kobject_uevent函数，想用户态发送KOBJ_ADD设备接入的消息。

int kobject_uevent(struct kobject *kobj, enum kobject_action action)
{
return kobject_uevent_env(kobj, action, NULL);
}
EXPORT_SYMBOL_GPL(kobject_uevent);

具体调用到kobject_uevent_env函数完成了消息的拼装和具体的发送。下面直接将这段代码贴出来并且附上关键部分的分析，函数长但是逻辑比较简单。

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                       char *envp_ext[])
{
    struct kobj_uevent_env *env;
    const char *action_string = kobject_actions[action];
    const char *devpath = NULL;
    const char *subsystem;
    struct kobject *top_kobj;
    struct kset *kset;
    struct kset_uevent_ops *uevent_ops;
    u64 seq;
    int i = 0;
    int retval = 0;

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

    /* search the kset we belong to */
    /*首先如果传入的kobj并没有直接指定kset，找齐上层kobj指定的kset*/
    top_kobj = kobj;
    while (!top_kobj->kset && top_kobj->parent)
        top_kobj = top_kobj->parent;

    /*如果这个kobj是孤立的，无kset指定，不发送uevent消息*/
    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;
    uevent_ops = kset->uevent_ops;

    /* skip the event, if the filter returns zero. */
    /*检查发送消息类型是不是要求被过滤掉，如果是就不要发送了*/
    if (uevent_ops && uevent_ops->filter)
        if (!uevent_ops->filter(kset, kobj))
        {
            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);
    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 */
    /*申请了一个kobj_uevent_env的结构体，之后将需要发送的信息
      填充到这个结构体中*/
    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;
    else if (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", (unsigned long long)seq);
    if (retval)
        goto exit;

#if defined(CONFIG_NET)
    /* send netlink message */
    /*使用netlink机制发送uevent消息到用户态*/
    if (uevent_sock)
    {
        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(uevent_sock, skb, 0, 1,
                                       GFP_KERNEL);
        }
        else
            retval = -ENOMEM;
    }
#endif

    /* call uevent_helper, usually only enabled during early boot */
    if (uevent_helper[0])
    {
        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);

Uevent的用户态部分是一个udev的后台进程，它随系统启动后监听内核发送到消息。主要执行的工作有两个：

1、自动加载驱动模块

2、根据uevent消息在/dev目录下自动添加或者删除设备节点

Udev进程相关的文档比较多，这里不再做详细的叙述。Udev进程在etc目录下面有一个uevent规则文件/etc/udev/rules.d/50-udev.rules类似的以.rules为后缀的文件。Udev程序收到uevent消息后，在这些规则文件中寻找匹配的规则，如果找到了就执行匹配的shell命令。