Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/util-linux/mdev.c

Timestamp:

Jan 1, 2014, 12:47:38 AM (10 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

File:

• branches/3.2/mindi-busybox/util-linux/mdev.c (modified) (18 diffs)

branches/3.2/mindi-busybox/util-linux/mdev.c

@@ -8 +8 @@
  * Licensed under GPLv2, see file LICENSE in this source tree.
  */
+
+//config:config MDEV
+//config:   bool "mdev"
+//config:   default y
+//config:   select PLATFORM_LINUX
+//config:   help
+//config:     mdev is a mini-udev implementation for dynamically creating device
+//config:     nodes in the /dev directory.
+//config:
+//config:     For more information, please see docs/mdev.txt
+//config:
+//config:config FEATURE_MDEV_CONF
+//config:   bool "Support /etc/mdev.conf"
+//config:   default y
+//config:   depends on MDEV
+//config:   help
+//config:     Add support for the mdev config file to control ownership and
+//config:     permissions of the device nodes.
+//config:
+//config:     For more information, please see docs/mdev.txt
+//config:
+//config:config FEATURE_MDEV_RENAME
+//config:   bool "Support subdirs/symlinks"
+//config:   default y
+//config:   depends on FEATURE_MDEV_CONF
+//config:   help
+//config:     Add support for renaming devices and creating symlinks.
+//config:
+//config:     For more information, please see docs/mdev.txt
+//config:
+//config:config FEATURE_MDEV_RENAME_REGEXP
+//config:   bool "Support regular expressions substitutions when renaming device"
+//config:   default y
+//config:   depends on FEATURE_MDEV_RENAME
+//config:   help
+//config:     Add support for regular expressions substitutions when renaming
+//config:     device.
+//config:
+//config:config FEATURE_MDEV_EXEC
+//config:   bool "Support command execution at device addition/removal"
+//config:   default y
+//config:   depends on FEATURE_MDEV_CONF
+//config:   help
+//config:     This adds support for an optional field to /etc/mdev.conf for
+//config:     executing commands when devices are created/removed.
+//config:
+//config:     For more information, please see docs/mdev.txt
+//config:
+//config:config FEATURE_MDEV_LOAD_FIRMWARE
+//config:   bool "Support loading of firmwares"
+//config:   default y
+//config:   depends on MDEV
+//config:   help
+//config:     Some devices need to load firmware before they can be usable.
+//config:
+//config:     These devices will request userspace look up the files in
+//config:     /lib/firmware/ and if it exists, send it to the kernel for
+//config:     loading into the hardware.
+
+//applet:IF_MDEV(APPLET(mdev, BB_DIR_SBIN, BB_SUID_DROP))
+
+//kbuild:lib-$(CONFIG_MDEV) += mdev.o
+
+//usage:#define mdev_trivial_usage
+//usage:       "[-s]"
+//usage:#define mdev_full_usage "\n\n"
+//usage:       "mdev -s is to be run during boot to scan /sys and populate /dev.\n"
+//usage:       "\n"
+//usage:       "Bare mdev is a kernel hotplug helper. To activate it:\n"
+//usage:       "    echo /sbin/mdev >/proc/sys/kernel/hotplug\n"
+//usage:    IF_FEATURE_MDEV_CONF(
+//usage:       "\n"
+//usage:       "It uses /etc/mdev.conf with lines\n"
+//usage:       "    [-][ENV=regex;]...DEVNAME UID:GID PERM"
+//usage:            IF_FEATURE_MDEV_RENAME(" [>|=PATH]|[!]")
+//usage:            IF_FEATURE_MDEV_EXEC(" [@|$|*PROG]")
+//usage:       "\n"
+//usage:       "where DEVNAME is device name regex, @major,minor[-minor2], or\n"
+//usage:       "environment variable regex. A common use of the latter is\n"
+//usage:       "to load modules for hotplugged devices:\n"
+//usage:       "    $MODALIAS=.* 0:0 660 @modprobe \"$MODALIAS\"\n"
+//usage:    )
+//usage:       "\n"
+//usage:       "If /dev/mdev.seq file exists, mdev will wait for its value\n"
+//usage:       "to match $SEQNUM variable. This prevents plug/unplug races.\n"
+//usage:       "To activate this feature, create empty /dev/mdev.seq at boot.\n"
+//usage:       "\n"
+//usage:       "If /dev/mdev.log file exists, debug log will be appended to it."
+
 #include "libbb.h"
 #include "xregex.h"
@@ -28 +117 @@
  *
  * If /etc/mdev.conf exists, it may modify /dev/device_name's properties.
- * /etc/mdev.conf file format:
- *
- * [-][subsystem/]device  user:grp  mode  [>|=path] [@|$|*command args...]
- * [-]@maj,min[-min2]     user:grp  mode  [>|=path] [@|$|*command args...]
- * [-]$envvar=val         user:grp  mode  [>|=path] [@|$|*command args...]
  *
  * Leading minus in 1st field means "don't stop on this line", otherwise
  * search is stopped after the matching line is encountered.
  *
- * The device name or "subsystem/device" combo is matched against 1st field
- * (which is a regex), or maj,min is matched against 1st field,
- * or specified environment variable (as regex) is matched against 1st field.
- *
- * $envvar=val format is useful for loading modules for hot-plugged devices
+ * $envvar=regex format is useful for loading modules for hot-plugged devices
  * which do not have driver loaded yet. In this case /sys/class/.../dev
  * does not exist, but $MODALIAS is set to needed module's name
@@ -62 +142 @@
  */
 
+/* Kernel's hotplug environment constantly changes.
+ * Here are new cases I observed on 3.1.0:
+ *
+ * Case with $DEVNAME and $DEVICE, not just $DEVPATH:
+ * ACTION=add
+ * BUSNUM=001
+ * DEVICE=/proc/bus/usb/001/003
+ * DEVNAME=bus/usb/001/003
+ * DEVNUM=003
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5
+ * DEVTYPE=usb_device
+ * MAJOR=189
+ * MINOR=2
+ * PRODUCT=18d1/4e12/227
+ * SUBSYSTEM=usb
+ * TYPE=0/0/0
+ *
+ * Case with $DEVICE, but no $DEVNAME - apparenty, usb iface notification?
+ * "Please load me a module" thing?
+ * ACTION=add
+ * DEVICE=/proc/bus/usb/001/003
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0
+ * DEVTYPE=usb_interface
+ * INTERFACE=8/6/80
+ * MODALIAS=usb:v18D1p4E12d0227dc00dsc00dp00ic08isc06ip50
+ * PRODUCT=18d1/4e12/227
+ * SUBSYSTEM=usb
+ * TYPE=0/0/0
+ *
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5
+ * DEVTYPE=scsi_host
+ * SUBSYSTEM=scsi
+ *
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/scsi_host/host5
+ * SUBSYSTEM=scsi_host
+ *
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/target5:0:0
+ * DEVTYPE=scsi_target
+ * SUBSYSTEM=scsi
+ *
+ * Case with strange $MODALIAS:
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/target5:0:0/5:0:0:0
+ * DEVTYPE=scsi_device
+ * MODALIAS=scsi:t-0x00
+ * SUBSYSTEM=scsi
+ *
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/target5:0:0/5:0:0:0/scsi_disk/5:0:0:0
+ * SUBSYSTEM=scsi_disk
+ *
+ * ACTION=add
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/target5:0:0/5:0:0:0/scsi_device/5:0:0:0
+ * SUBSYSTEM=scsi_device
+ *
+ * Case with explicit $MAJOR/$MINOR (no need to read /sys/$DEVPATH/dev?):
+ * ACTION=add
+ * DEVNAME=bsg/5:0:0:0
+ * DEVPATH=/devices/pci0000:00/0000:00:02.1/usb1/1-5/1-5:1.0/host5/target5:0:0/5:0:0:0/bsg/5:0:0:0
+ * MAJOR=253
+ * MINOR=1
+ * SUBSYSTEM=bsg
+ *
+ * ACTION=add
+ * DEVPATH=/devices/virtual/bdi/8:16
+ * SUBSYSTEM=bdi
+ *
+ * ACTION=add
+ * DEVNAME=sdb
+ * DEVPATH=/block/sdb
+ * DEVTYPE=disk
+ * MAJOR=8
+ * MINOR=16
+ * SUBSYSTEM=block
+ *
+ * Case with ACTION=change:
+ * ACTION=change
+ * DEVNAME=sdb
+ * DEVPATH=/block/sdb
+ * DEVTYPE=disk
+ * DISK_MEDIA_CHANGE=1
+ * MAJOR=8
+ * MINOR=16
+ * SUBSYSTEM=block
+ */
+
+#define DEBUG_LVL 2
+
+#if DEBUG_LVL >= 1
+# define dbg1(...) do { if (G.verbose) bb_error_msg(__VA_ARGS__); } while(0)
+#else
+# define dbg1(...) ((void)0)
+#endif
+#if DEBUG_LVL >= 2
+# define dbg2(...) do { if (G.verbose >= 2) bb_error_msg(__VA_ARGS__); } while(0)
+#else
+# define dbg2(...) ((void)0)
+#endif
+#if DEBUG_LVL >= 3
+# define dbg3(...) do { if (G.verbose >= 3) bb_error_msg(__VA_ARGS__); } while(0)
+#else
+# define dbg3(...) ((void)0)
+#endif
+
+
+static const char keywords[] ALIGN1 = "add\0remove\0"; // "change\0"
+enum { OP_add, OP_remove };
+
+struct envmatch {
+    struct envmatch *next;
+    char *envname;
+    regex_t match;
+};
+
+struct rule {
+    bool keep_matching;
+    bool regex_compiled;
+    mode_t mode;
+    int maj, min0, min1;
+    struct bb_uidgid_t ugid;
+    char *envvar;
+    char *ren_mov;
+    IF_FEATURE_MDEV_EXEC(char *r_cmd;)
+    regex_t match;
+    struct envmatch *envmatch;
+};
+
 struct globals {
     int root_major, root_minor;
+    smallint verbose;
     char *subsystem;
+    char *subsys_env; /* for putenv("SUBSYSTEM=subsystem") */
+#if ENABLE_FEATURE_MDEV_CONF
+    const char *filename;
+    parser_t *parser;
+    struct rule **rule_vec;
+    unsigned rule_idx;
+#endif
+    struct rule cur_rule;
+    char timestr[sizeof("60.123456")];
 } FIX_ALIASING;
 #define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { \
+    IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.maj = -1;) \
+    IF_NOT_FEATURE_MDEV_CONF(G.cur_rule.mode = 0660;) \
+} while (0)
+
 
 /* Prevent infinite loops in /sys symlinks */
 #define MAX_SYSFS_DEPTH 3
 
