《Linux设备节点创建》用户空间ueventd创建设备节点规则


一、devfs、udev和sysfs是什么关系？

linux2.6之前使用devfs设备文件系统，它存在与内核空间；

linux2.6之后使用udev设备文件系统，它存在与用户空间、但严重依赖与sysfs文件系统。



二、Android(使用linux2.6以后的设备节点创建策略)设备节点的创建

  在Android中，没有独立的类似于udev或者mdev的用户程序，这个功能集成到了init中做了。代码见：system/core/init/init.c文件，如下：


int ueventd_main(int argc, char **argv)  
{  
    struct pollfd ufd;  
    int nr;  
    char tmp[32];  
 
    open_devnull_stdio();  
    log_init();  
 
    INFO("starting ueventd\n");  
 
    get_hardware_name(hardware, &revision);  
 
/*
/ueventd.rc中以行为单位，除最后sysfs properties外，每一行由四部分组成：
如:/dev/diag      0660   radio             radio
   目录          权限   用户ID（uid)     组ID（gid）         
# sysfs properties 多一个属性
/sys/devices/virtual/input/input*   enable      0660  root   input
    目录  属性    权限   用户ID（uid)     组ID（gid）    
*/  
    ueventd_parse_config_file("/ueventd.rc");  
 
    snprintf(tmp, sizeof(tmp), "/ueventd.%s.rc", hardware);  
    ueventd_parse_config_file(tmp);  
 
//初始化uevent，建立socket，执行coldboot，用于检查当前service启动前操作系统已经处理的事件，add这些事件到应用层  
    device_init();  
 
    ufd.events = POLLIN;  
    ufd.fd = get_device_fd();  
 
//在死循环中处理触发事件  
    while(1) {  
        ufd.revents = 0;  
        nr = poll(&ufd, 1, -1);  
        if (nr <= 0)  
            continue;  
        if (ufd.revents == POLLIN)  
               handle_device_fd();  
    }  
}


int ueventd_parse_config_file(const char *fn)  
{  
    char *data;  
    data = read_file(fn, 0); //读取文件内容返回给data；
    if (!data) return -1;  
 
    parse_config(fn, data);   //解析整个rc文件内容 

    DUMP();     //空函数什么都不做  
    return 0;  
} 


以上步骤和Init进程解析init.rc文件的步骤相同，不过这里调用的parse_config函数不同，该函数是专门用于解析ueventd.rc文件的，具体解析过程如下：


static void parse_config(const char *fn, char *s)  
{  
    struct parse_state state;  
    char *args[UEVENTD_PARSER_MAXARGS];   //最多五个参数  
    int nargs;  
    nargs = 0;  
    state.filename = fn;  //设置解析文件的路径

    state.line = 1;  
    state.ptr = s;     //文件内容

    state.nexttoken = 0;   
    state.parse_line = parse_line_device;  //设置每行解析回调函数 

    for (;;) {  
        int token = next_token(&state); //用于获得配置文件中特殊标记，如文件结尾（T_EOF），换行符（T_TEXT），文本（T_NEWLINE） ，从文件内容中查找token，与init.rc文件类似；

        switch (token) {  
        case T_EOF:  //文件结束
            state.parse_line(&state, 0, 0); //state.parse_line 调用函数为parse_line_device;   
            return;  
        case T_NEWLINE:  //新的一行
            if (nargs) {  
                state.parse_line(&state, nargs, args);  //调用行解析函数解析每一行

                nargs = 0;  
            }  
            break;  
        case T_TEXT:  
            if (nargs < UEVENTD_PARSER_MAXARGS) {  
                args[nargs++] = state.text;  
            }  
            break;  
        }  
    }  
}


函数首先查找指定的token，然后对不同的token做不同的处理，对于发现新行时，调用parse_line_device函数对每一行进行详细解析，该函数实现如下：


