create static nodes provided by kernel modules to allow module autoloading

diff --git a/rules/rules.d/50-udev-default.rules b/rules/rules.d/50-udev-default.rules
index 7e09ea19bb1bf18c23cf2f8797b943c398c59932..d4da4b14a2e3be846c3f4cf86ecd11d0581b700e 100644 (file)
--- a/rules/rules.d/50-udev-default.rules
+++ b/rules/rules.d/50-udev-default.rules
@@ -8,12 +8,10 @@ KERNEL=="tty[pqrstuvwxyzabcdef][0123456789abcdef]", GROUP="tty", MODE="0660"
 KERNEL=="ptmx",                        GROUP="tty", MODE="0666"
 KERNEL=="tty",                 GROUP="tty", MODE="0666"
 KERNEL=="tty[0-9]*",           GROUP="tty", MODE="0620"
 KERNEL=="ptmx",                        GROUP="tty", MODE="0666"
 KERNEL=="tty",                 GROUP="tty", MODE="0666"
 KERNEL=="tty[0-9]*",           GROUP="tty", MODE="0620"

-KERNEL=="console",             MODE="0600"

 KERNEL=="vcs|vcs[0-9]*|vcsa|vcsa[0-9]*", GROUP="tty"
 
 # serial
 KERNEL=="tty[A-Z]*[0-9]|pppox[0-9]*|ircomm[0-9]*|noz[0-9]*|rfcomm[0-9]*", GROUP="dialout"
 KERNEL=="vcs|vcs[0-9]*|vcsa|vcsa[0-9]*", GROUP="tty"
 
 # serial
 KERNEL=="tty[A-Z]*[0-9]|pppox[0-9]*|ircomm[0-9]*|noz[0-9]*|rfcomm[0-9]*", GROUP="dialout"

-KERNEL=="ppp",                 MODE="0600"

 KERNEL=="mwave",               GROUP="dialout"
 KERNEL=="hvc*|hvsi*",          GROUP="dialout"
 
 KERNEL=="mwave",               GROUP="dialout"
 KERNEL=="hvc*|hvsi*",          GROUP="dialout"
 


@@ -36,7 +34,7 @@ KERNEL=="vtx*|vbi*",          GROUP="video"
 KERNEL=="winradio*",           GROUP="video"
 
 # graphics
 KERNEL=="winradio*",           GROUP="video"
 
 # graphics

-KERNEL=="agpgart",             MODE="0600", GROUP="video"
+KERNEL=="agpgart",             GROUP="video"

 KERNEL=="pmu",                 GROUP="video"
 KERNEL=="nvidia*|nvidiactl*",  GROUP="video"
 SUBSYSTEM=="graphics",         GROUP="video"
 KERNEL=="pmu",                 GROUP="video"
 KERNEL=="nvidia*|nvidiactl*",  GROUP="video"
 SUBSYSTEM=="graphics",         GROUP="video"


@@ -100,14 +98,14 @@ SUBSYSTEM=="aoe", GROUP="disk", MODE="0220"
 SUBSYSTEM=="aoe", KERNEL=="err", MODE="0440"
 
 # network
 SUBSYSTEM=="aoe", KERNEL=="err", MODE="0440"
 
 # network

-KERNEL=="tun",                 MODE="0666"
+KERNEL=="tun",                 MODE="0666", OPTIONS+="static_node=net/tun"

 KERNEL=="rfkill",              MODE="0644"
 
 # CPU
 KERNEL=="cpu[0-9]*",           MODE="0444"
 
 # miscellaneous
 KERNEL=="rfkill",              MODE="0644"
 
 # CPU
 KERNEL=="cpu[0-9]*",           MODE="0444"
 
 # miscellaneous

-KERNEL=="fuse",                        MODE="0666"
+KERNEL=="fuse",                        MODE="0666", OPTIONS+="static_node=fuse"

 SUBSYSTEM=="rtc", DRIVERS=="rtc_cmos", SYMLINK+="rtc"
 KERNEL=="mmtimer",             MODE="0644"
 KERNEL=="rflash[0-9]*",                MODE="0400"
 SUBSYSTEM=="rtc", DRIVERS=="rtc_cmos", SYMLINK+="rtc"
 KERNEL=="mmtimer",             MODE="0644"
 KERNEL=="rflash[0-9]*",                MODE="0400"

