chiark / gitweb /
create static nodes provided by kernel modules to allow module autoloading
authorKay Sievers <kay.sievers@vrfy.org>
Thu, 20 May 2010 15:09:04 +0000 (17:09 +0200)
committerKay Sievers <kay.sievers@vrfy.org>
Thu, 20 May 2010 15:09:04 +0000 (17:09 +0200)
rules/rules.d/50-udev-default.rules
udev/udev-node.c
udev/udev-rules.c
udev/udev.h
udev/udevd.c

index 7e09ea1..d4da4b1 100644 (file)
@@ -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=="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=="ppp",                 MODE="0600"
 KERNEL=="mwave",               GROUP="dialout"
 KERNEL=="hvc*|hvsi*",          GROUP="dialout"
 
@@ -36,7 +34,7 @@ KERNEL=="vtx*|vbi*",          GROUP="video"
 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"
@@ -100,14 +98,14 @@ SUBSYSTEM=="aoe", GROUP="disk", MODE="0220"
 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=="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"
index d55700d..8339eb7 100644 (file)
@@ -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(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) {
-                               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;
                        }
-                       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 {
-               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)
@@ -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)
-                       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);
        }
@@ -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) {
-               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) {
-               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:
@@ -396,7 +396,6 @@ int udev_node_remove(struct udev_device *dev)
        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 */
@@ -426,12 +425,6 @@ int udev_node_remove(struct udev_device *dev)
                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);
index 8fc804a..5dcd760 100644 (file)
@@ -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_STATIC_NODE,               /* 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 {
-               unsigned char type;             /* same as in rule and key */
+               unsigned char type;             /* same in rule and key */
                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;
@@ -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_STATIC_NODE] =            "A STATIC_NODE",
                [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 %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);
@@ -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_STATIC_NODE:
+               dbg(rules->udev, "%s '%s'\n", token_str(type), value);
+               break;
        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);
@@ -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)
 {
-       int found = 0;
+       bool found = false;
 
        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) {
-                                       found = 1;
+                                       found = true;
                                        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_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;
@@ -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_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        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);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        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);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        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);
                        }
-                       rule_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        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_tmp.rule.rule.flags = 1;
+                       rule_tmp.rule.rule.can_set_name = true;
                        continue;
                }
 
@@ -1586,6 +1596,11 @@ static int add_rule(struct udev_rules *rules, char *line,
                                        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);
@@ -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;
-       int match = 0;
+       bool match = false;
 
        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;
-       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 */
-                       if (!can_set_name && rule->rule.flags)
+                       if (!can_set_name && rule->rule.can_set_name)
                                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;
-                               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) {
-                                               match = 1;
+                                               match = true;
                                                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)
-                                       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",
@@ -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)
-                                       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",
@@ -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)
-                                       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') {
-                                       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,
@@ -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)
-                               event->owner_final = 1;
+                               event->owner_final = true;
                        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)
-                               event->group_final = 1;
+                               event->group_final = true;
                        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)
-                               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;
+               case TK_A_STATIC_NODE:
+                       break;
                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)
-                                       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, "/");
@@ -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)
-                                       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);
 
@@ -2592,3 +2609,75 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                 (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;
+       }
+}
index b1b65c5..4150c16 100644 (file)
@@ -43,13 +43,13 @@ struct udev_event {
        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 {
@@ -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);
+void udev_rules_apply_static_dev_perms(struct udev_rules *rules);
 
 /* udev-event.c */
 struct udev_event *udev_event_new(struct udev_device *dev);
index 1bde8f4..ab24885 100644 (file)
@@ -41,6 +41,7 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/inotify.h>
+#include <sys/utsname.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;
@@ -808,7 +875,7 @@ static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
        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;
@@ -822,28 +889,38 @@ static void prepare_dev(struct udev *udev)
                { "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++) {
-               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);
        }
+}
+
+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");
-       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)
@@ -959,8 +1036,6 @@ int main(int argc, char *argv[])
        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) {
@@ -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);
 
+       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);