-/* We use additional 64+ bytes in make_device() */
-#define SCRATCH_SIZE 80
+/* We use additional bytes in make_device() */
+#define SCRATCH_SIZE 128
+
+#if ENABLE_FEATURE_MDEV_CONF
+
+static void make_default_cur_rule(void)
+{
+    memset(&G.cur_rule, 0, sizeof(G.cur_rule));
+    G.cur_rule.maj = -1; /* "not a @major,minor rule" */
+    G.cur_rule.mode = 0660;
+}
+
+static void clean_up_cur_rule(void)
+{
+    struct envmatch *e;
+
+    free(G.cur_rule.envvar);
+    free(G.cur_rule.ren_mov);
+    if (G.cur_rule.regex_compiled)
+        regfree(&G.cur_rule.match);
+    IF_FEATURE_MDEV_EXEC(free(G.cur_rule.r_cmd);)
+    e = G.cur_rule.envmatch;
+    while (e) {
+        free(e->envname);
+        regfree(&e->match);
+        e = e->next;
+    }
+    make_default_cur_rule();
+}
+
+/* In later versions, endofname is in libbb */
+#define endofname mdev_endofname
+static
+const char* FAST_FUNC
+endofname(const char *name)
+{
+#define is_name(c)      ((c) == '_' || isalpha((unsigned char)(c)))
+#define is_in_name(c)   ((c) == '_' || isalnum((unsigned char)(c)))
+    if (!is_name(*name))
+        return name;
+    while (*++name) {
+        if (!is_in_name(*name))
+            break;
+    }
+    return name;
+}
+
+static char *parse_envmatch_pfx(char *val)
+{
+    struct envmatch **nextp = &G.cur_rule.envmatch;
+
+    for (;;) {
+        struct envmatch *e;
+        char *semicolon;
+        char *eq = strchr(val, '=');
+        if (!eq /* || eq == val? */)
+            return val;
+        if (endofname(val) != eq)
+            return val;
+        semicolon = strchr(eq, ';');
+        if (!semicolon)
+            return val;
+        /* ENVVAR=regex;... */
+        *nextp = e = xzalloc(sizeof(*e));
+        nextp = &e->next;
+        e->envname = xstrndup(val, eq - val);
+        *semicolon = '\0';
+        xregcomp(&e->match, eq + 1, REG_EXTENDED);
+        *semicolon = ';';
+        val = semicolon + 1;
+    }
+}
+
+static void parse_next_rule(void)
+{
+    /* Note: on entry, G.cur_rule is set to default */
+    while (1) {
+        char *tokens[4];
+        char *val;
+
+        /* No PARSE_EOL_COMMENTS, because command may contain '#' chars */
+        if (!config_read(G.parser, tokens, 4, 3, "# \t", PARSE_NORMAL & ~PARSE_EOL_COMMENTS))
+            break;
+
+        /* Fields: [-]regex uid:gid mode [alias] [cmd] */
+        dbg3("token1:'%s'", tokens[1]);
+
+        /* 1st field */
+        val = tokens[0];
+        G.cur_rule.keep_matching = ('-' == val[0]);
+        val += G.cur_rule.keep_matching; /* swallow leading dash */
+        val = parse_envmatch_pfx(val);
+        if (val[0] == '@') {
+            /* @major,minor[-minor2] */
+            /* (useful when name is ambiguous:
+             * "/sys/class/usb/lp0" and
+             * "/sys/class/printer/lp0")
+             */
+            int sc = sscanf(val, "@%u,%u-%u", &G.cur_rule.maj, &G.cur_rule.min0, &G.cur_rule.min1);
+            if (sc < 2 || G.cur_rule.maj < 0) {
+                bb_error_msg("bad @maj,min on line %d", G.parser->lineno);
+                goto next_rule;
+            }
+            if (sc == 2)
+                G.cur_rule.min1 = G.cur_rule.min0;
+        } else {
+            char *eq = strchr(val, '=');
+            if (val[0] == '$') {
+                /* $ENVVAR=regex ... */
+                val++;
+                if (!eq) {
+                    bb_error_msg("bad $envvar=regex on line %d", G.parser->lineno);
+                    goto next_rule;
+                }
+                G.cur_rule.envvar = xstrndup(val, eq - val);
+                val = eq + 1;
+            }
+            xregcomp(&G.cur_rule.match, val, REG_EXTENDED);
+            G.cur_rule.regex_compiled = 1;
+        }
+
+        /* 2nd field: uid:gid - device ownership */
+        if (get_uidgid(&G.cur_rule.ugid, tokens[1], /*allow_numeric:*/ 1) == 0) {
+            bb_error_msg("unknown user/group '%s' on line %d", tokens[1], G.parser->lineno);
+            goto next_rule;
+        }
+
+        /* 3rd field: mode - device permissions */
+        bb_parse_mode(tokens[2], &G.cur_rule.mode);
+
+        /* 4th field (opt): ">|=alias" or "!" to not create the node */
+        val = tokens[3];
+        if (ENABLE_FEATURE_MDEV_RENAME && val && strchr(">=!", val[0])) {
+            char *s = skip_non_whitespace(val);
+            G.cur_rule.ren_mov = xstrndup(val, s - val);
+            val = skip_whitespace(s);
+        }
+
+        if (ENABLE_FEATURE_MDEV_EXEC && val && val[0]) {
+            const char *s = "$@*";
+            const char *s2 = strchr(s, val[0]);
+            if (!s2) {
+                bb_error_msg("bad line %u", G.parser->lineno);
+                goto next_rule;
+            }
+            IF_FEATURE_MDEV_EXEC(G.cur_rule.r_cmd = xstrdup(val);)
+        }
+
+        return;
+ next_rule:
+        clean_up_cur_rule();
+    } /* while (config_read) */
+
+    dbg3("config_close(G.parser)");
+    config_close(G.parser);
+    G.parser = NULL;
+
+    return;
+}
+
+/* If mdev -s, we remember rules in G.rule_vec[].
+ * Otherwise, there is no point in doing it, and we just
+ * save only one parsed rule in G.cur_rule.
+ */
+static const struct rule *next_rule(void)
+{
+    struct rule *rule;
+
+    /* Open conf file if we didn't do it yet */
+    if (!G.parser && G.filename) {
+        dbg3("config_open('%s')", G.filename);
+        G.parser = config_open2(G.filename, fopen_for_read);
+        G.filename = NULL;
+    }
+
+    if (G.rule_vec) {
+        /* mdev -s */
+        /* Do we have rule parsed already? */
+        if (G.rule_vec[G.rule_idx]) {
+            dbg3("< G.rule_vec[G.rule_idx:%d]=%p", G.rule_idx, G.rule_vec[G.rule_idx]);
+            return G.rule_vec[G.rule_idx++];
+        }
+        make_default_cur_rule();
+    } else {
+        /* not mdev -s */
+        clean_up_cur_rule();
+    }
+
+    /* Parse one more rule if file isn't fully read */
+    rule = &G.cur_rule;
+    if (G.parser) {
+        parse_next_rule();
+        if (G.rule_vec) { /* mdev -s */
+            rule = memcpy(xmalloc(sizeof(G.cur_rule)), &G.cur_rule, sizeof(G.cur_rule));
+            G.rule_vec = xrealloc_vector(G.rule_vec, 4, G.rule_idx);
+            G.rule_vec[G.rule_idx++] = rule;
+            dbg3("> G.rule_vec[G.rule_idx:%d]=%p", G.rule_idx, G.rule_vec[G.rule_idx]);
+        }
+    }
+
+    return rule;
+}
+
+static int env_matches(struct envmatch *e)
+{
+    while (e) {
+        int r;
+        char *val = getenv(e->envname);
+        if (!val)
+            return 0;
+        r = regexec(&e->match, val, /*size*/ 0, /*range[]*/ NULL, /*eflags*/ 0);
+        if (r != 0) /* no match */
+            return 0;
+        e = e->next;
+    }
+    return 1;
+}
+
+#else
+
+# define next_rule() (&G.cur_rule)
+
+#endif
+
+static void mkdir_recursive(char *name)
+{
+    /* if name has many levels ("dir1/dir2"),
+     * bb_make_directory() will create dir1 according to umask,
+     * not according to its "mode" parameter.
+     * Since we run with umask=0, need to temporarily switch it.
+     */
+    umask(022); /* "dir1" (if any) will be 0755 too */
+    bb_make_directory(name, 0755, FILEUTILS_RECUR);
+    umask(0);
+}
 
 /* Builds an alias path.
@@ -87 +545 @@
     if (dest) { /* ">bar/[baz]" ? */
         *dest = '\0'; /* mkdir bar */