diff --git a/udev/udev-node.c b/udev/udev-node.c
index d55700d70fe7df39aff8bf46da5b08b2b2e9ca93..8339eb732f0bd8b42e9a57be8aed5d5a823c9a26 100644 (file)
--- a/udev/udev-node.c
+++ b/udev/udev-node.c
@@ -72,22 +72,22 @@ int udev_node_mknod(struct udev_device *dev, const char *file, mode_t mode, uid_
                        err = mknod(file_tmp, mode, devnum);
                        udev_selinux_resetfscreatecon(udev);
                        if (err != 0) {
                        err = mknod(file_tmp, mode, devnum);
                        udev_selinux_resetfscreatecon(udev);
                        if (err != 0) {

-                               err(udev, "mknod(%s, %#o, %u, %u) failed: %m\n",
-                                   file_tmp, mode, major(devnum), minor(devnum));
+                               err(udev, "mknod '%s' %u:%u %#o failed: %m\n",
+                                   file_tmp, major(devnum), minor(devnum), mode);

                                goto exit;
                        }
                        err = rename(file_tmp, file);
                        if (err != 0) {
                                goto exit;
                        }
                        err = rename(file_tmp, file);
                        if (err != 0) {

-                               err(udev, "rename(%s, %s) failed: %m\n", file_tmp, file);
+                               err(udev, "rename '%s' '%s' failed: %m\n", file_tmp, file);

                                unlink(file_tmp);
                                goto exit;
                        }
                                unlink(file_tmp);
                                goto exit;
                        }

-                       info(udev, "set permissions %s, %#o, uid=%u, gid=%u\n", file, mode, uid, gid);
+                       info(udev, "set permissions '%s' %#o uid=%u gid=%u\n", file, mode, uid, gid);

                        chmod(file, mode);
                        chown(file, uid, gid);
                }
        } else {
                        chmod(file, mode);
                        chown(file, uid, gid);
                }
        } else {

-               info(udev, "mknod(%s, %#o, (%u,%u))\n", file, mode, major(devnum), minor(devnum));
+               info(udev, "mknod '%s' %u:%u %#o\n", file, major(devnum), minor(devnum), mode);

                do {
                        err = util_create_path(udev, file);
                        if (err != 0 && err != -ENOENT)
                do {
                        err = util_create_path(udev, file);
                        if (err != 0 && err != -ENOENT)


@@ -99,8 +99,8 @@ int udev_node_mknod(struct udev_device *dev, const char *file, mode_t mode, uid_
                        udev_selinux_resetfscreatecon(udev);
                } while (err == -ENOENT);
                if (err != 0)
                        udev_selinux_resetfscreatecon(udev);
                } while (err == -ENOENT);
                if (err != 0)

-                       err(udev, "mknod(%s, %#o, (%u,%u) failed: %m\n", file, mode, major(devnum), minor(devnum));
-               info(udev, "set permissions %s, %#o, uid=%u, gid=%u\n", file, mode, uid, gid);
+                       err(udev, "mknod '%s' %u:%u %#o' failed: %m\n", file, major(devnum), minor(devnum), mode);
+               info(udev, "set permissions '%s' %#o uid=%u gid=%u\n", file, mode, uid, gid);

                chmod(file, mode);
                chown(file, uid, gid);
        }
                chmod(file, mode);
                chown(file, uid, gid);
        }


@@ -204,12 +204,12 @@ static int node_symlink(struct udev *udev, const char *node, const char *slink)
                udev_selinux_resetfscreatecon(udev);
        } while (err == -ENOENT);
        if (err != 0) {
                udev_selinux_resetfscreatecon(udev);
        } while (err == -ENOENT);
        if (err != 0) {

-               err(udev, "symlink(%s, %s) failed: %m\n", target, slink_tmp);
+               err(udev, "symlink '%s' '%s' failed: %m\n", target, slink_tmp);

                goto exit;
        }
        err = rename(slink_tmp, slink);
        if (err != 0) {
                goto exit;
        }
        err = rename(slink_tmp, slink);
        if (err != 0) {

-               err(udev, "rename(%s, %s) failed: %m\n", slink_tmp, slink);
+               err(udev, "rename '%s' '%s' failed: %m\n", slink_tmp, slink);

                unlink(slink_tmp);
        }
 exit:
                unlink(slink_tmp);
        }
 exit:


