X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=util-linux%2Fmdev.c;h=8acc4d21da99d0af701b623b73e4c1b2c5e34110;hb=0180b57aaf9fd18c2f54be508a1dc2a64f848ed1;hp=b0efd98b50cf76698cd95f459be29f3f99c4c70c;hpb=651a2697f725f10c1ebdb8947925b5a9c6cf4fe2;p=oweals%2Fbusybox.git diff --git a/util-linux/mdev.c b/util-linux/mdev.c index b0efd98b5..8acc4d21d 100644 --- a/util-linux/mdev.c +++ b/util-linux/mdev.c @@ -5,9 +5,99 @@ * Copyright 2005 Rob Landley * Copyright 2005 Frank Sorenson * - * Licensed under GPL version 2, see file LICENSE in this tarball for details. + * Licensed under GPLv2, see file LICENSE in this source tree. */ + +//config:config MDEV +//config: bool "mdev (16 kb)" +//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 firmware" +//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 "common_bufsiz.h" #include "xregex.h" /* "mdev -s" scans /sys/class/xxx, looking for directories which have dev @@ -27,20 +117,11 @@ * (todo: explain "delete" and $FIRMWARE) * * 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 * (actually, an alias to it) by kernel. This rule instructs mdev @@ -61,17 +142,379 @@ * This happens regardless of /sys/class/.../dev existence. */ +/* 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("HH:MM:SS.123456")]; } FIX_ALIASING; -#define G (*(struct globals*)&bb_common_bufsiz1) +#define G (*(struct globals*)bb_common_bufsiz1) +#define INIT_G() do { \ + setup_common_bufsiz(); \ + 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(); +} + +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]) == 0) { + bb_error_msg("unknown user/group '%s' on line %d", tokens[1], G.parser->lineno); + goto next_rule; + } + + /* 3rd field: mode - device permissions */ + G.cur_rule.mode = 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 = xmemdup(&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. * This function potentionally reallocates the alias parameter. @@ -86,7 +529,7 @@ static char *build_alias(char *alias, const char *device_name) dest = strrchr(alias, '/'); 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" */ dest = alias; @@ -100,16 +543,16 @@ static char *build_alias(char *alias, const char *device_name) /* 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) - * path string. + * after NUL, but we promise to not mangle it (IOW: to restore NUL if needed). * 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) +static void make_device(char *device_name, char *path, int operation) { - char *device_name, *subsystem_slash_devname; 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 * the data, so we don't need to worry about null terminating the string @@ -117,298 +560,296 @@ static void make_device(char *path, int delete) * We also depend on path having writeable space after it. */ 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) return; /* 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; } } - - /* Determine device name, type, major and minor */ - device_name = (char*) bb_basename(path); - /* http://kernel.org/doc/pending/hotplug.txt says that only + /* else: for delete, -1 still deletes the node, but < -1 suppresses that */ + + /* 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)) + if (strstr(path, "/block/") || (G.subsystem && is_prefixed_with(G.subsystem, "block"))) 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 - */ - 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; +#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 */ - - /* 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 = '='; + 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: 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 */ - } + } + /* 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; } - 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 */ - /* mode = strtoul(tokens[2], NULL, 8); */ - bb_parse_mode(tokens[2], &mode); - - val = tokens[3]; - /* 4th field (opt): >|=alias */ - - if (ENABLE_FEATURE_MDEV_RENAME && val) { - aliaslink = val[0]; - if (aliaslink == '>' || aliaslink == '=') { - char *a, *s, *st; + else if (aliaslink == '>' || aliaslink == '=') { + if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) { + char *s; char *p; - unsigned i, n; - - a = val; - s = strchrnul(val, ' '); - st = strchrnul(val, '\t'); - if (st < s) - s = st; - val = (s[0] && s[1]) ? s+1 : NULL; - s[0] = '\0'; - - if (ENABLE_FEATURE_MDEV_RENAME_REGEXP) { - /* 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++; - } + 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(a + 1); + p++; + s++; } + } else { + alias = xstrdup(rule->ren_mov + 1); } } + } + dbg3("alias:'%s'", alias); - 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) - command = xstrdup(val + 1); + 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; } } - - /* End of field parsing */ + dbg3("command:'%s'", command); /* "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); + 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); - char *s1 = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem); - putenv(s); - putenv(s1); - if (system(command) == -1) - bb_perror_msg("can't run '%s'", command); - unsetenv("SUBSYSTEM"); - free(s1); - unsetenv("MDEV"); - free(s); - free(command); - } + 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 (delete) { - if (ENABLE_FEATURE_MDEV_RENAME && alias) { - if (aliaslink == '>') - unlink(device_name); + if (operation == OP_remove && major >= -1) { + if (ENABLE_FEATURE_MDEV_RENAME && alias) { + if (aliaslink == '>') { + dbg1("unlink: %s", device_name); + unlink(device_name); } - unlink(node_name); } - - if (ENABLE_FEATURE_MDEV_RENAME) - free(alias); + 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 '-' */ - if (ENABLE_FEATURE_MDEV_CONF && !keep_matching) + * Stop unless it was prefixed with '-' + */ + 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 (;;) */ } -/* File callback for /sys/ traversal */ +/* File callback for /sys/ traversal. + * We act only on "/sys/.../dev" (pseudo)file + */ static int FAST_FUNC fileAction(const char *fileName, struct stat *statbuf UNUSED_PARAM, void *userData, int depth UNUSED_PARAM) { size_t len = strlen(fileName) - 4; /* can't underflow */ - char *scratch = userData; - - /* len check is for paranoid reasons */ - if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX) - return FALSE; + char *path = userData; /* char array[PATH_MAX + SCRATCH_SIZE] */ + char subsys[PATH_MAX]; + int res; + + /* Is it a ".../dev" file? (len check is for paranoid reasons) */ + if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX - 32) + return FALSE; /* not .../dev */ + + strcpy(path, fileName); + path[len] = '\0'; + + /* Read ".../subsystem" symlink in the same directory where ".../dev" is */ + strcpy(subsys, path); + strcpy(subsys + len, "/subsystem"); + res = readlink(subsys, subsys, sizeof(subsys)-1); + if (res > 0) { + subsys[res] = '\0'; + free(G.subsystem); + if (G.subsys_env) { + bb_unsetenv_and_free(G.subsys_env); + G.subsys_env = NULL; + } + /* Set G.subsystem and $SUBSYSTEM from symlink's last component */ + G.subsystem = strrchr(subsys, '/'); + if (G.subsystem) { + G.subsystem = xstrdup(G.subsystem + 1); + G.subsys_env = xasprintf("%s=%s", "SUBSYSTEM", G.subsystem); + putenv(G.subsys_env); + } + } - strcpy(scratch, fileName); - scratch[len] = '\0'; - make_device(scratch, /*delete:*/ 0); + make_device(/*DEVNAME:*/ NULL, path, OP_add); return TRUE; } @@ -419,15 +860,6 @@ static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM, void *userData UNUSED_PARAM, int depth) { - /* Extract device subsystem -- the name of the directory - * under /sys/class/ */ - if (1 == depth) { - free(G.subsystem); - G.subsystem = strrchr(fileName, '/'); - if (G.subsystem) - G.subsystem = xstrdup(G.subsystem + 1); - } - return (depth >= MAX_SYSFS_DEPTH ? SKIP : TRUE); } @@ -445,47 +877,164 @@ static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM, static void load_firmware(const char *firmware, const char *sysfs_path) { 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 = -1; + if (chdir("/lib/firmware") == 0) + firmware_fd = open(firmware, O_RDONLY); /* can fail */ /* check for /sys/$DEVPATH/loading ... give 30 seconds to appear */ xchdir(sysfs_path); for (cnt = 0; cnt < 30; ++cnt) { loading_fd = open("loading", O_WRONLY); - if (loading_fd != -1) + if (loading_fd >= 0) goto loading; sleep(1); } goto out; 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); + 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" */ + /* 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); else full_write(loading_fd, "-1", 2); 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( + strftime_HHMMSS(G.timestr, sizeof(G.timestr), &tv.tv_sec), + ".%06u", + (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(unsigned expected_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(long)*3 + 2]; + unsigned seqbufnum; + + if (seq_fd < 0) { + seq_fd = open("mdev.seq", O_RDWR); + if (seq_fd < 0) + break; + close_on_exec_on(seq_fd); + } + 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' || seqbuf[0] == '\0') { + /* seed file: write out seq ASAP */ + xwrite_str(seq_fd, utoa(expected_seq)); + xlseek(seq_fd, 0, SEEK_SET); + dbg2("first seq written"); + break; + } + seqbufnum = atoll(seqbuf); + if (seqbufnum == expected_seq) { + /* correct idx */ + break; + } + if (seqbufnum > expected_seq) { + /* a later mdev runs already (this was seen by users to happen) */ + /* do not overwrite seqfile on exit */ + close(seq_fd); + seq_fd = -1; + break; + } + if (do_once) { + dbg2("%s mdev.seq='%s', need '%u'", curtime(), seqbuf, expected_seq); + do_once = 0; + } + if (sigtimedwait(&set_CHLD, NULL, &ts) >= 0) { + dbg3("woken up"); + continue; /* don't decrement timeout! */ + } + if (--timeout == 0) { + dbg1("%s mdev.seq='%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); + } } } @@ -494,6 +1043,12 @@ int mdev_main(int argc UNUSED_PARAM, char **argv) { 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 */ /* Kernel cannot provide suitable stdio fds for us, do it ourself */ bb_sanitize_stdio(); @@ -504,98 +1059,88 @@ int mdev_main(int argc UNUSED_PARAM, char **argv) xchdir("/dev"); 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); - /* ACTION_FOLLOWLINKS is needed since in newer kernels - * /sys/block/loop* (for example) are symlinks to dirs, - * not real directories. - * (kernel's CONFIG_SYSFS_DEPRECATED makes them real dirs, - * but we can't enforce that on users) - */ - if (access("/sys/class/block", F_OK) != 0) { - /* Scan obsolete /sys/block only if /sys/class/block - * doesn't exist. Otherwise we'll have dupes. - * Also, do not complain if it doesn't exist. - * Some people configure kernel to have no blockdevs. - */ - recursive_action("/sys/block", - ACTION_RECURSE | ACTION_FOLLOWLINKS | ACTION_QUIET, - fileAction, dirAction, temp, 0); - } - recursive_action("/sys/class", - ACTION_RECURSE | ACTION_FOLLOWLINKS, - fileAction, dirAction, temp, 0); + putenv((char*)"ACTION=add"); + + /* Create all devices from /sys/dev hierarchy */ + recursive_action("/sys/dev", + ACTION_RECURSE | ACTION_FOLLOWLINKS, + fileAction, dirAction, temp, 0); } else { char *fw; 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; + unsigned seqnum = seqnum; /* for compiler */ + 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"); + env_devname = getenv("DEVNAME"); /* can be NULL */ G.subsystem = getenv("SUBSYSTEM"); - if (!action || !env_path /*|| !G.subsystem*/) + action = getenv("ACTION"); + env_devpath = getenv("DEVPATH"); + 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"); + op = index_in_strings(keywords, action); + + my_pid = getpid(); + open_mdev_log(seq, my_pid); + + seq_fd = -1; 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); + seqnum = atoll(seq); + seq_fd = wait_for_seqfile(seqnum); } - snprintf(temp, PATH_MAX, "/sys%s", env_path); + 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 * to happen and to cause erroneous deletion * of device nodes. */ if (!fw) - make_device(temp, /*delete:*/ 1); + make_device(env_devname, temp, op); } - else if (op == OP_add) { - make_device(temp, /*delete:*/ 0); + 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(seqnum + 1)); + signal_mdevs(my_pid); } }