-        bb_make_directory(alias, 0755, FILEUTILS_RECUR);
+        mkdir_recursive(alias);
         *dest = '/';
         if (dest[1] == '\0') { /* ">bar/" => ">bar/device_name" */
@@ -101 +559 @@
 /* mknod in /dev based on a path like "/sys/block/hda/hda1"
  * NB1: path parameter needs to have SCRATCH_SIZE scratch bytes
- * after NUL, but we promise to not mangle (IOW: to restore if needed)
+ * after NUL, but we promise to not mangle (IOW: to restore NUL if needed)
  * path string.
  * NB2: "mdev -s" may call us many times, do not leak memory/fds!
+ *
+ * device_name = $DEVNAME (may be NULL)
+ * path        = /sys/$DEVPATH
  */
-static void make_device(char *path, int delete)
-{
-    char *device_name, *subsystem_slash_devname;
+static void make_device(char *device_name, char *path, int operation)
+{
     int major, minor, type, len;
-    mode_t mode;
-    parser_t *parser;
+    char *path_end = path + strlen(path);
 
     /* Try to read major/minor string.  Note that the kernel puts \n after
@@ -118 +577 @@
      */
     major = -1;
-    if (!delete) {
-        char *dev_maj_min = path + strlen(path);
-
-        strcpy(dev_maj_min, "/dev");
-        len = open_read_close(path, dev_maj_min + 1, 64);
-        *dev_maj_min = '\0';
+    if (operation == OP_add) {
+        strcpy(path_end, "/dev");
+        len = open_read_close(path, path_end + 1, SCRATCH_SIZE - 1);
+        *path_end = '\0';
         if (len < 1) {
             if (!ENABLE_FEATURE_MDEV_EXEC)
@@ -129 +586 @@
             /* no "dev" file, but we can still run scripts
              * based on device name */
-        } else if (sscanf(++dev_maj_min, "%u:%u", &major, &minor) != 2) {
+        } else if (sscanf(path_end + 1, "%u:%u", &major, &minor) == 2) {
+            dbg1("dev %u,%u", major, minor);
+        } else {
             major = -1;
         }
@@ -135 +594 @@
     /* else: for delete, -1 still deletes the node, but < -1 suppresses that */
 
-    /* Determine device name, type, major and minor */
-    device_name = (char*) bb_basename(path);
-    /* http://kernel.org/doc/pending/hotplug.txt says that only
+    /* Determine device name */
+    if (!device_name) {
+        /*
+         * There was no $DEVNAME envvar (for example, mdev -s never has).
+         * But it is very useful: it contains the *path*, not only basename,
+         * Thankfully, uevent file has it.
+         * Example of .../sound/card0/controlC0/uevent file on Linux-3.7.7:
+         * MAJOR=116
+         * MINOR=7
+         * DEVNAME=snd/controlC0
+         */
+        strcpy(path_end, "/uevent");
+        len = open_read_close(path, path_end + 1, SCRATCH_SIZE - 1);
+        if (len < 0)
+            len = 0;
+        *path_end = '\0';
+        path_end[1 + len] = '\0';
+        device_name = strstr(path_end + 1, "\nDEVNAME=");
+        if (device_name) {
+            device_name += sizeof("\nDEVNAME=")-1;
+            strchrnul(device_name, '\n')[0] = '\0';
+        } else {
+            /* Fall back to just basename */
+            device_name = (char*) bb_basename(path);
+        }
+    }
+    /* Determine device type */
+    /*
+     * http://kernel.org/doc/pending/hotplug.txt says that only
      * "/sys/block/..." is for block devices. "/sys/bus" etc is not.
      * But since 2.6.25 block devices are also in /sys/class/block.
-     * We use strstr("/block/") to forestall future surprises. */
+     * We use strstr("/block/") to forestall future surprises.
+     */
     type = S_IFCHR;
     if (strstr(path, "/block/") || (G.subsystem && strncmp(G.subsystem, "block", 5) == 0))
         type = S_IFBLK;
 
-    /* Make path point to "subsystem/device_name" */
-    subsystem_slash_devname = NULL;
-    /* Check for coldplug invocations first */
-    if (strncmp(path, "/sys/block/", 11) == 0) /* legacy case */
-        path += sizeof("/sys/") - 1;
-    else if (strncmp(path, "/sys/class/", 11) == 0)
-        path += sizeof("/sys/class/") - 1;
-    else {
-        /* Example of a hotplug invocation:
-         * SUBSYSTEM="block"
-         * DEVPATH="/sys" + "/devices/virtual/mtd/mtd3/mtdblock3"
-         * ("/sys" is added by mdev_main)
-         * - path does not contain subsystem
+#if ENABLE_FEATURE_MDEV_CONF
+    G.rule_idx = 0; /* restart from the beginning (think mdev -s) */
+#endif
+    for (;;) {
+        const char *str_to_match;
+        regmatch_t off[1 + 9 * ENABLE_FEATURE_MDEV_RENAME_REGEXP];
+        char *command;
+        char *alias;
+        char aliaslink = aliaslink; /* for compiler */
+        char *node_name;
+        const struct rule *rule;
+
+        str_to_match = device_name;
+
+        rule = next_rule();
+
+#if ENABLE_FEATURE_MDEV_CONF
+        if (!env_matches(rule->envmatch))
+            continue;
+        if (rule->maj >= 0) {  /* @maj,min rule */
+            if (major != rule->maj)
+                continue;
+            if (minor < rule->min0 || minor > rule->min1)
+                continue;
+            memset(off, 0, sizeof(off));
+            goto rule_matches;
+        }
+        if (rule->envvar) { /* $envvar=regex rule */
+            str_to_match = getenv(rule->envvar);
+            dbg3("getenv('%s'):'%s'", rule->envvar, str_to_match);
+            if (!str_to_match)
+                continue;
+        }
+        /* else: str_to_match = device_name */
+
+        if (rule->regex_compiled) {
+            int regex_match = regexec(&rule->match, str_to_match, ARRAY_SIZE(off), off, 0);
+            dbg3("regex_match for '%s':%d", str_to_match, regex_match);
+            //bb_error_msg("matches:");
+            //for (int i = 0; i < ARRAY_SIZE(off); i++) {
+            //  if (off[i].rm_so < 0) continue;
+            //  bb_error_msg("match %d: '%.*s'\n", i,
+            //      (int)(off[i].rm_eo - off[i].rm_so),
+            //      device_name + off[i].rm_so);
+            //}
+
+            if (regex_match != 0
+            /* regexec returns whole pattern as "range" 0 */
+             || off[0].rm_so != 0
+             || (int)off[0].rm_eo != (int)strlen(str_to_match)
+            ) {
+                continue; /* this rule doesn't match */
+            }
+        }
+        /* else: it's final implicit "match-all" rule */
+ rule_matches:
+        dbg2("rule matched, line %d", G.parser ? G.parser->lineno : -1);
+#endif
+        /* Build alias name */
+        alias = NULL;
+        if (ENABLE_FEATURE_MDEV_RENAME && rule->ren_mov) {
+            aliaslink = rule->ren_mov[0];
+            if (aliaslink == '!') {
+                /* "!": suppress node creation/deletion */
+                major = -2;
+            }
+            else if (aliaslink == '>' || aliaslink == '=') {
+                if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) {
+                    char *s;
+                    char *p;
+                    unsigned n;
+
+                    /* substitute %1..9 with off[1..9], if any */
+                    n = 0;
+                    s = rule->ren_mov;
+                    while (*s)
+                        if (*s++ == '%')
+                            n++;
+
+                    p = alias = xzalloc(strlen(rule->ren_mov) + n * strlen(str_to_match));
+                    s = rule->ren_mov + 1;
+                    while (*s) {
+                        *p = *s;
+                        if ('%' == *s) {
+                            unsigned i = (s[1] - '0');
+                            if (i <= 9 && off[i].rm_so >= 0) {
+                                n = off[i].rm_eo - off[i].rm_so;
+                                strncpy(p, str_to_match + off[i].rm_so, n);
+                                p += n - 1;
+                                s++;
+                            }
+                        }
+                        p++;
+                        s++;
+                    }
+                } else {
+                    alias = xstrdup(rule->ren_mov + 1);
+                }
+            }
+        }
+        dbg3("alias:'%s'", alias);
+
+        command = NULL;
+        IF_FEATURE_MDEV_EXEC(command = rule->r_cmd;)
+        if (command) {
+            /* Are we running this command now?
+             * Run @cmd on create, $cmd on delete, *cmd on any
+             */
+            if ((command[0] == '@' && operation == OP_add)
+             || (command[0] == '$' && operation == OP_remove)
+             || (command[0] == '*')
+            ) {
+                command++;
+            } else {
+                command = NULL;
+            }
+        }
+        dbg3("command:'%s'", command);
+
+        /* "Execute" the line we found */
+        node_name = device_name;
+        if (ENABLE_FEATURE_MDEV_RENAME && alias) {
+            node_name = alias = build_alias(alias, device_name);
+            dbg3("alias2:'%s'", alias);
+        }
+
+        if (operation == OP_add && major >= 0) {
+            char *slash = strrchr(node_name, '/');
+            if (slash) {
+                *slash = '\0';
+                mkdir_recursive(node_name);
+                *slash = '/';
+            }
+            if (ENABLE_FEATURE_MDEV_CONF) {
+                dbg1("mknod %s (%d,%d) %o"
+                    " %u:%u",
+                    node_name, major, minor, rule->mode | type,
+                    rule->ugid.uid, rule->ugid.gid
+                );
+            } else {
+                dbg1("mknod %s (%d,%d) %o",
+                    node_name, major, minor, rule->mode | type
+                );
+            }
+            if (mknod(node_name, rule->mode | type, makedev(major, minor)) && errno != EEXIST)
+                bb_perror_msg("can't create '%s'", node_name);
+            if (ENABLE_FEATURE_MDEV_CONF) {
+                chmod(node_name, rule->mode);
+                chown(node_name, rule->ugid.uid, rule->ugid.gid);
+            }
+            if (major == G.root_major && minor == G.root_minor)
+                symlink(node_name, "root");
+            if (ENABLE_FEATURE_MDEV_RENAME && alias) {
+                if (aliaslink == '>') {
+//TODO: on devtmpfs, device_name already exists and symlink() fails.
+//End result is that instead of symlink, we have two nodes.
+//What should be done?
+                    dbg1("symlink: %s", device_name);
+                    symlink(node_name, device_name);
+                }
+            }
+        }
+
+        if (ENABLE_FEATURE_MDEV_EXEC && command) {
+            /* setenv will leak memory, use putenv/unsetenv/free */
+            char *s = xasprintf("%s=%s", "MDEV", node_name);
+            putenv(s);
+            dbg1("running: %s", command);
+            if (system(command) == -1)
+                bb_perror_msg("can't run '%s'", command);
+            bb_unsetenv_and_free(s);
+        }
+
+        if (operation == OP_remove && major >= -1) {
+            if (ENABLE_FEATURE_MDEV_RENAME && alias) {
+                if (aliaslink == '>') {
+                    dbg1("unlink: %s", device_name);
+                    unlink(device_name);
+                }
+            }
+            dbg1("unlink: %s", node_name);
+            unlink(node_name);
+        }
+
+        if (ENABLE_FEATURE_MDEV_RENAME)
+            free(alias);
+
+        /* We found matching line.
+         * Stop unless it was prefixed with '-'
          */
-        subsystem_slash_devname = concat_path_file(G.subsystem, device_name);
-        path = subsystem_slash_devname;
-    }
-
-    /* If we have config file, look up user settings */
-    if (ENABLE_FEATURE_MDEV_CONF)
-        parser = config_open2("/etc/mdev.conf", fopen_for_read);
-
-    do {
-        int keep_matching;
-        struct bb_uidgid_t ugid;
-        char *tokens[4];
-        char *command = NULL;
-        char *alias = NULL;
-        char aliaslink = aliaslink; /* for compiler */
-
-        /* Defaults in case we won't match any line */
-        ugid.uid = ugid.gid = 0;
-        keep_matching = 0;
-        mode = 0660;
-
-        if (ENABLE_FEATURE_MDEV_CONF
-         && config_read(parser, tokens, 4, 3, "# \t", PARSE_NORMAL)
-        ) {
-            char *val;
-            char *str_to_match;
-            regmatch_t off[1 + 9 * ENABLE_FEATURE_MDEV_RENAME_REGEXP];
-
-            val = tokens[0];
-            keep_matching = ('-' == val[0]);
-            val += keep_matching; /* swallow leading dash */
-
-            /* Match against either "subsystem/device_name"
-             * or "device_name" alone */
-            str_to_match = strchr(val, '/') ? path : device_name;
-
-            /* Fields: regex uid:gid mode [alias] [cmd] */
-
-            if (val[0] == '@') {
-                /* @major,minor[-minor2] */
-                /* (useful when name is ambiguous:
-                 * "/sys/class/usb/lp0" and
-                 * "/sys/class/printer/lp0") */
-                int cmaj, cmin0, cmin1, sc;
-                if (major < 0)
-                    continue; /* no dev, no match */
-                sc = sscanf(val, "@%u,%u-%u", &cmaj, &cmin0, &cmin1);
-                if (sc < 1
-                 || major != cmaj
-                 || (sc == 2 && minor != cmin0)
-                 || (sc == 3 && (minor < cmin0 || minor > cmin1))
-                ) {
-                    continue; /* this line doesn't match */
-                }
-                goto line_matches;
-            }
-            if (val[0] == '$') {
-                /* regex to match an environment variable */
-                char *eq = strchr(++val, '=');
-                if (!eq)
-                    continue;
-                *eq = '\0';
-                str_to_match = getenv(val);
-                if (!str_to_match)
-                    continue;
-                str_to_match -= strlen(val) + 1;
-                *eq = '=';
-            }
-            /* else: regex to match [subsystem/]device_name */
-
-            {
-                regex_t match;
-                int result;
-
-                xregcomp(&match, val, REG_EXTENDED);
-                result = regexec(&match, str_to_match, ARRAY_SIZE(off), off, 0);
-                regfree(&match);
-                //bb_error_msg("matches:");
-                //for (int i = 0; i < ARRAY_SIZE(off); i++) {
-                //  if (off[i].rm_so < 0) continue;
-                //  bb_error_msg("match %d: '%.*s'\n", i,
-                //      (int)(off[i].rm_eo - off[i].rm_so),
-                //      device_name + off[i].rm_so);
-                //}
-
-                /* If no match, skip rest of line */
-                /* (regexec returns whole pattern as "range" 0) */
-                if (result
-                 || off[0].rm_so
-                 || ((int)off[0].rm_eo != (int)strlen(str_to_match))
-                ) {
-                    continue; /* this line doesn't match */
-                }
-            }
- line_matches:
-            /* This line matches. Stop parsing after parsing
-             * the rest the line unless keep_matching == 1 */
-
-            /* 2nd field: uid:gid - device ownership */
-            if (get_uidgid(&ugid, tokens[1], 1) == 0)
-                bb_error_msg("unknown user/group %s on line %d", tokens[1], parser->lineno);
-
-            /* 3rd field: mode - device permissions */
-            bb_parse_mode(tokens[2], &mode);
-
-            val = tokens[3];
-            /* 4th field (opt): ">|=alias" or "!" to not create the node */
-
-            if (ENABLE_FEATURE_MDEV_RENAME && val) {
-                char *a, *s, *st;
-
-                a = val;
-                s = strchrnul(val, ' ');
-                st = strchrnul(val, '\t');
-                if (st < s)
-                    s = st;
-                st = (s[0] && s[1]) ? s+1 : NULL;
-
-                aliaslink = a[0];
-                if (aliaslink == '!' && s == a+1) {
-                    val = st;
-                    /* "!": suppress node creation/deletion */
-                    major = -2;
-                }
-                else if (aliaslink == '>' || aliaslink == '=') {
-                    val = st;
-                    s[0] = '\0';
-                    if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) {
-                        char *p;
-                        unsigned i, n;
-
-                        /* substitute %1..9 with off[1..9], if any */
-                        n = 0;
-                        s = a;
-                        while (*s)
-                            if (*s++ == '%')
-                                n++;
-
-                        p = alias = xzalloc(strlen(a) + n * strlen(str_to_match));
-                        s = a + 1;
-                        while (*s) {
-                            *p = *s;
-                            if ('%' == *s) {
-                                i = (s[1] - '0');
-                                if (i <= 9 && off[i].rm_so >= 0) {
-                                    n = off[i].rm_eo - off[i].rm_so;
-                                    strncpy(p, str_to_match + off[i].rm_so, n);
-                                    p += n - 1;
-                                    s++;
-                                }
-                            }
-                            p++;
-                            s++;
-                        }
-                    } else {
-                        alias = xstrdup(a + 1);
-                    }
-                }
-            }
-
-            if (ENABLE_FEATURE_MDEV_EXEC && val) {
-                const char *s = "$@*";
-                const char *s2 = strchr(s, val[0]);
-
-                if (!s2) {
-                    bb_error_msg("bad line %u", parser->lineno);
-                    if (ENABLE_FEATURE_MDEV_RENAME)
-                        free(alias);
-                    continue;
-                }
-
-                /* Are we running this command now?
-                 * Run $cmd on delete, @cmd on create, *cmd on both
-                 */
-                if (s2 - s != delete) {
-                    /* We are here if: '*',
-                     * or: '@' and delete = 0,
-                     * or: '$' and delete = 1
-                     */
-                    command = xstrdup(val + 1);
-                }
-            }
-        }
-
-        /* End of field parsing */
-
-        /* "Execute" the line we found */
-        {
-            const char *node_name;
-
-            node_name = device_name;
-            if (ENABLE_FEATURE_MDEV_RENAME && alias)
-                node_name = alias = build_alias(alias, device_name);
-
-            if (!delete && major >= 0) {
-                if (mknod(node_name, mode | type, makedev(major, minor)) && errno != EEXIST)
-                    bb_perror_msg("can't create '%s'", node_name);
-                if (major == G.root_major && minor == G.root_minor)
-                    symlink(node_name, "root");
-                if (ENABLE_FEATURE_MDEV_CONF) {
-                    chmod(node_name, mode);
-                    chown(node_name, ugid.uid, ugid.gid);
-                }
-                if (ENABLE_FEATURE_MDEV_RENAME && alias) {
-                    if (aliaslink == '>')
-                        symlink(node_name, device_name);
-                }
-            }
-
-            if (ENABLE_FEATURE_MDEV_EXEC && command) {
-                /* setenv will leak memory, use putenv/unsetenv/free */
-                char *s = xasprintf("%s=%s", "MDEV", node_name);
-                char *s1 = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem);
-                putenv(s);
-                putenv(s1);
-                if (system(command) == -1)
-                    bb_perror_msg("can't run '%s'", command);
-                bb_unsetenv_and_free(s1);
-                bb_unsetenv_and_free(s);
-                free(command);
-            }
-
-            if (delete && major >= -1) {
-                if (ENABLE_FEATURE_MDEV_RENAME && alias) {
-                    if (aliaslink == '>')
-                        unlink(device_name);
-                }
-                unlink(node_name);
-            }
-
-            if (ENABLE_FEATURE_MDEV_RENAME)
-                free(alias);
-        }
-
-        /* We found matching line.
-         * Stop unless it was prefixed with '-' */
-        if (ENABLE_FEATURE_MDEV_CONF && !keep_matching)
+        if (!ENABLE_FEATURE_MDEV_CONF || !rule->keep_matching)
             break;
-
-    /* end of "while line is read from /etc/mdev.conf" */
-    } while (ENABLE_FEATURE_MDEV_CONF);
-
-    if (ENABLE_FEATURE_MDEV_CONF)
-        config_close(parser);
-    free(subsystem_slash_devname);
+    } /* for (;;) */
 }
 
@@ -421 +841 @@
     strcpy(scratch, fileName);
     scratch[len] = '\0';
-    make_device(scratch, /*delete:*/ 0);
+    make_device(/*DEVNAME:*/ NULL, scratch, OP_add);
 
     return TRUE;
@@ -436 +856 @@
     if (1 == depth) {
         free(G.subsystem);
+        if (G.subsys_env) {
+            bb_unsetenv_and_free(G.subsys_env);
+            G.subsys_env = NULL;
+        }
         G.subsystem = strrchr(fileName, '/');
-        if (G.subsystem)
+        if (G.subsystem) {
             G.subsystem = xstrdup(G.subsystem + 1);
+            G.subsys_env = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem);
+            putenv(G.subsys_env);
+        }
     }
 