@@ -396,7 +396,6 @@ int udev_node_remove(struct udev_device *dev)
        const char *devnode;
        struct stat stats;
        struct udev_device *dev_check;
        const char *devnode;
        struct stat stats;
        struct udev_device *dev_check;

-       char filename[UTIL_PATH_SIZE];

        int err = 0;
 
        /* remove/update symlinks, remove symlinks from name index */
        int err = 0;
 
        /* remove/update symlinks, remove symlinks from name index */


@@ -426,12 +425,6 @@ int udev_node_remove(struct udev_device *dev)
                goto out;
        }
 
                goto out;
        }
 

-       util_strscpyl(filename, sizeof(filename), LIBEXECDIR "/devices", &devnode[strlen(udev_get_dev_path(udev))], NULL);
-       if (stat(filename, &stats) == 0 && stats.st_rdev == udev_device_get_devnum(dev)) {
-               info(udev, "static device entry found '%s', skip removal\n", devnode);
-               goto out;
-       }
-

        info(udev, "removing device node '%s'\n", devnode);
        err = util_unlink_secure(udev, devnode);
        util_delete_path(udev, devnode);
        info(udev, "removing device node '%s'\n", devnode);
        err = util_unlink_secure(udev, devnode);
        util_delete_path(udev, devnode);

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 8fc804a3c2a863e7758514f97b4e686d7a15ed47..5dcd760c55956447bce490810cf377e05d9020a9 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -157,6 +157,7 @@ enum token_type {
        TK_A_OWNER_ID,                  /* uid_t */
        TK_A_GROUP_ID,                  /* gid_t */
        TK_A_MODE_ID,                   /* mode_t */
        TK_A_OWNER_ID,                  /* uid_t */
        TK_A_GROUP_ID,                  /* gid_t */
        TK_A_MODE_ID,                   /* mode_t */

+       TK_A_STATIC_NODE,               /* val */

        TK_A_ENV,                       /* val, attr */
        TK_A_TAG,                       /* val */
        TK_A_NAME,                      /* val */
        TK_A_ENV,                       /* val, attr */
        TK_A_TAG,                       /* val */
        TK_A_NAME,                      /* val */


@@ -172,10 +173,12 @@ enum token_type {
 /* we try to pack stuff in a way that we take only 12 bytes per token */
 struct token {
        union {
 /* we try to pack stuff in a way that we take only 12 bytes per token */
 struct token {
        union {

-               unsigned char type;             /* same as in rule and key */
+               unsigned char type;             /* same in rule and key */

                struct {
                        enum token_type type:8;
                struct {
                        enum token_type type:8;

-                       unsigned int flags:8;
+                       bool can_set_name:1;
+                       bool has_static_node:1;
+                       unsigned int unused:6;

                        unsigned short token_count;
                        unsigned int label_off;
                        unsigned short filename_off;
                        unsigned short token_count;
                        unsigned int label_off;
                        unsigned short filename_off;


@@ -286,6 +289,7 @@ static const char *token_str(enum token_type type)
                [TK_A_MODE] =                   "A MODE",
                [TK_A_OWNER_ID] =               "A OWNER_ID",
                [TK_A_GROUP_ID] =               "A GROUP_ID",
                [TK_A_MODE] =                   "A MODE",
                [TK_A_OWNER_ID] =               "A OWNER_ID",
                [TK_A_GROUP_ID] =               "A GROUP_ID",

+               [TK_A_STATIC_NODE] =            "A STATIC_NODE",

                [TK_A_MODE_ID] =                "A MODE_ID",
                [TK_A_ENV] =                    "A ENV",
                [TK_A_TAG] =                    "A ENV",
                [TK_A_MODE_ID] =                "A MODE_ID",
                [TK_A_ENV] =                    "A ENV",
                [TK_A_TAG] =                    "A ENV",


@@ -374,7 +378,7 @@ static void dump_token(struct udev_rules *rules, struct token *token)
                dbg(rules->udev, "%s %u\n", token_str(type), token->key.watch);
                break;
        case TK_A_DEVLINK_PRIO:
                dbg(rules->udev, "%s %u\n", token_str(type), token->key.watch);
                break;
        case TK_A_DEVLINK_PRIO:

-               dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.devlink_prio);
+               dbg(rules->udev, "%s %u\n", token_str(type), token->key.devlink_prio);

                break;
        case TK_A_OWNER_ID:
                dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.uid);
                break;
        case TK_A_OWNER_ID:
                dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.uid);


@@ -385,8 +389,11 @@ static void dump_token(struct udev_rules *rules, struct token *token)
        case TK_A_MODE_ID:
                dbg(rules->udev, "%s %s %#o\n", token_str(type), operation_str(op), token->key.mode);
                break;
        case TK_A_MODE_ID:
                dbg(rules->udev, "%s %s %#o\n", token_str(type), operation_str(op), token->key.mode);
                break;

+       case TK_A_STATIC_NODE:
+               dbg(rules->udev, "%s '%s'\n", token_str(type), value);
+               break;

        case TK_A_EVENT_TIMEOUT:
        case TK_A_EVENT_TIMEOUT:

-               dbg(rules->udev, "%s %s %u\n", token_str(type), operation_str(op), token->key.event_timeout);
+               dbg(rules->udev, "%s %u\n", token_str(type), token->key.event_timeout);

                break;
        case TK_A_GOTO:
                dbg(rules->udev, "%s '%s' %u\n", token_str(type), value, token->key.rule_goto);
                break;
        case TK_A_GOTO:
                dbg(rules->udev, "%s '%s' %u\n", token_str(type), value, token->key.rule_goto);


@@ -834,7 +841,7 @@ static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
 
 static int attr_subst_subdir(char *attr, size_t len)
 {
 
 static int attr_subst_subdir(char *attr, size_t len)
 {

-       int found = 0;
+       bool found = false;

 
        if (strstr(attr, "/*/")) {
                char *pos;
 
        if (strstr(attr, "/*/")) {
                char *pos;


@@ -859,7 +866,7 @@ static int attr_subst_subdir(char *attr, size_t len)
                                        continue;
                                util_strscpyl(attr, len, dirname, "/", dent->d_name, tail, NULL);
                                if (stat(attr, &stats) == 0) {
                                        continue;
                                util_strscpyl(attr, len, dirname, "/", dent->d_name, tail, NULL);
                                if (stat(attr, &stats) == 0) {

-                                       found = 1;
+                                       found = true;

                                        break;
                                }
                        }
                                        break;
                                }
                        }


@@ -1053,6 +1060,9 @@ static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
        case TK_A_MODE_ID:
                token->key.mode = *(mode_t *)data;
                break;
        case TK_A_MODE_ID:
                token->key.mode = *(mode_t *)data;
                break;

+       case TK_A_STATIC_NODE:
+               token->key.value_off = add_string(rule_tmp->rules, value);
+               break;

        case TK_A_EVENT_TIMEOUT:
                token->key.event_timeout = *(int *)data;
                break;
        case TK_A_EVENT_TIMEOUT:
                token->key.event_timeout = *(int *)data;
                break;


@@ -1480,7 +1490,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                                }
                                rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
                        }
                                }
                                rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
                        }

-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;

                        continue;
                }
 
                        continue;
                }
 


@@ -1495,7 +1505,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                                        flag = 1;
                                rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, &flag);
                        }
                                        flag = 1;
                                rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, &flag);
                        }