int next_token(struct parse_state *state)  
{  
    char *x = state->ptr;   //读数据指针  
    char *s;  
/*
#define T_EOF 0
#define T_TEXT 1
#define T_NEWLINE 2
非T_EOF时，直接返回下一个标记
*/  
    if (state->nexttoken) {  
        int t = state->nexttoken;  
        state->nexttoken = 0;  
        return t;  
    }  
 
    for (;;) {  
        switch (*x) {  
        case 0:  
            state->ptr = x;  
            return T_EOF;    
        case '\n':  
            x++;  
            state->ptr = x;  
            return T_NEWLINE; //换行符  
        case ' ':  
        case '\t':  
        case '\r':  
            x++;  
            continue;  //跳过转义字符 ：空格 tab 回车  
        case '#':  
            while (*x && (*x != '\n')) x++;  //单行注释  
            if (*x == '\n') {  
                state->ptr = x+1;  
                return T_NEWLINE;  
            } else {  
                state->ptr = x;  
                return T_EOF;  
            }  
        default:  
            goto text;  
        }  
    }  
 
textdone:  
    state->ptr = x;  
    *s = 0;  
    return T_TEXT;  
text:  
    state->text = s = x;  
textresume:  
    for (;;) {  
        switch (*x) {  
        case 0:  
            goto textdone;  
        case ' ':  
        case '\t':  
        case '\r':  
            x++;  
            goto textdone;  
        case '\n':  
            state->nexttoken = T_NEWLINE;  
            x++;  
            goto textdone;  
        case '"':  
            x++;  
            for (;;) {  
                switch (*x) {  
                case 0:  
                        /* unterminated quoted thing */  
                    state->ptr = x;  
                    return T_EOF;  
                case '"':  
                    x++;  
                    goto textresume;  
                default:  
                    *s++ = *x++;  
                }  
            }  
            break;  
        case '\\':  
            x++;  
            switch (*x) {  
            case 0:  
                goto textdone;  
            case 'n':  
                *s++ = '\n';  
                break;  
            case 'r':  
                *s++ = '\r';  
                break;  
            case 't':  
                *s++ = '\t';  
                break;  
            case '\\':  
                *s++ = '\\';  
                break;  
            case '\r':  
                    /* \ <cr> <lf> -> line continuation */  
                if (x[1] != '\n') {  
                    x++;  
                    continue;  
                }  
            case '\n':  
                    /* \ <lf> -> line continuation */  
                state->line++;  
                x++;  
                    /* eat any extra whitespace */  
                while((*x == ' ') || (*x == '\t')) x++;  
                continue;  
            default:  
                    /* unknown escape -- just copy */  
                *s++ = *x++;  
            }  
            continue;  
        default:  
            *s++ = *x++;  
        }  
    }  
    return T_EOF;  
}



static void parse_line_device(struct parse_state* state, int nargs, char **args)  
{  
    set_device_permission(nargs, args);  //nargs参数个数 args参数  
}


函数直接调用set_device_permission来实现；


非sysfs 设备文件：

|name|  |permission| |user| |group|

/dev/cam   0660   root       ca

sysfs 设备文件属性：
/sys/devices/virtual/input/input*   enable      0660  root   input



void set_device_permission(int nargs, char **args)  
{  
    char *name;  
    char *attr = 0;  
    mode_t perm;  
    uid_t uid;  
    gid_t gid;  
    int prefix = 0;  
    char *endptr;  
    int ret;  
    char *tmp = 0;  
 
    if (nargs == 0)  
        return;  
 
    if (args[0][0] == '#')  
        return;  
/*  |name|  |permission| |user| |group|  */  
    name = args[0];  
    if (!strncmp(name,"/sys/", 5) && (nargs == 5)) {  
        INFO("/sys/ rule %s %s\n",args[0],args[1]);  
        attr = args[1];  
        args++;  
        nargs--;  
    }  
    //参数检查  
    if (nargs != 4) {  
        ERROR("invalid line ueventd.rc line for '%s'\n", args[0]);  
        return;  
    }  
    /* If path starts with mtd@ lookup the mount number. */  
    if (!strncmp(name, "mtd@", 4)) {  
        int n = mtd_name_to_number(name + 4);  
        if (n >= 0)  
            asprintf(&tmp, "/dev/mtd/mtd%d", n);  
        name = tmp;  
    } else {  
        int len = strlen(name);  
        if (name[len - 1] == '*') {  
            prefix = 1;  
            name[len - 1] = '\0';  
        }  
    }  
    //权限检查  
    perm = strtol(args[1], &endptr, 8);  
    if (!endptr || *endptr != '\0') {  
        ERROR("invalid mode '%s'\n", args[1]);  
        free(tmp);  
        return;  
    }  
    //从android_ids数组中查找uid  
    ret = get_android_id(args[2]);  
    if (ret < 0) {  
        ERROR("invalid uid '%s'\n", args[2]);  
        free(tmp);  
        return;  
    }  
    uid = ret;  
    //从android_ids数组中查找gid  
    ret = get_android_id(args[3]);  
    if (ret < 0) {  
        ERROR("invalid gid '%s'\n", args[3]);  
        free(tmp);  
        return;  
    }  
    gid = ret;  
    //为设备文件添加权限  
    add_dev_perms(name, attr, perm, uid, gid, prefix);  
    free(tmp);  
}


