《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中了，如下：

static const struct android_id_info android_ids[] = {
    { "root",      AID_ROOT, },
    { "system",    AID_SYSTEM, },
    { "radio",     AID_RADIO, },
    { "bluetooth", AID_BLUETOOTH, },
    { "graphics",  AID_GRAPHICS, },
    { "input",     AID_INPUT, },
    { "audio",     AID_AUDIO, },
    { "camera",    AID_CAMERA, },
    { "log",       AID_LOG, },
    { "compass",   AID_COMPASS, },
    { "mount",     AID_MOUNT, },
    { "wifi",      AID_WIFI, },
    { "dhcp",      AID_DHCP, },
    { "adb",       AID_ADB, },
    { "install",   AID_INSTALL, },
    { "media",     AID_MEDIA, },
    { "drm",       AID_DRM, },
    { "mdnsr",     AID_MDNSR, },
    { "nfc",       AID_NFC, },
    { "drmrpc",    AID_DRMRPC, },
    { "shell",     AID_SHELL, },
    { "cache",     AID_CACHE, },
    { "diag",      AID_DIAG, },
    { "net_bt_admin", AID_NET_BT_ADMIN, },
    { "net_bt",    AID_NET_BT, },
    { "sdcard_r",  AID_SDCARD_R, },
    { "sdcard_rw", AID_SDCARD_RW, },
    { "media_rw",  AID_MEDIA_RW, },
    { "vpn",       AID_VPN, },
    { "keystore",  AID_KEYSTORE, },
    { "usb",       AID_USB, },
    { "mtp",       AID_MTP, },
    { "gps",       AID_GPS, },
    { "inet",      AID_INET, },
    { "net_raw",   AID_NET_RAW, },
    { "net_admin", AID_NET_ADMIN, },
    { "net_bw_stats", AID_NET_BW_STATS, },
    { "net_bw_acct", AID_NET_BW_ACCT, },
    { "misc",      AID_MISC, },
    { "nobody",    AID_NOBODY, },
};

這些uid、gid都是以宏的形式被定義：

#define AID_ROOT             0  /* traditional unix root user */
#define AID_SYSTEM        1000  /* system server */
#define AID_RADIO         1001  /* telephony subsystem, RIL */
#define AID_BLUETOOTH     1002  /* bluetooth subsystem */

通過調用get_android_id函數在數組android_ids中查找對應的uid、gid

static int get_android_id(const char *id)
{
    unsigned int i;
    for (i = 0; i < ARRAY_SIZE(android_ids); i++)
        if (!strcmp(id, android_ids[i].name))
            return android_ids[i].aid;
    return 0;
}

函數實現比較簡單，通過遍歷數組，並匹配數組元素的name屬性來查找指定name的uid或gid。

最後通過add_dev_perms函數來設置設備文件的操作權限，該函數定義在system\core\init\devices.c文件中，在該文件中聲明瞭三個鏈表：

static list_declare(sys_perms);
static list_declare(dev_perms);
static list_declare(platform_names);

add_dev_perms函數就是將解析得到的設備及設備屬性，添加到指定的鏈表中，

使用解析得到的內容來創建一個perm_node變量，並根據條件添加到sys_perms或dev_perms鏈表中。

int add_dev_perms(const char *name, const char *attr,
                  mode_t perm, unsigned int uid, unsigned int gid,
                  unsigned short prefix) {
    //創建perm_node
    struct perm_node *node = calloc(1, sizeof(*node));
    if (!node)
        return -ENOMEM;

    node->dp.name = strdup(name);
    if (!node->dp.name)
        return -ENOMEM;

    if (attr) {
        node->dp.attr = strdup(attr);
        if (!node->dp.attr)
            return -ENOMEM;
    }
    //設置perm_node的成員屬性
    node->dp.perm = perm;
    node->dp.uid = uid;
    node->dp.gid = gid;
    node->dp.prefix = prefix;
    //根據attr 來選擇添加到sys_perms或dev_perms鏈表中
    if (attr)
        list_add_tail(&sys_perms, &node->plist);
    else
        list_add_tail(&dev_perms, &node->plist);
    return 0;
}

至此ueventd.rc文件的解析工作完成了，uevent進程接下來將調用device_init()函數來初始化設備文件