-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;

                        continue;
                }
 
                        continue;
                }
 


@@ -1512,7 +1522,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL);
                        }
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL);
                        }

-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;

                        continue;
                }
 
                        continue;
                }
 


@@ -1529,7 +1539,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL);
                        }
                        } else if (rules->resolve_names >= 0) {
                                rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL);
                        }

-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;

                        continue;
                }
 
                        continue;
                }
 


@@ -1542,7 +1552,7 @@ static int add_rule(struct udev_rules *rules, char *line,
                                rule_add_key(&rule_tmp, TK_A_MODE_ID, op, NULL, &mode);
                        else
                                rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL);
                                rule_add_key(&rule_tmp, TK_A_MODE_ID, op, NULL, &mode);
                        else
                                rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL);

-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;

                        continue;
                }
 
                        continue;
                }
 


@@ -1586,6 +1596,11 @@ static int add_rule(struct udev_rules *rules, char *line,
                                        dbg(rules->udev, "inotify watch of device requested\n");
                                }
                        }
                                        dbg(rules->udev, "inotify watch of device requested\n");
                                }
                        }

+                       pos = strstr(value, "static_node=");
+                       if (pos != NULL) {
+                               rule_add_key(&rule_tmp, TK_A_STATIC_NODE, 0, &pos[strlen("static_node=")], NULL);
+                               rule_tmp.rule.rule.has_static_node = true;
+                       }

                        continue;
                }
                err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno);
                        continue;
                }
                err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno);