首先检查参数的合法性，并根据参数查找uid、gid，对不同的用户和组的uid、gid已经事先配置在数组android_ids中了，如下：

[cpp] view plain copy
  1. static const struct android_id_info android_ids[] = {  
  2.     { "root",      AID_ROOT, },  
  3.     { "system",    AID_SYSTEM, },  
  4.     { "radio",     AID_RADIO, },  
  5.     { "bluetooth", AID_BLUETOOTH, },  
  6.     { "graphics",  AID_GRAPHICS, },  
  7.     { "input",     AID_INPUT, },  
  8.     { "audio",     AID_AUDIO, },  
  9.     { "camera",    AID_CAMERA, },  
  10.     { "log",       AID_LOG, },  
  11.     { "compass",   AID_COMPASS, },  
  12.     { "mount",     AID_MOUNT, },  
  13.     { "wifi",      AID_WIFI, },  
  14.     { "dhcp",      AID_DHCP, },  
  15.     { "adb",       AID_ADB, },  
  16.     { "install",   AID_INSTALL, },  
  17.     { "media",     AID_MEDIA, },  
  18.     { "drm",       AID_DRM, },  
  19.     { "mdnsr",     AID_MDNSR, },  
  20.     { "nfc",       AID_NFC, },  
  21.     { "drmrpc",    AID_DRMRPC, },  
  22.     { "shell",     AID_SHELL, },  
  23.     { "cache",     AID_CACHE, },  
  24.     { "diag",      AID_DIAG, },  
  25.     { "net_bt_admin", AID_NET_BT_ADMIN, },  
  26.     { "net_bt",    AID_NET_BT, },  
  27.     { "sdcard_r",  AID_SDCARD_R, },  
  28.     { "sdcard_rw", AID_SDCARD_RW, },  
  29.     { "media_rw",  AID_MEDIA_RW, },  
  30.     { "vpn",       AID_VPN, },  
  31.     { "keystore",  AID_KEYSTORE, },  
  32.     { "usb",       AID_USB, },  
  33.     { "mtp",       AID_MTP, },  
  34.     { "gps",       AID_GPS, },  
  35.     { "inet",      AID_INET, },  
  36.     { "net_raw",   AID_NET_RAW, },  
  37.     { "net_admin", AID_NET_ADMIN, },  
  38.     { "net_bw_stats", AID_NET_BW_STATS, },  
  39.     { "net_bw_acct", AID_NET_BW_ACCT, },  
  40.     { "misc",      AID_MISC, },  
  41.     { "nobody",    AID_NOBODY, },  
  42. };  

这些uid、gid都是以宏的形式被定义：

[cpp] view plain copy
  1. #define AID_ROOT             0  /* traditional unix root user */  
  2. #define AID_SYSTEM        1000  /* system server */  
  3. #define AID_RADIO         1001  /* telephony subsystem, RIL */  
  4. #define AID_BLUETOOTH     1002  /* bluetooth subsystem */  

通过调用get_android_id函数在数组android_ids中查找对应的uid、gid

[cpp] view plain copy
  1. static int get_android_id(const char *id)  
  2. {  
  3.     unsigned int i;  
  4.     for (i = 0; i < ARRAY_SIZE(android_ids); i++)  
  5.         if (!strcmp(id, android_ids[i].name))  
  6.             return android_ids[i].aid;  
  7.     return 0;  
  8. }  

