X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=namedev.c;h=bbc5b40069d552179c90768417827e6adb3a0bfb;hp=025a14aea4a5ae832c6d9de1987562a859b8112b;hb=82b1698314f004b9d69a14c5054e5f7699aa33ad;hpb=0a5417a0ebe92f96fb103399c9aacdf39c719271 diff --git a/namedev.c b/namedev.c index 025a14aea..bbc5b4006 100644 --- a/namedev.c +++ b/namedev.c @@ -29,24 +29,20 @@ #include #include #include -#include #include #include #include "libsysfs/sysfs/libsysfs.h" #include "list.h" #include "udev.h" +#include "udev_utils.h" #include "udev_version.h" #include "logging.h" #include "namedev.h" -#include "klibc_fixups.h" +#include "udev_db.h" static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr); -LIST_HEAD(config_device_list); -LIST_HEAD(perm_device_list); - - /* compare string with pattern (supports * ? [0-9] [!A-Z]) */ static int strcmp_pattern(const char *p, const char *s) { @@ -100,44 +96,6 @@ static int strcmp_pattern(const char *p, const char *s) return 1; } -static struct perm_device *find_perm(char *name) -{ - struct perm_device *perm; - - list_for_each_entry(perm, &perm_device_list, node) { - if (strcmp_pattern(perm->name, name)) - continue; - return perm; - } - return NULL; -} - -static mode_t get_default_mode(void) -{ - mode_t mode = 0600; /* default to owner rw only */ - - if (strlen(default_mode_str) != 0) - mode = strtol(default_mode_str, NULL, 8); - - return mode; -} - -static char *get_default_owner(void) -{ - if (strlen(default_owner_str) == 0) - strfieldcpy(default_owner_str, "root"); - - return default_owner_str; -} - -static char *get_default_group(void) -{ - if (strlen(default_group_str) == 0) - strfieldcpy(default_group_str, "root"); - - return default_group_str; -} - /* extract possible {attr} and move str behind it */ static char *get_format_attribute(char **str) { @@ -177,6 +135,37 @@ static int get_format_len(char **str) return -1; } +/** Finds the lowest positive N such that N isn't present in + * $(udevroot) either as a file or a symlink. + * + * @param name Name to check for + * @return 0 if didn't exist and N otherwise. + */ +static int find_free_number(struct udevice *udev, const char *name) +{ + char filename[NAME_SIZE]; + int num = 0; + struct udevice db_udev; + + strfieldcpy(filename, name); + while (1) { + dbg("look for existing node '%s'", filename); + memset(&db_udev, 0x00, sizeof(struct udevice)); + if (udev_db_get_device_byname(&db_udev, filename) != 0) { + dbg("free num=%d", num); + return num; + } + + num++; + if (num > 1000) { + info("find_free_number gone crazy (num=%d), aborted", num); + return -1; + } + snprintf(filename, NAME_SIZE, "%s%d", name, num); + filename[NAME_SIZE-1] = '\0'; + } +} + static void apply_format(struct udevice *udev, char *string, size_t maxsize, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) @@ -193,26 +182,32 @@ static void apply_format(struct udevice *udev, char *string, size_t maxsize, char *rest; int slen; struct sysfs_attribute *tmpattr; + unsigned int next_free_number; + struct sysfs_class_device *class_dev_parent; pos = string; - while (1) { - pos = strchr(string, '%'); - if (pos != NULL) { - pos[0] = '\0'; - tail = pos+1; - len = get_format_len(&tail); - c = tail[0]; - strfieldcpy(temp, tail+1); - tail = temp; - } else { + pos = strchr(pos, '%'); + if (pos == NULL) break; - } - dbg("format=%c, string='%s', tail='%s'",c , string, tail); + pos[0] = '\0'; + tail = pos+1; + len = get_format_len(&tail); + c = tail[0]; + strfieldcpy(temp, tail+1); + tail = temp; + dbg("format=%c, string='%s', tail='%s'",c , string, tail); attr = get_format_attribute(&tail); + switch (c) { + case 'p': + if (strlen(udev->devpath) == 0) + break; + strfieldcatmax(string, udev->devpath, maxsize); + dbg("substitute kernel name '%s'", udev->kernel_name); + break; case 'b': if (strlen(udev->bus_id) == 0) break; @@ -274,6 +269,17 @@ static void apply_format(struct udevice *udev, char *string, size_t maxsize, dbg("sysfa attribute '%s' not found", attr); break; } + /* strip trailing whitespace of matching value */ + if (isspace(tmpattr->value[strlen(tmpattr->value)-1])) { + i = len = strlen(tmpattr->value); + while (i > 0 && isspace(tmpattr->value[i-1])) + i--; + if (i < len) { + tmpattr->value[i] = '\0'; + dbg("remove %i trailing whitespace chars from '%s'", + len - i, tmpattr->value); + } + } strfieldcatmax(string, tmpattr->value, maxsize); dbg("substitute sysfs value '%s'", tmpattr->value); } else { @@ -282,6 +288,43 @@ static void apply_format(struct udevice *udev, char *string, size_t maxsize, break; case '%': strfieldcatmax(string, "%", maxsize); + pos++; + break; + case 'e': + next_free_number = find_free_number(udev, string); + if (next_free_number > 0) { + sprintf(temp2, "%d", next_free_number); + strfieldcatmax(string, temp2, maxsize); + } + break; + case 'P': + class_dev_parent = sysfs_get_classdev_parent(class_dev); + if (class_dev_parent != NULL) { + struct udevice udev_parent; + + dbg("found parent '%s', get the node name", class_dev_parent->path); + memset(&udev_parent, 0x00, sizeof(struct udevice)); + /* lookup the name in the udev_db with the DEVPATH of the parent */ + strfieldcpy(udev_parent.devpath, &class_dev_parent->path[strlen(sysfs_path)]); + if (udev_db_get_device(&udev_parent) == 0) { + strfieldcatmax(string, udev_parent.name, maxsize); + dbg("substitute parent node name'%s'", udev_parent.name); + } else + dbg("parent not found in database"); + } + break; + case 'N': + if (udev->tmp_node[0] == '\0') { + dbg("create temporary device node for callout"); + snprintf(udev->tmp_node, NAME_SIZE-1, "%s/.tmp-%u-%u", udev_root, udev->major, udev->minor); + udev_make_node(udev, udev->tmp_node, udev->major, udev->minor, 0600, 0, 0); + } + strfieldcatmax(string, udev->tmp_node, maxsize); + dbg("substitute temporary device node name '%s'", udev->tmp_node); + break; + case 'r': + strfieldcatmax(string, udev_root, maxsize); + dbg("substitute udev_root '%s'", udev_root); break; default: dbg("unknown substitution type '%%%c'", c); @@ -295,69 +338,6 @@ static void apply_format(struct udevice *udev, char *string, size_t maxsize, } } -/* - * Note, we can have multiple files for different busses in here due - * to the mess that USB has for its device tree... - */ -static struct bus_file { - char *bus; - char *file; -} bus_files[] = { - { .bus = "scsi", .file = "vendor" }, - { .bus = "usb", .file = "idVendor" }, - { .bus = "usb", .file = "iInterface" }, - { .bus = "usb-serial", .file = "detach_state" }, - { .bus = "ide", .file = "detach_state" }, - { .bus = "pci", .file = "vendor" }, - {} -}; - -#define SECONDS_TO_WAIT_FOR_FILE 10 -static void wait_for_device_to_initialize(struct sysfs_device *sysfs_device) -{ - /* sleep until we see the file for this specific bus type show up this - * is needed because we can easily out-run the kernel in looking for - * these files before the paticular subsystem has created them in the - * sysfs tree properly. - * - * And people thought that the /sbin/hotplug event system was going to - * be slow, poo on you for arguing that before even testing it... - */ - struct bus_file *b = &bus_files[0]; - struct sysfs_attribute *tmpattr; - int found = 0; - int loop = SECONDS_TO_WAIT_FOR_FILE; - - while (1) { - if (b->bus == NULL) { - if (!found) - break; - /* sleep to give the kernel a chance to create the file */ - sleep(1); - --loop; - if (loop == 0) - break; - b = &bus_files[0]; - } - if (strcmp(sysfs_device->bus, b->bus) == 0) { - found = 1; - dbg("looking for file '%s' on bus '%s'", b->file, b->bus); - tmpattr = sysfs_get_device_attr(sysfs_device, b->file); - if (tmpattr) { - /* found it! */ - goto exit; - } - dbg("can't find '%s' file", b->file); - } - ++b; - } - if (!found) - dbg("did not find bus type '%s' on list of bus_id_files, " - "contact greg@kroah.com", sysfs_device->bus); -exit: - return; /* here to prevent compiler warning... */ -} - static void fix_kernel_name(struct udevice *udev) { char *temp = udev->kernel_name; @@ -371,7 +351,7 @@ static void fix_kernel_name(struct udevice *udev) } } -static int execute_program(char *path, char *value, int len) +static int execute_program(struct udevice *udev, const char *path, char *value, int len) { int retval; int count; @@ -380,28 +360,34 @@ static int execute_program(char *path, char *value, int len) pid_t pid; char *pos; char arg[PROGRAM_SIZE]; - char *argv[sizeof(arg) / 2]; + char *argv[(PROGRAM_SIZE / 2) + 1]; int i; + strfieldcpy(arg, path); i = 0; if (strchr(path, ' ')) { - strfieldcpy(arg, path); pos = arg; while (pos != NULL) { if (pos[0] == '\'') { /* don't separate if in apostrophes */ pos++; argv[i] = strsep(&pos, "\'"); - while (pos[0] == ' ') + while (pos && pos[0] == ' ') pos++; - } else { + } else { argv[i] = strsep(&pos, " "); } dbg("arg[%i] '%s'", i, argv[i]); i++; } + argv[i] = NULL; + dbg("execute '%s' with parsed arguments", arg); + } else { + argv[0] = arg; + argv[1] = udev->subsystem; + argv[2] = NULL; + dbg("execute '%s' with subsystem '%s' argument", arg, argv[1]); } - argv[i] = NULL; retval = pipe(fds); if (retval != 0) { @@ -413,17 +399,9 @@ static int execute_program(char *path, char *value, int len) switch(pid) { case 0: /* child */ - close(STDOUT_FILENO); - - /* dup write side of pipe to STDOUT */ - dup(fds[1]); - if (argv[0] != NULL) { - dbg("execute '%s' with given arguments", argv[0]); - retval = execv(argv[0], argv); - } else { - dbg("execute '%s' with main argument", path); - retval = execv(path, main_argv); - } + /* dup2 write side of pipe to STDOUT */ + dup2(fds[1], STDOUT_FILENO); + retval = execv(arg, argv); info(FIELD_PROGRAM " execution of '%s' failed", path); exit(1); @@ -453,13 +431,13 @@ static int execute_program(char *path, char *value, int len) retval = -1; } - if (i > 0 && value[i] == '\n') + if (i > 0 && value[i-1] == '\n') i--; value[i] = '\0'; dbg("result is '%s'", value); close(fds[0]); - wait(&status); + waitpid(pid, &status, 0); if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) { dbg("exec program status 0x%x", status); @@ -601,102 +579,57 @@ static int match_place(struct config_device *dev, struct sysfs_class_device *cla return 0; } -static struct sysfs_device *get_sysfs_device(struct sysfs_class_device *class_dev) +static int match_rule(struct udevice *udev, struct config_device *dev, + struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) { - struct sysfs_device *sysfs_device; - struct sysfs_class_device *class_dev_parent; - struct timespec tspec; - int loop; - - /* Figure out where the device symlink is at. For char devices this will - * always be in the class_dev->path. But for block devices, it's different. - * The main block device will have the device symlink in it's path, but - * all partitions have the symlink in its parent directory. - * But we need to watch out for block devices that do not have parents, yet - * look like a partition (fd0, loop0, etc.) They all do not have a device - * symlink yet. We do sit and spin on waiting for them right now, we should - * possibly have a whitelist for these devices here... - */ - class_dev_parent = sysfs_get_classdev_parent(class_dev); - if (class_dev_parent) - dbg("Really a partition"); - - tspec.tv_sec = 0; - tspec.tv_nsec = 10000000; /* sleep 10 millisec */ - loop = 10; - while (loop--) { - if (udev_sleep) - nanosleep(&tspec, NULL); - if (class_dev_parent) - sysfs_device = sysfs_get_classdev_device(class_dev_parent); - else - sysfs_device = sysfs_get_classdev_device(class_dev); - - if (sysfs_device != NULL) - goto device_found; - } - dbg("timed out waiting for device symlink, continuing on anyway..."); - -device_found: - /* We have another issue with just the wait above - the sysfs part of - * the kernel may not be quick enough to have created the link to the - * device under the "bus" subsystem. Due to this, the sysfs_device->bus - * will not contain the actual bus name :( - * - * Libsysfs now provides a new API sysfs_get_device_bus(), so use it - * if needed - */ - if (sysfs_device) { - if (sysfs_device->bus[0] != '\0') - goto bus_found; - - loop = 10; - tspec.tv_nsec = 10000000; - while (loop--) { - if (udev_sleep) - nanosleep(&tspec, NULL); - sysfs_get_device_bus(sysfs_device); - - if (sysfs_device->bus[0] != '\0') - goto bus_found; + while (1) { + /* check for matching kernel name */ + if (dev->kernel[0] != '\0') { + dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'", + dev->kernel, class_dev->name); + if (strcmp_pattern(dev->kernel, class_dev->name) != 0) { + dbg(FIELD_KERNEL " is not matching"); + goto exit; + } + dbg(FIELD_KERNEL " matches"); + } + + /* check for matching subsystem */ + if (dev->subsystem[0] != '\0') { + dbg("check for " FIELD_SUBSYSTEM " dev->subsystem='%s' class_dev->name='%s'", + dev->subsystem, class_dev->name); + if (strcmp_pattern(dev->subsystem, udev->subsystem) != 0) { + dbg(FIELD_SUBSYSTEM " is not matching"); + goto exit; + } + dbg(FIELD_SUBSYSTEM " matches"); + } + + /* check for matching driver */ + if (dev->driver[0] != '\0') { + dbg("check for " FIELD_DRIVER " dev->driver='%s' sysfs_device->driver_name='%s'", + dev->driver, sysfs_device->driver_name); + if (strcmp_pattern(dev->driver, sysfs_device->driver_name) != 0) { + dbg(FIELD_DRIVER " is not matching"); + goto try_parent; + } else { + dbg(FIELD_DRIVER " matches"); + } } - dbg("timed out waiting to find the device bus, continuing on anyway"); - goto exit; -bus_found: - dbg("device %s is registered with bus '%s'", - sysfs_device->name, sysfs_device->bus); - } -exit: - return sysfs_device; -} -static int match_rule(struct config_device *dev, struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device) -{ - while (1) { /* check for matching bus value */ if (dev->bus[0] != '\0') { if (sysfs_device == NULL) { dbg("device has no bus"); goto try_parent; } - dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus); + dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'", + dev->bus, sysfs_device->bus); if (strcmp_pattern(dev->bus, sysfs_device->bus) != 0) { dbg(FIELD_BUS " is not matching"); goto try_parent; - } else { - dbg(FIELD_BUS " matches"); - } - } - - /* check for matching kernel name*/ - if (dev->kernel[0] != '\0') { - dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'", dev->kernel, class_dev->name); - if (strcmp_pattern(dev->kernel, class_dev->name) != 0) { - dbg(FIELD_KERNEL " is not matching"); - goto try_parent; - } else { - dbg(FIELD_KERNEL " matches"); } + dbg(FIELD_BUS " matches"); } /* check for matching bus id */ @@ -734,10 +667,12 @@ static int match_rule(struct config_device *dev, struct sysfs_class_device *clas /* execute external program */ if (dev->program[0] != '\0') { + char program[PROGRAM_SIZE]; + dbg("check " FIELD_PROGRAM); - apply_format(udev, dev->program, sizeof(dev->program), - class_dev, sysfs_device); - if (execute_program(dev->program, udev->program_result, NAME_SIZE) != 0) { + strfieldcpy(program, dev->program); + apply_format(udev, program, sizeof(program), class_dev, sysfs_device); + if (execute_program(udev, program, udev->program_result, NAME_SIZE) != 0) { dbg(FIELD_PROGRAM " returned nonzero"); goto try_parent; } else { @@ -747,8 +682,7 @@ static int match_rule(struct config_device *dev, struct sysfs_class_device *clas /* check for matching result of external program */ if (dev->result[0] != '\0') { - dbg("check for " FIELD_RESULT - " dev->result='%s', udev->program_result='%s'", + dbg("check for " FIELD_RESULT " dev->result='%s', udev->program_result='%s'", dev->result, udev->program_result); if (strcmp_pattern(dev->result, udev->program_result) != 0) { dbg(FIELD_RESULT " is not matching"); @@ -758,40 +692,49 @@ static int match_rule(struct config_device *dev, struct sysfs_class_device *clas } } - /* Yeah, we matched! */ + /* we matched */ return 0; try_parent: dbg("try parent sysfs device"); sysfs_device = sysfs_get_device_parent(sysfs_device); if (sysfs_device == NULL) - return -ENODEV; + goto exit; dbg("sysfs_device->path='%s'", sysfs_device->path); dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id); - dbg("sysfs_device->bus='%s'", sysfs_device->bus); } +exit: + return -1; } -int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *udev) +int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_dev) { + struct sysfs_class_device *class_dev_parent; struct sysfs_device *sysfs_device = NULL; struct config_device *dev; - struct perm_device *perm; char *pos; - udev->mode = 0; + dbg("class_dev->name='%s'", class_dev->name); + + /* Figure out where the "device"-symlink is at. For char devices this will + * always be in the class_dev->path. On block devices, only the main block + * device will have the device symlink in it's path. All partition devices + * need to look at the symlink in its parent directory. + */ + class_dev_parent = sysfs_get_classdev_parent(class_dev); + if (class_dev_parent != NULL) { + dbg("given class device has a parent, use this instead"); + sysfs_device = sysfs_get_classdev_device(class_dev_parent); + } else { + sysfs_device = sysfs_get_classdev_device(class_dev); + } - /* find the sysfs_device associated with this class device */ - sysfs_device = get_sysfs_device(class_dev); if (sysfs_device) { - dbg("sysfs_device->path='%s'", sysfs_device->path); - dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id); - dbg("sysfs_device->bus='%s'", sysfs_device->bus); + dbg("found devices device: path='%s', bus_id='%s', bus='%s'", + sysfs_device->path, sysfs_device->bus_id, sysfs_device->bus); strfieldcpy(udev->bus_id, sysfs_device->bus_id); - wait_for_device_to_initialize(sysfs_device); } - dbg("class_dev->name = '%s'", class_dev->name); strfieldcpy(udev->kernel_name, class_dev->name); fix_kernel_name(udev); @@ -807,76 +750,84 @@ int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *ud /* look for a matching rule to apply */ list_for_each_entry(dev, &config_device_list, node) { dbg("process rule"); - if (match_rule(dev, class_dev, udev, sysfs_device) == 0) { - if (dev->name[0] == '\0' && dev->symlink[0] == '\0') { - info("configured rule in '%s' at line %i applied, '%s' is ignored", + if (match_rule(udev, dev, class_dev, sysfs_device) == 0) { + + /* empty name, symlink and perms will not create any node */ + if (dev->name[0] == '\0' && dev->symlink[0] == '\0' && + dev->mode == 0000 && dev->owner[0] == '\0' && dev->group[0] == '\0') { + info("configured rule in '%s[%i]' applied, '%s' is ignored", dev->config_file, dev->config_line, udev->kernel_name); return -1; } + /* apply permissions */ + if (dev->mode != 0000) { + udev->mode = dev->mode; + dbg("applied mode=%#o to '%s'", udev->mode, udev->kernel_name); + } + if (dev->owner[0] != '\0') { + strfieldcpy(udev->owner, dev->owner); + apply_format(udev, udev->owner, sizeof(udev->owner), class_dev, sysfs_device); + dbg("applied owner='%s' to '%s'", udev->owner, udev->kernel_name); + } + if (dev->group[0] != '\0') { + strfieldcpy(udev->group, dev->group); + apply_format(udev, udev->group, sizeof(udev->group), class_dev, sysfs_device); + dbg("applied group='%s' to '%s'", udev->group, udev->kernel_name); + } + + /* collect symlinks for this or the final matching rule */ if (dev->symlink[0] != '\0') { - info("configured rule in '%s' at line %i applied, added symlink '%s'", + char temp[NAME_SIZE]; + + info("configured rule in '%s[%i]' applied, added symlink '%s'", dev->config_file, dev->config_line, dev->symlink); + strfieldcpy(temp, dev->symlink); + apply_format(udev, temp, sizeof(temp), class_dev, sysfs_device); if (udev->symlink[0] != '\0') strfieldcat(udev->symlink, " "); - strfieldcat(udev->symlink, dev->symlink); + strfieldcat(udev->symlink, temp); } + /* rule matches */ if (dev->name[0] != '\0') { - info("configured rule in '%s' at line %i applied, '%s' becomes '%s'", + /* apply all_partitions flag only at a main block device */ + if (dev->partitions > 0 && + (udev->type != 'b' || udev->kernel_number[0] != '\0')) + continue; + + info("configured rule in '%s[%i]' applied, '%s' becomes '%s'", dev->config_file, dev->config_line, udev->kernel_name, dev->name); + strfieldcpy(udev->name, dev->name); - goto found; + apply_format(udev, udev->name, sizeof(udev->name), class_dev, sysfs_device); + strfieldcpy(udev->config_file, dev->config_file); + udev->config_line = dev->config_line; + udev->ignore_remove = dev->ignore_remove; + + if (udev->type == 'n') + goto exit; + + udev->partitions = dev->partitions; + + dbg("name, '%s' is going to have owner='%s', group='%s', mode=%#o partitions=%i", + udev->name, udev->owner, udev->group, udev->mode, udev->partitions); + + goto exit; } } } - /* no rule was found so we use the kernel name */ + /* no rule matched, so we use the kernel name */ strfieldcpy(udev->name, udev->kernel_name); - goto done; - -found: - apply_format(udev, udev->name, sizeof(udev->name), class_dev, sysfs_device); - apply_format(udev, udev->symlink, sizeof(udev->symlink), class_dev, sysfs_device); - udev->partitions = dev->partitions; - -done: - /* get permissions given in rule */ - set_empty_perms(udev, dev->mode, - dev->owner, - dev->group); - - /* get permissions given in config file or set defaults */ - perm = find_perm(udev->name); - if (perm != NULL) { - set_empty_perms(udev, perm->mode, - perm->owner, - perm->group); - } else { - set_empty_perms(udev, get_default_mode(), - get_default_owner(), - get_default_group()); - } + dbg("no rule found, use kernel name '%s'", udev->name); - dbg("name, '%s' is going to have owner='%s', group='%s', mode = %#o", - udev->name, udev->owner, udev->group, udev->mode); +exit: + if (udev->tmp_node[0] != '\0') { + dbg("removing temporary device node"); + unlink_secure(udev->tmp_node); + udev->tmp_node[0] = '\0'; + } return 0; } - -int namedev_init(void) -{ - int retval; - - retval = namedev_init_rules(); - if (retval) - return retval; - - retval = namedev_init_permissions(); - if (retval) - return retval; - - dump_config_dev_list(); - dump_perm_dev_list(); - return retval; -}