@@ -1907,7 +1922,7 @@ static int match_key(struct udev_rules *rules, struct token *token, const char *
 {
        char *key_value = &rules->buf[token->key.value_off];
        char *pos;
 {
        char *key_value = &rules->buf[token->key.value_off];
        char *pos;

-       int match = 0;
+       bool match = false;

 
        if (val == NULL)
                val = "";
 
        if (val == NULL)
                val = "";


@@ -2056,14 +2071,14 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
        /* loop through token list, match, run actions or forward to next rule */
        cur = &rules->tokens[0];
        rule = cur;
        /* loop through token list, match, run actions or forward to next rule */
        cur = &rules->tokens[0];
        rule = cur;

-       while (1) {
+       for (;;) {

                dump_token(rules, cur);
                switch (cur->type) {
                case TK_RULE:
                        /* current rule */
                        rule = cur;
                        /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */
                dump_token(rules, cur);
                switch (cur->type) {
                case TK_RULE:
                        /* current rule */
                        rule = cur;
                        /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */

-                       if (!can_set_name && rule->rule.flags)
+                       if (!can_set_name && rule->rule.can_set_name)

                                goto nomatch;
                        esc = ESCAPE_UNSET;
                        break;
                                goto nomatch;
                        esc = ESCAPE_UNSET;
                        break;


@@ -2083,14 +2098,14 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        {
                                size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
                                struct udev_list_entry *list_entry;
                        {
                                size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
                                struct udev_list_entry *list_entry;

-                               int match = 0;
+                               bool match = false;

 
                                udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
                                        const char *devlink;
 
                                        devlink =  &udev_list_entry_get_name(list_entry)[devlen];
                                        if (match_key(rules, cur, devlink) == 0) {
 
                                udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
                                        const char *devlink;
 
                                        devlink =  &udev_list_entry_get_name(list_entry)[devlen];
                                        if (match_key(rules, cur, devlink) == 0) {

-                                               match = 1;
+                                               match = true;

                                                break;
                                        }
                                }
                                                break;
                                        }
                                }


@@ -2348,7 +2363,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                if (event->owner_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)
                                if (event->owner_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)

-                                       event->owner_final = 1;
+                                       event->owner_final = true;

                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner));
                                event->uid = util_lookup_user(event->udev, owner);
                                info(event->udev, "OWNER %u %s:%u\n",
                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner));
                                event->uid = util_lookup_user(event->udev, owner);
                                info(event->udev, "OWNER %u %s:%u\n",


@@ -2364,7 +2379,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                if (event->group_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)
                                if (event->group_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)

-                                       event->group_final = 1;
+                                       event->group_final = true;

                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group));
                                event->gid = util_lookup_group(event->udev, group);
                                info(event->udev, "GROUP %u %s:%u\n",
                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group));
                                event->gid = util_lookup_group(event->udev, group);
                                info(event->udev, "GROUP %u %s:%u\n",


@@ -2381,12 +2396,12 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                if (event->mode_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)
                                if (event->mode_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)

-                                       event->mode_final = 1;
+                                       event->mode_final = true;

                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode, sizeof(mode));
                                event->mode = strtol(mode, &endptr, 8);
                                if (endptr[0] != '\0') {
                                udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode, sizeof(mode));
                                event->mode = strtol(mode, &endptr, 8);
                                if (endptr[0] != '\0') {

-                                       err(event->udev, "invalide mode '%s' set default mode 0660\n", mode);
-                                       event->mode = 0660;
+                                       err(event->udev, "invalide mode '%s' set default mode 0600\n", mode);
+                                       event->mode = 0600;

                                }
                                info(event->udev, "MODE %#o %s:%u\n",
                                     event->mode,
                                }
                                info(event->udev, "MODE %#o %s:%u\n",
                                     event->mode,


@@ -2398,7 +2413,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (event->owner_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
                        if (event->owner_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)

-                               event->owner_final = 1;
+                               event->owner_final = true;

                        event->uid = cur->key.uid;
                        info(event->udev, "OWNER %u %s:%u\n",
                             event->uid,
                        event->uid = cur->key.uid;
                        info(event->udev, "OWNER %u %s:%u\n",
                             event->uid,


@@ -2409,7 +2424,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (event->group_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
                        if (event->group_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)

-                               event->group_final = 1;
+                               event->group_final = true;

                        event->gid = cur->key.gid;
                        info(event->udev, "GROUP %u %s:%u\n",
                             event->gid,
                        event->gid = cur->key.gid;
                        info(event->udev, "GROUP %u %s:%u\n",
                             event->gid,


@@ -2420,13 +2435,15 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        if (event->mode_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)
                        if (event->mode_final)
                                break;
                        if (cur->key.op == OP_ASSIGN_FINAL)

-                               event->mode_final = 1;
+                               event->mode_final = true;

                        event->mode = cur->key.mode;
                        info(event->udev, "MODE %#o %s:%u\n",
                             event->mode,
                             &rules->buf[rule->rule.filename_off],
                             rule->rule.filename_line);
                        break;
                        event->mode = cur->key.mode;
                        info(event->udev, "MODE %#o %s:%u\n",
                             event->mode,
                             &rules->buf[rule->rule.filename_off],
                             rule->rule.filename_line);
                        break;

+               case TK_A_STATIC_NODE:
+                       break;

                case TK_A_ENV:
                        {
                                const char *name = &rules->buf[cur->key.attr_off];
                case TK_A_ENV:
                        {
                                const char *name = &rules->buf[cur->key.attr_off];


@@ -2460,7 +2477,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                if (event->name_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)
                                if (event->name_final)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)

-                                       event->name_final = 1;
+                                       event->name_final = true;

                                udev_event_apply_format(event, name, name_str, sizeof(name_str));
                                if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
                                        count = udev_util_replace_chars(name_str, "/");
                                udev_event_apply_format(event, name, name_str, sizeof(name_str));
                                if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
                                        count = udev_util_replace_chars(name_str, "/");


@@ -2487,7 +2504,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                if (major(udev_device_get_devnum(event->dev)) == 0)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)
                                if (major(udev_device_get_devnum(event->dev)) == 0)
                                        break;
                                if (cur->key.op == OP_ASSIGN_FINAL)

-                                       event->devlink_final = 1;
+                                       event->devlink_final = true;

                                if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
                                        udev_device_cleanup_devlinks_list(event->dev);
 
                                if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
                                        udev_device_cleanup_devlinks_list(event->dev);
 


@@ -2592,3 +2609,75 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                 (unsigned int) (cur - rules->tokens));
        }
 }
                                 (unsigned int) (cur - rules->tokens));
        }
 }

+
+void udev_rules_apply_static_dev_perms(struct udev_rules *rules)
+{
+       struct token *cur;
+       struct token *rule;
+       uid_t uid = 0;
+       gid_t gid = 0;
+       mode_t mode = 0;
+
+       if (rules->tokens == NULL)
+               return;
+
+       cur = &rules->tokens[0];
+       rule = cur;
+       for (;;) {
+               switch (cur->type) {
+               case TK_RULE:
+                       /* current rule */
+                       rule = cur;
+
+                       /* skip rules without a static_node tag */
+                       if (!rule->rule.has_static_node)
+                               goto next;
+
+                       uid = 0;
+                       gid = 0;
+                       mode = 0;
+                       break;
+               case TK_A_OWNER_ID:
+                       uid = cur->key.uid;
+                       break;
+               case TK_A_GROUP_ID:
+                       gid = cur->key.gid;
+                       break;
+               case TK_A_MODE_ID:
+                       mode = cur->key.mode;
+                       break;
+               case TK_A_STATIC_NODE: {
+                       char filename[UTIL_PATH_SIZE];
+                       struct stat stats;
+                       /* we assure, that the permissions tokens are sorted before the static token */
+                       if (mode == 0 && uid == 0 && gid == 0)
+                               goto next;
+                       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(rules->udev), "/",
+                                     &rules->buf[cur->key.value_off], NULL);
+                       if (stat(filename, &stats) != 0)
+                               goto next;
+                       if (!S_ISBLK(stats.st_mode) && !S_ISCHR(stats.st_mode))
+                               goto next;
+                       if (mode != 0 && mode != (stats.st_mode & 0777)) {
+                               chmod(filename, mode);
+                               info(rules->udev, "chmod '%s' %#o\n", filename, mode);
+                       }
+                       if ((uid != 0 && uid != stats.st_uid) || (gid != 0 && gid != stats.st_gid)) {
+                               chown(filename, uid, gid);
+                               info(rules->udev, "chown '%s' %u %u\n", filename, uid, gid);
+                       }
+                       utimensat(AT_FDCWD, filename, NULL, 0);
+                       break;
+               }
+               case TK_END:
+                       return;
+               }
+
+               cur++;
+               continue;
+next:
+               /* fast-forward to next rule */
+               cur = rule + rule->rule.token_count;
+               continue;
+       }
+}

diff --git a/udev/udev.h b/udev/udev.h
index b1b65c5617daa84efd1802c6e4b24da2a2397a28..4150c16af721a64b6f56d55f3b0f8055cd69588a 100644 (file)
--- a/udev/udev.h
+++ b/udev/udev.h
@@ -43,13 +43,13 @@ struct udev_event {
        uid_t uid;
        gid_t gid;
        struct udev_list_node run_list;
        uid_t uid;
        gid_t gid;
        struct udev_list_node run_list;

-       unsigned int group_final:1;
-       unsigned int owner_final:1;
-       unsigned int mode_final:1;
-       unsigned int name_final:1;
-       unsigned int devlink_final:1;
-       unsigned int run_final:1;
-       unsigned int inotify_watch:1;
+       bool group_final;
+       bool owner_final;
+       bool mode_final;
+       bool name_final;
+       bool devlink_final;
+       bool run_final;
+       bool inotify_watch;

 };
 
 struct udev_watch {
 };
 
 struct udev_watch {


@@ -63,6 +63,7 @@ struct udev_rules;
 struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names);
 void udev_rules_unref(struct udev_rules *rules);
 int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event);
 struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names);
 void udev_rules_unref(struct udev_rules *rules);
 int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event);