@@ -458 +885 @@
 {
     int cnt;
-    int firmware_fd, loading_fd, data_fd;
+    int firmware_fd, loading_fd;
 
     /* check for /lib/firmware/$FIRMWARE */
     xchdir("/lib/firmware");
-    firmware_fd = xopen(firmware, O_RDONLY);
-
-    /* in case we goto out ... */
-    data_fd = -1;
+    firmware_fd = open(firmware, O_RDONLY); /* can fail */
 
     /* check for /sys/$DEVPATH/loading ... give 30 seconds to appear */
@@ -471 +895 @@
     for (cnt = 0; cnt < 30; ++cnt) {
         loading_fd = open("loading", O_WRONLY);
-        if (loading_fd != -1)
+        if (loading_fd >= 0)
             goto loading;
         sleep(1);
@@ -478 +902 @@
 
  loading:
-    /* tell kernel we're loading by "echo 1 > /sys/$DEVPATH/loading" */
-    if (full_write(loading_fd, "1", 1) != 1)
-        goto out;
-
-    /* load firmware into /sys/$DEVPATH/data */
-    data_fd = open("data", O_WRONLY);
-    if (data_fd == -1)
-        goto out;
-    cnt = bb_copyfd_eof(firmware_fd, data_fd);
-
-    /* tell kernel result by "echo [0|-1] > /sys/$DEVPATH/loading" */
+    cnt = 0;
+    if (firmware_fd >= 0) {
+        int data_fd;
+
+        /* tell kernel we're loading by "echo 1 > /sys/$DEVPATH/loading" */
+        if (full_write(loading_fd, "1", 1) != 1)
+            goto out;
+
+        /* load firmware into /sys/$DEVPATH/data */
+        data_fd = open("data", O_WRONLY);
+        if (data_fd < 0)
+            goto out;
+        cnt = bb_copyfd_eof(firmware_fd, data_fd);
+        if (ENABLE_FEATURE_CLEAN_UP)
+            close(data_fd);
+    }
+
+    /* Tell kernel result by "echo [0|-1] > /sys/$DEVPATH/loading"
+     * Note: we emit -1 also if firmware file wasn't found.
+     * There are cases when otherwise kernel would wait for minutes
+     * before timing out.
+     */
     if (cnt > 0)
         full_write(loading_fd, "0", 1);
@@ -495 +930 @@
 
  out:
+    xchdir("/dev");
     if (ENABLE_FEATURE_CLEAN_UP) {
         close(firmware_fd);
         close(loading_fd);
-        close(data_fd);
+    }
+}
+
+static char *curtime(void)
+{
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    sprintf(G.timestr, "%u.%06u", (unsigned)tv.tv_sec % 60, (unsigned)tv.tv_usec);
+    return G.timestr;
+}
+
+static void open_mdev_log(const char *seq, unsigned my_pid)
+{
+    int logfd = open("mdev.log", O_WRONLY | O_APPEND);
+    if (logfd >= 0) {
+        xmove_fd(logfd, STDERR_FILENO);
+        G.verbose = 2;
+        applet_name = xasprintf("%s[%s]", applet_name, seq ? seq : utoa(my_pid));
+    }
+}
+
+/* If it exists, does /dev/mdev.seq match $SEQNUM?
+ * If it does not match, earlier mdev is running
+ * in parallel, and we need to wait.
+ * Active mdev pokes us with SIGCHLD to check the new file.
+ */
+static int
+wait_for_seqfile(const char *seq)
+{
+    /* We time out after 2 sec */
+    static const struct timespec ts = { 0, 32*1000*1000 };
+    int timeout = 2000 / 32;
+    int seq_fd = -1;
+    int do_once = 1;
+    sigset_t set_CHLD;
+
+    sigemptyset(&set_CHLD);
+    sigaddset(&set_CHLD, SIGCHLD);
+    sigprocmask(SIG_BLOCK, &set_CHLD, NULL);
+
+    for (;;) {
+        int seqlen;
+        char seqbuf[sizeof(int)*3 + 2];
+
+        if (seq_fd < 0) {
+            seq_fd = open("mdev.seq", O_RDWR);
+            if (seq_fd < 0)
+                break;
+        }
+        seqlen = pread(seq_fd, seqbuf, sizeof(seqbuf) - 1, 0);
+        if (seqlen < 0) {
+            close(seq_fd);
+            seq_fd = -1;
+            break;
+        }
+        seqbuf[seqlen] = '\0';
+        if (seqbuf[0] == '\n') {
+            /* seed file: write out seq ASAP */
+            xwrite_str(seq_fd, seq);
+            xlseek(seq_fd, 0, SEEK_SET);
+            dbg2("first seq written");
+            break;
+        }
+        if (strcmp(seq, seqbuf) == 0) {
+            /* correct idx */
+            break;
+        }
+        if (do_once) {
+            dbg2("%s waiting for '%s'", curtime(), seqbuf);
+            do_once = 0;
+        }
+        if (sigtimedwait(&set_CHLD, NULL, &ts) >= 0) {
+            dbg3("woken up");
+            continue; /* don't decrement timeout! */
+        }
+        if (--timeout == 0) {
+            dbg1("%s waiting for '%s'", "timed out", seqbuf);
+            break;
+        }
+    }
+    sigprocmask(SIG_UNBLOCK, &set_CHLD, NULL);
+    return seq_fd;
+}
+
+static void signal_mdevs(unsigned my_pid)
+{
+    procps_status_t* p = NULL;
+    while ((p = procps_scan(p, PSSCAN_ARGV0)) != NULL) {
+        if (p->pid != my_pid
+         && p->argv0
+         && strcmp(bb_basename(p->argv0), "mdev") == 0
+        ) {
+            kill(p->pid, SIGCHLD);
+        }
     }
 }
@@ -506 +1035 @@
 {
     RESERVE_CONFIG_BUFFER(temp, PATH_MAX + SCRATCH_SIZE);
+
+    INIT_G();
+
+#if ENABLE_FEATURE_MDEV_CONF
+    G.filename = "/etc/mdev.conf";
+#endif
 
     /* We can be called as hotplug helper */
@@ -517 +1052 @@
 
     if (argv[1] && strcmp(argv[1], "-s") == 0) {
-        /* Scan:
-         * mdev -s
+        /*
+         * Scan: mdev -s
          */
         struct stat st;
 
+#if ENABLE_FEATURE_MDEV_CONF
+        /* Same as xrealloc_vector(NULL, 4, 0): */
+        G.rule_vec = xzalloc((1 << 4) * sizeof(*G.rule_vec));
+#endif
         xstat("/", &st);
         G.root_major = major(st.st_dev);
         G.root_minor = minor(st.st_dev);
+
+        putenv((char*)"ACTION=add");
 
         /* ACTION_FOLLOWLINKS is needed since in newer kernels
@@ -549 +1090 @@
         char *seq;
         char *action;
-        char *env_path;
-        static const char keywords[] ALIGN1 = "remove\0add\0";
-        enum { OP_remove = 0, OP_add };
+        char *env_devname;
+        char *env_devpath;
+        unsigned my_pid;
+        int seq_fd;
         smalluint op;
 
         /* Hotplug:
          * env ACTION=... DEVPATH=... SUBSYSTEM=... [SEQNUM=...] mdev
-         * ACTION can be "add" or "remove"
+         * ACTION can be "add", "remove", "change"
          * DEVPATH is like "/block/sda" or "/class/input/mice"
          */
         action = getenv("ACTION");
-        env_path = getenv("DEVPATH");
+        op = index_in_strings(keywords, action);
+        env_devname = getenv("DEVNAME"); /* can be NULL */
+        env_devpath = getenv("DEVPATH");
         G.subsystem = getenv("SUBSYSTEM");
-        if (!action || !env_path /*|| !G.subsystem*/)
+        if (!action || !env_devpath /*|| !G.subsystem*/)
             bb_show_usage();
         fw = getenv("FIRMWARE");
-        op = index_in_strings(keywords, action);
-        /* If it exists, does /dev/mdev.seq match $SEQNUM?
-         * If it does not match, earlier mdev is running
-         * in parallel, and we need to wait */
         seq = getenv("SEQNUM");
-        if (seq) {
-            int timeout = 2000 / 32; /* 2000 msec */
-            do {
-                int seqlen;
-                char seqbuf[sizeof(int)*3 + 2];
-
-                seqlen = open_read_close("mdev.seq", seqbuf, sizeof(seqbuf-1));
-                if (seqlen < 0) {
-                    seq = NULL;
-                    break;
-                }
-                seqbuf[seqlen] = '\0';
-                if (seqbuf[0] == '\n' /* seed file? */
-                 || strcmp(seq, seqbuf) == 0 /* correct idx? */
-                ) {
-                    break;
-                }
-                usleep(32*1000);
-            } while (--timeout);
-        }
-
-        snprintf(temp, PATH_MAX, "/sys%s", env_path);
+
+        my_pid = getpid();
+        open_mdev_log(seq, my_pid);
+
+        seq_fd = seq ? wait_for_seqfile(seq) : -1;
+
+        dbg1("%s "
+            "ACTION:%s SUBSYSTEM:%s DEVNAME:%s DEVPATH:%s"
+            "%s%s",
+            curtime(),
+            action, G.subsystem, env_devname, env_devpath,
+            fw ? " FW:" : "", fw ? fw : ""
+        );
+
+        snprintf(temp, PATH_MAX, "/sys%s", env_devpath);
         if (op == OP_remove) {
             /* Ignoring "remove firmware". It was reported
@@ -597 +1130 @@
              * of device nodes. */
             if (!fw)
-                make_device(temp, /*delete:*/ 1);
-        }
-        else if (op == OP_add) {
-            make_device(temp, /*delete:*/ 0);
+                make_device(env_devname, temp, op);
+        }
+        else {
+            make_device(env_devname, temp, op);
             if (ENABLE_FEATURE_MDEV_LOAD_FIRMWARE) {
-                if (fw)
+                if (op == OP_add && fw)
                     load_firmware(fw, temp);
             }
         }
 
-        if (seq) {
-            xopen_xwrite_close("mdev.seq", utoa(xatou(seq) + 1));
+        dbg1("%s exiting", curtime());
+        if (seq_fd >= 0) {
+            xwrite_str(seq_fd, utoa(xatou(seq) + 1));
+            signal_mdevs(my_pid);
         }
     }