函数实现比较简单，通过遍历数组，并匹配数组元素的name属性来查找指定name的uid或gid。


最后通过add_dev_perms函数来设置设备文件的操作权限，该函数定义在system\core\init\devices.c文件中，在该文件中声明了三个链表：

[cpp] view plain copy
  1. static list_declare(sys_perms);  
  2. static list_declare(dev_perms);  
  3. static list_declare(platform_names);  

add_dev_perms函数就是将解析得到的设备及设备属性，添加到指定的链表中，

使用解析得到的内容来创建一个perm_node变量，并根据条件添加到sys_perms或dev_perms链表中。



  1. int add_dev_perms(const char *name, const char *attr,  
  2.                   mode_t perm, unsigned int uid, unsigned int gid,  
  3.                   unsigned short prefix) {  
  4.     //创建perm_node  
  5.     struct perm_node *node = calloc(1, sizeof(*node));  
  6.     if (!node)  
  7.         return -ENOMEM;  
  8.   
  9.     node->dp.name = strdup(name);  
  10.     if (!node->dp.name)  
  11.         return -ENOMEM;  
  12.   
  13.     if (attr) {  
  14.         node->dp.attr = strdup(attr);  
  15.         if (!node->dp.attr)  
  16.             return -ENOMEM;  
  17.     }  
  18.     //设置perm_node的成员属性  
  19.     node->dp.perm = perm;  
  20.     node->dp.uid = uid;  
  21.     node->dp.gid = gid;  
  22.     node->dp.prefix = prefix;  
  23.     //根据attr 来选择添加到sys_perms或dev_perms链表中  
  24.     if (attr)  
  25.         list_add_tail(&sys_perms, &node->plist);  
  26.     else  
  27.         list_add_tail(&dev_perms, &node->plist);  
  28.     return 0;  
  29. } 

至此ueventd.rc文件的解析工作完成了，uevent进程接下来将调用device_init()函数来初始化设备文件

[cpp] view plain copy
  1. void device_init(void)  
  2. {  
  3.     suseconds_t t0, t1;  
  4.     struct stat info;  
  5.     int fd;  
  6. #ifdef HAVE_SELINUX  
  7.     struct selinux_opt seopts[] = {  
  8.         { SELABEL_OPT_PATH, "/file_contexts" }  
  9.     };  
  10.     if (is_selinux_enabled() > 0)  
  11.         sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);  
  12. #endif  
  13.     /* is 64K enough? udev uses 16MB! */  
  14.     //创建NETLINK socket，用于监听内核发送过来的uevent消息  
  15.     device_fd = uevent_open_socket(64*1024, true);  
  16.     if(device_fd < 0)  
  17.         return;  
  18.     //设置socket相关属性  
  19.     fcntl(device_fd, F_SETFD, FD_CLOEXEC);  
  20.     fcntl(device_fd, F_SETFL, O_NONBLOCK);  
  21.     //查看"/dev/.coldboot_done" 文件信息  
  22.     if (stat(coldboot_done, &info) < 0) {  
  23.         t0 = get_usecs();  
  24.         coldboot("/sys/class");  
  25.         coldboot("/sys/block");  
  26.         coldboot("/sys/devices");  
  27.         t1 = get_usecs();  
  28.         fd = open(coldboot_done, O_WRONLY|O_CREAT, 0000);  
  29.         close(fd);  
  30.         log_event_print("coldboot %ld uS\n", ((long) (t1 - t0)));  
  31.     } else {  
  32.         log_event_print("skipping coldboot, already done\n");  
  33.     }  
  34. }  

函数首先调用uevent_open_socket 来创建PF_NETLINK socket 并绑定到指定地址上：