+void udev_rules_apply_static_dev_perms(struct udev_rules *rules);

 
 /* udev-event.c */
 struct udev_event *udev_event_new(struct udev_device *dev);
 
 /* udev-event.c */
 struct udev_event *udev_event_new(struct udev_device *dev);

diff --git a/udev/udevd.c b/udev/udevd.c
index 1bde8f4a746d19b719d71289137e308e5721ae2f..ab2488530926464e0b0814c181674f329e29abc3 100644 (file)
--- a/udev/udevd.c
+++ b/udev/udevd.c
@@ -41,6 +41,7 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/inotify.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/inotify.h>

+#include <sys/utsname.h>

 
 #include "udev.h"
 
 
 #include "udev.h"
 


@@ -745,6 +746,72 @@ static void handle_signal(struct udev *udev, int signo)
        }
 }
 
        }
 }
 

+static void static_dev_create_from_modules(struct udev *udev)
+{
+       struct utsname kernel;
+       char modules[UTIL_PATH_SIZE];
+       char buf[4096];
+       FILE *f;
+
+       uname(&kernel);
+       util_strscpyl(modules, sizeof(modules), "/lib/modules/", kernel.release, "/modules.devname", NULL);
+       f = fopen(modules, "r");
+       if (f == NULL)
+               return;
+
+       while (fgets(buf, sizeof(buf), f) != NULL) {
+               char *s;
+               const char *modname;
+               const char *devname;
+               const char *devno;
+               int maj, min;
+               char type;
+               mode_t mode;
+               char filename[UTIL_PATH_SIZE];
+
+               if (buf[0] == '#')
+                       continue;
+
+               modname = buf;
+               s = strchr(modname, ' ');
+               if (s == NULL)
+                       continue;
+               s[0] = '\0';
+
+               devname = &s[1];
+               s = strchr(devname, ' ');
+               if (s == NULL)
+                       continue;
+               s[0] = '\0';
+
+               devno = &s[1];
+               s = strchr(devno, ' ');
+               if (s == NULL)
+                       s = strchr(devno, '\n');
+               if (s != NULL)
+                       s[0] = '\0';
+               if (sscanf(devno, "%c%u:%u", &type, &maj, &min) != 3)
+                       continue;
+
+               if (type == 'c')
+                       mode = 0600 | S_IFCHR;
+               else if (type == 'b')
+                       mode = 0600 | S_IFBLK;
+               else
+                       continue;
+
+               util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/", devname, NULL);
+               util_create_path(udev, filename);
+               udev_selinux_setfscreatecon(udev, filename, mode);
+               info(udev, "mknod '%s' %c%u:%u\n", filename, type, maj, min);
+               if (mknod(filename, mode, makedev(maj, min)) < 0 && errno == EEXIST)
+                       utimensat(AT_FDCWD, filename, NULL, 0);
+               udev_selinux_resetfscreatecon(udev);
+       }
+
+       fclose(f);
+}
+

 static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
 {
        struct dirent *dent;
 static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
 {
        struct dirent *dent;


@@ -808,7 +875,7 @@ static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
        return 0;
 }
 
        return 0;
 }
 