void device_init(void)
{
    suseconds_t t0, t1;
    struct stat info;
    int fd;
#ifdef HAVE_SELINUX
    struct selinux_opt seopts[] = {
        { SELABEL_OPT_PATH, "/file_contexts" }
    };
    if (is_selinux_enabled() > 0)
        sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
#endif
    /* is 64K enough? udev uses 16MB! */
    //創建NETLINK socket，用於監聽內核發送過來的uevent消息
    device_fd = uevent_open_socket(64*1024, true);
    if(device_fd < 0)
        return;
    //設置socket相關屬性
    fcntl(device_fd, F_SETFD, FD_CLOEXEC);
    fcntl(device_fd, F_SETFL, O_NONBLOCK);
    //查看"/dev/.coldboot_done" 文件信息
    if (stat(coldboot_done, &info) < 0) {
        t0 = get_usecs();
        coldboot("/sys/class");
        coldboot("/sys/block");
        coldboot("/sys/devices");
        t1 = get_usecs();
        fd = open(coldboot_done, O_WRONLY|O_CREAT, 0000);
        close(fd);
        log_event_print("coldboot %ld uS\n", ((long) (t1 - t0)));
    } else {
        log_event_print("skipping coldboot, already done\n");
    }
}

函數首先調用uevent_open_socket 來創建PF_NETLINK socket 並綁定到指定地址上：

int uevent_open_socket(int buf_sz, bool passcred)
{
    struct sockaddr_nl addr;
    int on = passcred;
    int s;

    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid();
    addr.nl_groups = 0xffffffff;
    //創建socket
    s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
    if(s < 0)
        return -1;
    //設置該socket屬性
    setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &buf_sz, sizeof(buf_sz));
    setsockopt(s, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
    //綁定該socket
    if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        close(s);
        return -1;
    }
    return s;
}

ueventd進程接下來將通過系統調用poll函數來監控該socket，如下所示：

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();
}

函數get_device_fd()返回創建的socket句柄值，並設置到ufd中，最後ueventd進程進入閉環監控模式，使用poll函數監控ufd，同時將第三個參數設置爲-1，表示只有在監控的socket上有事件發生時，該函數才能返回。當熱插入某一設備時，Linux內核將通過NETLINKsocket 發送uevent事件，此時poll函數得以返回，並調用handle_device_fd()函數來出來設備變化事件：

void handle_device_fd()
{
    char msg[UEVENT_MSG_LEN+2];
    int n;
    //從socket中讀取消息內容
    while ((n = uevent_kernel_multicast_recv(device_fd, msg, UEVENT_MSG_LEN)) > 0) {
        //如果讀取的內容長度大於1024，繼續讀取
        if(n >= UEVENT_MSG_LEN)   /* overflow -- discard */
            continue;

        msg[n] = '\0';
        msg[n+1] = '\0';
        //將uevent消息解析成uevent類型的事件
        struct uevent uevent;
        parse_event(msg, &uevent);
        //處理uevent事件
        handle_device_event(&uevent);
        handle_firmware_event(&uevent);
    }
}

當有設備事件發生時，poll函數返回，並從socket中讀取內核發送過來的消息內容，並將該消息解析成uevent事件，同時調用handle_device_event函數和handle_firmware_event函數來分別處理設備事件或firmware事件

static void handle_device_event(struct uevent *uevent)
{
    //如果是設備添加事件
    if (!strcmp(uevent->action,"add"))
        fixup_sys_perms(uevent->path);
    //塊設備事件
    if (!strncmp(uevent->subsystem, "block", 5)) {
        handle_block_device_event(uevent);
    //平臺設備事件
    } else if (!strncmp(uevent->subsystem, "platform", 8)) {
        handle_platform_device_event(uevent);
    //通用設備事件
    } else {
        handle_generic_device_event(uevent);
    }
}

 

static void handle_firmware_event(struct uevent *uevent)
{
    pid_t pid;
    int ret;
    if(strcmp(uevent->subsystem, "firmware"))
        return;
    if(strcmp(uevent->action, "add"))
        return;
    //創建一個線程來專門執行firmware事件
    /* we fork, to avoid making large memory allocations in init proper */
    pid = fork();
    if (!pid) {
        process_firmware_event(uevent);
        exit(EXIT_SUCCESS);
    }
}

具體的處理過程這裏不在詳細分析，讀者有興趣請自行分析！至此就介紹完了整個ueventd進程的工作，