X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=util-linux%2Fmdev.c;h=5ac8015551c6ebb4a299065487d7428cf84be7a7;hb=4bdeaaf556043964d7d772b492882a6835eb4622;hp=acc5012d468d7653bd81a6a0cea0f0d1a0a4385e;hpb=e9a7a6212b5881bd29ee5936b492f4d8899df8bb;p=oweals%2Fbusybox.git diff --git a/util-linux/mdev.c b/util-linux/mdev.c index acc5012d4..5ac801555 100644 --- a/util-linux/mdev.c +++ b/util-linux/mdev.c @@ -9,255 +9,478 @@ * Licensed under GPL version 2, see file LICENSE in this tarball for details. */ -#include "busybox.h" +#include "libbb.h" #include "xregex.h" -#define DEV_PATH "/dev" +struct globals { + int root_major, root_minor; +}; +#define G (*(struct globals*)&bb_common_bufsiz1) +#define root_major (G.root_major) +#define root_minor (G.root_minor) + +/* Prevent infinite loops in /sys symlinks */ +#define MAX_SYSFS_DEPTH 3 -struct mdev_globals +/* We use additional 64+ bytes in make_device() */ +#define SCRATCH_SIZE 80 + +#if ENABLE_FEATURE_MDEV_RENAME +/* Builds an alias path. + * This function potentionally reallocates the alias parameter. + */ +static char *build_alias(char *alias, const char *device_name) { - int root_major, root_minor; -} mdev_globals; + char *dest; + + /* ">bar/": rename to bar/device_name */ + /* ">bar[/]baz": rename to bar[/]baz */ + dest = strrchr(alias, '/'); + if (dest) { /* ">bar/[baz]" ? */ + *dest = '\0'; /* mkdir bar */ + bb_make_directory(alias, 0755, FILEUTILS_RECUR); + *dest = '/'; + if (dest[1] == '\0') { /* ">bar/" => ">bar/device_name" */ + dest = alias; + alias = concat_path_file(alias, device_name); + free(dest); + } + } -#define bbg mdev_globals + return alias; +} +#endif /* mknod in /dev based on a path like "/sys/block/hda/hda1" */ +/* NB: "mdev -s" may call us many times, do not leak memory/fds! */ static void make_device(char *path, int delete) { - char *device_name; - int major, minor, type, len, fd; + const char *device_name; + int major, minor, type, len; int mode = 0660; - uid_t uid = 0; - gid_t gid = 0; - char *temp = path + strlen(path); +#if ENABLE_FEATURE_MDEV_CONF + struct bb_uidgid_t ugid = { 0, 0 }; + parser_t *parser; + char *tokens[5]; +#endif +#if ENABLE_FEATURE_MDEV_EXEC char *command = NULL; +#endif +#if ENABLE_FEATURE_MDEV_RENAME + char *alias = NULL; + char aliaslink = aliaslink; /* for compiler */ +#endif + char *dev_maj_min = path + strlen(path); + + /* Force the configuration file settings exactly. */ + umask(0); /* 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 - * because sscanf() will stop at the first nondigit, which \n is. We - * also depend on path having writeable space after it. */ - + * because sscanf() will stop at the first nondigit, which \n is. + * We also depend on path having writeable space after it. + */ + major = -1; if (!delete) { - strcat(path, "/dev"); - fd = open(path, O_RDONLY); - len = read(fd, temp + 1, 64); - *temp++ = 0; - close(fd); - if (len < 1) return; + strcpy(dev_maj_min, "/dev"); + len = open_read_close(path, dev_maj_min + 1, 64); + *dev_maj_min++ = '\0'; + if (len < 1) { + if (!ENABLE_FEATURE_MDEV_EXEC) + return; + /* no "dev" file, so just try to run script */ + *dev_maj_min = '\0'; + } else if (sscanf(dev_maj_min, "%u:%u", &major, &minor) != 2) { + major = -1; + } } /* Determine device name, type, major and minor */ + device_name = bb_basename(path); + /* 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. */ + type = S_IFCHR; + if (strstr(path, "/block/")) + type = S_IFBLK; + +#if ENABLE_FEATURE_MDEV_CONF + parser = config_open2("/etc/mdev.conf", fopen_for_read); + + /* If we have config file, look up user settings */ + while (config_read(parser, tokens, 4, 3, "# \t", PARSE_NORMAL)) { + regmatch_t off[1 + 9*ENABLE_FEATURE_MDEV_RENAME_REGEXP]; + char *val; + + /* Fields: regex uid:gid mode [alias] [cmd] */ + + /* 1st field: @... */ + if (tokens[0][0] == '@') { + /* @major,minor[-last] */ + /* (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(tokens[0], "@%u,%u-%u", &cmaj, &cmin0, &cmin1); + if (sc < 1 || major != cmaj + || (sc == 2 && minor != cmin0) + || (sc == 3 && (minor < cmin0 || minor > cmin1)) + ) { + continue; /* no match */ + } + } else { /* ... or regex to match device name */ + regex_t match; + int result; + + /* Is this it? */ + xregcomp(&match, tokens[0], REG_EXTENDED); + result = regexec(&match, device_name, 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 not this device, skip rest of line */ + /* (regexec returns whole pattern as "range" 0) */ + if (result || off[0].rm_so + || ((int)off[0].rm_eo != (int)strlen(device_name)) + ) { + continue; + } + } - device_name = strrchr(path, '/') + 1; - type = path[5]=='c' ? S_IFCHR : S_IFBLK; - - /* If we have a config file, look up permissions for this device */ - - if (ENABLE_FEATURE_MDEV_CONF) { - char *conf, *pos, *end; - - /* mmap the config file */ - if (-1 != (fd=open("/etc/mdev.conf",O_RDONLY))) { - len = lseek(fd, 0, SEEK_END); - conf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0); - if (conf) { - int line = 0; - - /* Loop through lines in mmaped file*/ - for (pos=conf; pos-confpw_uid; - } - s++; - /* parse GID */ - gid = strtoul(s, &s2, 10); - if (end2 != s2) { - struct group *grp; - grp = getgrnam(strndupa(s, end2-s)); - if (!grp) break; - gid = grp->gr_gid; - } - } else if (field == 2) { - /* mode */ - - mode = strtoul(pos, &pos, 8); - if (pos != end2) break; - } else if (ENABLE_FEATURE_MDEV_EXEC && field == 3) { - // Command to run - char *s = "@$*", *s2; - if (!(s2 = strchr(s, *pos++))) { - // Force error - field = 1; - break; - } - if ((s2-s+1) & (1<alias */ +#if ENABLE_FEATURE_MDEV_RENAME + if (!val) + break; + aliaslink = *val; + if (aliaslink == '>' || aliaslink == '=') { + char *s; +#if ENABLE_FEATURE_MDEV_RENAME_REGEXP + char *p; + unsigned i, n; +#endif + char *a = val; + s = strchr(val, ' '); + val = (s && s[1]) ? s+1 : NULL; +#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(device_name)); + 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, device_name + off[i].rm_so, n); + p += n - 1; + s++; } - - /* Did everything parse happily? */ - - if (field > 2) break; - if (field) bb_error_msg_and_die("Bad line %d",line); - - /* Next line */ - pos = ++end; } - munmap(conf, len); + p++; + s++; } - close(fd); +#else + alias = xstrdup(a + 1); +#endif } - } +#endif /* ENABLE_FEATURE_MDEV_RENAME */ + +#if ENABLE_FEATURE_MDEV_EXEC + /* The rest (opt): command to run */ + if (!val) + break; + { + const char *s = "@$*"; + const char *s2 = strchr(s, *val); + + if (!s2) + bb_error_msg_and_die("bad line %u", parser->lineno); + + /* Correlate the position in the "@$*" with the delete + * step so that we get the proper behavior: + * @cmd: run on create + * $cmd: run on delete + * *cmd: run on both + */ + if ((s2 - s + 1) /*1/2/3*/ & /*1/2*/ (1 + delete)) { + command = xstrdup(val + 1); + } + } +#endif + /* end of field parsing */ + break; /* we found matching line, stop */ + } /* end of "while line is read from /etc/mdev.conf" */ + + config_close(parser); +#endif /* ENABLE_FEATURE_MDEV_CONF */ + + if (!delete && major >= 0) { + + if (ENABLE_FEATURE_MDEV_RENAME) + unlink(device_name); - umask(0); - if (!delete) { - if (sscanf(temp, "%d:%d", &major, &minor) != 2) return; if (mknod(device_name, mode | type, makedev(major, minor)) && errno != EEXIST) - bb_perror_msg_and_die("mknod %s failed", device_name); + bb_perror_msg_and_die("mknod %s", device_name); - if (major == bbg.root_major && minor == bbg.root_minor) + if (major == root_major && minor == root_minor) symlink(device_name, "root"); - if (ENABLE_FEATURE_MDEV_CONF) chown(device_name, uid, gid); +#if ENABLE_FEATURE_MDEV_CONF + chown(device_name, ugid.uid, ugid.gid); + +#if ENABLE_FEATURE_MDEV_RENAME + if (alias) { + alias = build_alias(alias, device_name); + + /* move the device, and optionally + * make a symlink to moved device node */ + if (rename(device_name, alias) == 0 && aliaslink == '>') + symlink(alias, device_name); + + free(alias); + } +#endif +#endif } - if (command) { - int rc; - char *s; - s=xasprintf("MDEV=%s",device_name); - putenv(s); - rc = system(command); - s[4]=0; +#if ENABLE_FEATURE_MDEV_EXEC + if (command) { + /* setenv will leak memory, use putenv/unsetenv/free */ + char *s = xasprintf("MDEV=%s", device_name); putenv(s); + if (system(command) == -1) + bb_perror_msg_and_die("can't run '%s'", command); + s[4] = '\0'; + unsetenv(s); free(s); free(command); - if (rc == -1) bb_perror_msg_and_die("Couldn't run %s", command); } - if (delete) unlink(device_name); +#endif + + if (delete) { + unlink(device_name); + /* At creation time, device might have been moved + * and a symlink might have been created. Undo that. */ +#if ENABLE_FEATURE_MDEV_RENAME + if (alias) { + alias = build_alias(alias, device_name); + unlink(alias); + free(alias); + } +#endif + } } -/* Recursive search of /sys/block or /sys/class. path must be a writeable - * buffer of size PATH_MAX containing the directory string to start at. */ - -static void find_dev(char *path) +/* File callback for /sys/ traversal */ +static int FAST_FUNC fileAction(const char *fileName, + struct stat *statbuf UNUSED_PARAM, + void *userData, + int depth UNUSED_PARAM) { - DIR *dir; - size_t len = strlen(path); - struct dirent *entry; - - if ((dir = opendir(path)) == NULL) - return; - - while ((entry = readdir(dir)) != NULL) { - struct stat st; - - /* Skip "." and ".." (also skips hidden files, which is ok) */ + size_t len = strlen(fileName) - 4; /* can't underflow */ + char *scratch = userData; - if (entry->d_name[0] == '.') - continue; + /* len check is for paranoid reasons */ + if (strcmp(fileName + len, "/dev") != 0 || len >= PATH_MAX) + return FALSE; - // uClibc doesn't fill out entry->d_type reliably. so we use lstat(). + strcpy(scratch, fileName); + scratch[len] = '\0'; + make_device(scratch, 0); - snprintf(path+len, PATH_MAX-len, "/%s", entry->d_name); - if (!lstat(path, &st) && S_ISDIR(st.st_mode)) find_dev(path); - path[len] = 0; + return TRUE; +} - /* If there's a dev entry, mknod it */ +/* Directory callback for /sys/ traversal */ +static int FAST_FUNC dirAction(const char *fileName UNUSED_PARAM, + struct stat *statbuf UNUSED_PARAM, + void *userData UNUSED_PARAM, + int depth) +{ + return (depth >= MAX_SYSFS_DEPTH ? SKIP : TRUE); +} - if (!strcmp(entry->d_name, "dev")) make_device(path, 0); +/* For the full gory details, see linux/Documentation/firmware_class/README + * + * Firmware loading works like this: + * - kernel sets FIRMWARE env var + * - userspace checks /lib/firmware/$FIRMWARE + * - userspace waits for /sys/$DEVPATH/loading to appear + * - userspace writes "1" to /sys/$DEVPATH/loading + * - userspace copies /lib/firmware/$FIRMWARE into /sys/$DEVPATH/data + * - userspace writes "0" (worked) or "-1" (failed) to /sys/$DEVPATH/loading + * - kernel loads firmware into device + */ +static void load_firmware(const char *const firmware, const char *const sysfs_path) +{ + int cnt; + int firmware_fd, loading_fd, data_fd; + + /* check for /lib/firmware/$FIRMWARE */ + xchdir("/lib/firmware"); + firmware_fd = xopen(firmware, O_RDONLY); + + /* in case we goto out ... */ + data_fd = -1; + + /* 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) + 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 by `cat /lib/firmware/$FIRMWARE > /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` */ + if (cnt > 0) + full_write(loading_fd, "0", 1); + else + full_write(loading_fd, "-1", 2); + + out: + if (ENABLE_FEATURE_CLEAN_UP) { + close(firmware_fd); + close(loading_fd); + close(data_fd); } - - closedir(dir); } -int mdev_main(int argc, char *argv[]) +int mdev_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int mdev_main(int argc UNUSED_PARAM, char **argv) { - char *action; - char *env_path; - RESERVE_CONFIG_BUFFER(temp,PATH_MAX); - - xchdir(DEV_PATH); - - /* Scan */ - - if (argc == 2 && !strcmp(argv[1],"-s")) { + RESERVE_CONFIG_BUFFER(temp, PATH_MAX + SCRATCH_SIZE); + + /* We can be called as hotplug helper */ + /* Kernel cannot provide suitable stdio fds for us, do it ourself */ +#if 1 + bb_sanitize_stdio(); +#else + /* Debug code */ + /* Replace LOGFILE by other file or device name if you need */ +#define LOGFILE "/dev/console" + /* Just making sure fd 0 is not closed, + * we don't really intend to read from it */ + xmove_fd(xopen("/", O_RDONLY), STDIN_FILENO); + xmove_fd(xopen(LOGFILE, O_WRONLY|O_APPEND), STDOUT_FILENO); + xmove_fd(xopen(LOGFILE, O_WRONLY|O_APPEND), STDERR_FILENO); +#endif + + xchdir("/dev"); + + if (argv[1] && !strcmp(argv[1], "-s")) { + /* Scan: + * mdev -s + */ struct stat st; - stat("/", &st); // If this fails, we have bigger problems. - bbg.root_major=major(st.st_dev); - bbg.root_minor=minor(st.st_dev); - strcpy(temp,"/sys/block"); - find_dev(temp); - strcpy(temp,"/sys/class"); - find_dev(temp); - - /* Hotplug */ - + xstat("/", &st); + root_major = major(st.st_dev); + 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) */ + recursive_action("/sys/block", + ACTION_RECURSE | ACTION_FOLLOWLINKS, + fileAction, dirAction, temp, 0); + recursive_action("/sys/class", + ACTION_RECURSE | ACTION_FOLLOWLINKS, + fileAction, dirAction, temp, 0); } else { + char *seq; + char *action; + char *env_path; + char seqbuf[sizeof(int)*3 + 2]; + int seqlen = seqlen; /* for compiler */ + + /* Hotplug: + * env ACTION=... DEVPATH=... [SEQNUM=...] mdev + * ACTION can be "add" or "remove" + * DEVPATH is like "/block/sda" or "/class/input/mice" + */ action = getenv("ACTION"); env_path = getenv("DEVPATH"); - if (!action || !env_path) + if (!action || !env_path) bb_show_usage(); - sprintf(temp, "/sys%s", env_path); - if (!strcmp(action, "add")) make_device(temp,0); - else if (!strcmp(action, "remove")) make_device(temp,1); + seq = getenv("SEQNUM"); + if (seq) { + int timeout = 2000 / 32; + do { + seqlen = open_read_close("mdev.seq", seqbuf, sizeof(seqbuf-1)); + if (seqlen < 0) + 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); + if (!strcmp(action, "remove")) + make_device(temp, 1); + else if (!strcmp(action, "add")) { + make_device(temp, 0); + + if (ENABLE_FEATURE_MDEV_LOAD_FIRMWARE) { + char *fw = getenv("FIRMWARE"); + if (fw) + load_firmware(fw, temp); + } + } + + if (seq && seqlen >= 0) { + xopen_xwrite_close("mdev.seq", utoa(xatou(seq) + 1)); + } } - if (ENABLE_FEATURE_CLEAN_UP) RELEASE_CONFIG_BUFFER(temp); + if (ENABLE_FEATURE_CLEAN_UP) + RELEASE_CONFIG_BUFFER(temp); + return 0; }