[cpp] view plain copy
  1. int uevent_open_socket(int buf_sz, bool passcred)  
  2. {  
  3.     struct sockaddr_nl addr;  
  4.     int on = passcred;  
  5.     int s;  
  6.       
  7.     memset(&addr, 0, sizeof(addr));  
  8.     addr.nl_family = AF_NETLINK;  
  9.     addr.nl_pid = getpid();  
  10.     addr.nl_groups = 0xffffffff;  
  11.     //创建socket  
  12.     s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);  
  13.     if(s < 0)  
  14.         return -1;  
  15.     //设置该socket属性  
  16.     setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &buf_sz, sizeof(buf_sz));  
  17.     setsockopt(s, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));  
  18.     //绑定该socket  
  19.     if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {  
  20.         close(s);  
  21.         return -1;  
  22.     }  
  23.     return s;  
  24. }  

ueventd进程接下来将通过系统调用poll函数来监控该socket，如下所示：

[cpp] view plain copy
  1. ufd.events = POLLIN;  
  2. ufd.fd = get_device_fd();  
  3.   
  4. while(1) {  
  5.     ufd.revents = 0;  
  6.     nr = poll(&ufd, 1, -1);  
  7.     if (nr <= 0)  
  8.         continue;  
  9.     if (ufd.revents == POLLIN)  
  10.            handle_device_fd();  
  11. }  

函数get_device_fd()返回创建的socket句柄值，并设置到ufd中，最后ueventd进程进入闭环监控模式，使用poll函数监控ufd，同时将第三个参数设置为-1，表示只有在监控的socket上有事件发生时，该函数才能返回。当热插入某一设备时，Linux内核将通过NETLINKsocket 发送uevent事件，此时poll函数得以返回，并调用handle_device_fd()函数来出来设备变化事件：

[cpp] view plain copy
  1. void handle_device_fd()  
  2. {  
  3.     char msg[UEVENT_MSG_LEN+2];  
  4.     int n;  
  5.     //从socket中读取消息内容  
  6.     while ((n = uevent_kernel_multicast_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {  
  7.         //如果读取的内容长度大于1024，继续读取  
  8.         if(n >= UEVENT_MSG_LEN)   /* overflow -- discard */  
  9.             continue;  
  10.   
  11.         msg[n] = '\0';  
  12.         msg[n+1] = '\0';  
  13.         //将uevent消息解析成uevent类型的事件  
  14.         struct uevent uevent;  
  15.         parse_event(msg, &uevent);  
  16.         //处理uevent事件  
  17.         handle_device_event(&uevent);  
  18.         handle_firmware_event(&uevent);  
  19.     }  
  20. }  

当有设备事件发生时，poll函数返回，并从socket中读取内核发送过来的消息内容，并将该消息解析成uevent事件，同时调用handle_device_event函数和handle_firmware_event函数来分别处理设备事件或firmware事件

[cpp] view plain copy
  1. static void handle_device_event(struct uevent *uevent)  
  2. {  
  3.     //如果是设备添加事件  
  4.     if (!strcmp(uevent->action,"add"))  
  5.         fixup_sys_perms(uevent->path);  
  6.     //块设备事件  
  7.     if (!strncmp(uevent->subsystem, "block", 5)) {  
  8.         handle_block_device_event(uevent);  
  9.     //平台设备事件  
  10.     } else if (!strncmp(uevent->subsystem, "platform", 8)) {  
  11.         handle_platform_device_event(uevent);  
  12.     //通用设备事件  
  13.     } else {  
  14.         handle_generic_device_event(uevent);  
  15.     }  
  16. }  

 

[cpp] view plain copy
  1. static void handle_firmware_event(struct uevent *uevent)  
  2. {  
  3.     pid_t pid;  
  4.     int ret;  
  5.     if(strcmp(uevent->subsystem, "firmware"))  
  6.         return;  
  7.     if(strcmp(uevent->action, "add"))  
  8.         return;  
  9.     //创建一个线程来专门执行firmware事件  
  10.     /* we fork, to avoid making large memory allocations in init proper */  
  11.     pid = fork();  
  12.     if (!pid) {  
  13.         process_firmware_event(uevent);  
  14.         exit(EXIT_SUCCESS);  
  15.     }  
  16. }  

具体的处理过程这里不在详细分析，读者有兴趣请自行分析！至此就介绍完了整个ueventd进程的工作，












posted @ 2016-08-16 15:17  点点爱梦  阅读(942)  评论(0)  编辑  收藏  举报