-static void prepare_dev(struct udev *udev)
+static void static_dev_create_links(struct udev *udev, DIR *dir)

 {
        struct stdlinks {
                const char *link;
 {
        struct stdlinks {
                const char *link;


@@ -822,28 +889,38 @@ static void prepare_dev(struct udev *udev)
                { "stderr", "/proc/self/fd/2" },
        };
        unsigned int i;
                { "stderr", "/proc/self/fd/2" },
        };
        unsigned int i;

-       DIR *dir_from, *dir_to;

 
 

-       dir_to = opendir(udev_get_dev_path(udev));
-       if (dir_to == NULL)
-               return;
-
-       /* create standard symlinks to /proc */

        for (i = 0; i < ARRAY_SIZE(stdlinks); i++) {
        for (i = 0; i < ARRAY_SIZE(stdlinks); i++) {

-               udev_selinux_setfscreateconat(udev, dirfd(dir_to), stdlinks[i].link, S_IFLNK);
-               if (symlinkat(stdlinks[i].target, dirfd(dir_to), stdlinks[i].link) < 0 && errno == EEXIST)
-                       utimensat(dirfd(dir_to), stdlinks[i].link, NULL, AT_SYMLINK_NOFOLLOW);
+               udev_selinux_setfscreateconat(udev, dirfd(dir), stdlinks[i].link, S_IFLNK);
+               if (symlinkat(stdlinks[i].target, dirfd(dir), stdlinks[i].link) < 0 && errno == EEXIST)
+                       utimensat(dirfd(dir), stdlinks[i].link, NULL, AT_SYMLINK_NOFOLLOW);

                udev_selinux_resetfscreatecon(udev);
        }
                udev_selinux_resetfscreatecon(udev);
        }

+}
+
+static void static_dev_create_from_devices(struct udev *udev, DIR *dir)
+{
+       DIR *dir_from;

 
 

-       /* copy content from /lib/udev/devices to /dev */

        dir_from = opendir(LIBEXECDIR "/devices");
        dir_from = opendir(LIBEXECDIR "/devices");

-       if (dir_from != NULL) {
-               copy_dir(udev, dir_from, dir_to, 8);
-               closedir(dir_from);
-       }
+       if (dir_from == NULL)
+               return;
+       copy_dir(udev, dir_from, dir, 8);
+       closedir(dir_from);
+}
+
+static void static_dev_create(struct udev *udev)
+{
+       DIR *dir;

 
 

-       closedir(dir_to);
+       dir = opendir(udev_get_dev_path(udev));
+       if (dir == NULL)
+               return;
+
+       static_dev_create_links(udev, dir);
+       static_dev_create_from_devices(udev, dir);
+
+       closedir(dir);

 }
 
 static int mem_size_mb(void)
 }
 
 static int mem_size_mb(void)


@@ -959,8 +1036,6 @@ int main(int argc, char *argv[])
        if (write(STDERR_FILENO, 0, 0) < 0)
                dup2(fd, STDERR_FILENO);
 
        if (write(STDERR_FILENO, 0, 0) < 0)
                dup2(fd, STDERR_FILENO);
 

-       prepare_dev(udev);
-

        /* init control socket, bind() ensures, that only one udevd instance is running */
        udev_ctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
        if (udev_ctrl == NULL) {
        /* init control socket, bind() ensures, that only one udevd instance is running */
        udev_ctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
        if (udev_ctrl == NULL) {


@@ -1118,6 +1193,10 @@ int main(int argc, char *argv[])
                max_childs = strtoul(value, NULL, 10);
        info(udev, "initialize max_childs to %u\n", max_childs);
 
                max_childs = strtoul(value, NULL, 10);
        info(udev, "initialize max_childs to %u\n", max_childs);
 

+       static_dev_create(udev);
+       static_dev_create_from_modules(udev);
+       udev_rules_apply_static_dev_perms(rules);
+

        udev_list_init(&event_list);
        udev_list_init(&worker_list);
 
        udev_list_init(&event_list);
        udev_list_init(&worker_list);