X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=namedev.c;h=08cceacda04d55c795fc9676c17dbc08692745de;hb=7e720bd4ad8257d81d273d98294ebbcc03ade9ba;hp=6d88b5d47a263bf56f71266de84d22de6eafadf9;hpb=1e959a4b05f93bf31d0603a027b50cb148ef7e90;p=elogind.git diff --git a/namedev.c b/namedev.c index 6d88b5d47..e317cc685 100644 --- a/namedev.c +++ b/namedev.c @@ -4,6 +4,7 @@ * Userspace devfs * * Copyright (C) 2003 Greg Kroah-Hartman + * Copyright (C) 2003-2005 Kay Sievers * * * This program is free software; you can redistribute it and/or modify it @@ -21,9 +22,6 @@ * */ -/* define this to enable parsing debugging */ -#define DEBUG_PARSER - #include #include #include @@ -33,763 +31,809 @@ #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 "libsysfs/libsysfs.h" - -#define TYPE_LABEL "LABEL" -#define TYPE_NUMBER "NUMBER" -#define TYPE_TOPOLOGY "TOPOLOGY" -#define TYPE_REPLACE "REPLACE" -#define TYPE_CALLOUT "CALLOUT" +#include "udev_db.h" -static LIST_HEAD(config_device_list); +static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr); -static void dump_dev(struct config_device *dev) +/* compare string with pattern (supports * ? [0-9] [!A-Z]) */ +static int strcmp_pattern(const char *p, const char *s) { - switch (dev->type) { - case KERNEL_NAME: - dbg_parse("KERNEL name ='%s'" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, - dev->owner, dev->group, dev->mode); - break; - case LABEL: - dbg_parse("LABEL name = '%s', bus = '%s', sysfs_file = '%s', sysfs_value = '%s'" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, dev->bus, dev->sysfs_file, dev->sysfs_value, - dev->owner, dev->group, dev->mode); - break; - case NUMBER: - dbg_parse("NUMBER name = '%s', bus = '%s', id = '%s'" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, dev->bus, dev->id, - dev->owner, dev->group, dev->mode); - break; - case TOPOLOGY: - dbg_parse("TOPOLOGY name = '%s', bus = '%s', place = '%s'" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, dev->bus, dev->place, - dev->owner, dev->group, dev->mode); - break; - case REPLACE: - dbg_parse("REPLACE name = %s, kernel_name = %s" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, dev->kernel_name, - dev->owner, dev->group, dev->mode); + if (s[0] == '\0') { + while (p[0] == '*') + p++; + return (p[0] != '\0'); + } + switch (p[0]) { + case '[': + { + int not = 0; + p++; + if (p[0] == '!') { + not = 1; + p++; + } + while ((p[0] != '\0') && (p[0] != ']')) { + int match = 0; + if (p[1] == '-') { + if ((s[0] >= p[0]) && (s[0] <= p[2])) + match = 1; + p += 3; + } else { + match = (p[0] == s[0]); + p++; + } + if (match ^ not) { + while ((p[0] != '\0') && (p[0] != ']')) + p++; + if (p[0] == ']') + return strcmp_pattern(p+1, s+1); + } + } + } break; - case CALLOUT: - dbg_parse("CALLOUT name = '%s', program ='%s', bus = '%s', id = '%s'" - " owner = '%s', group = '%s', mode = '%#o'", - dev->name, dev->exec_program, dev->bus, dev->id, - dev->owner, dev->group, dev->mode); + case '*': + if (strcmp_pattern(p, s+1)) + return strcmp_pattern(p+1, s); + return 0; + case '\0': + if (s[0] == '\0') { + return 0; + } break; default: - dbg_parse("Unknown type of device!"); + if ((p[0] == s[0]) || (p[0] == '?')) + return strcmp_pattern(p+1, s+1); + break; } + return 1; } -#define copy_var(a, b, var) \ - if (b->var) \ - a->var = b->var; - -#define copy_string(a, b, var) \ - if (strlen(b->var)) \ - strcpy(a->var, b->var); - -static int add_dev(struct config_device *new_dev) +/* extract possible {attr} and move str behind it */ +static char *get_format_attribute(char **str) { - struct list_head *tmp; - struct config_device *tmp_dev; - - /* loop through the whole list of devices to see if we already have - * this one... */ - list_for_each(tmp, &config_device_list) { - struct config_device *dev = list_entry(tmp, struct config_device, node); - if (strcmp(dev->name, new_dev->name) == 0) { - /* the same, copy the new info into this structure */ - copy_var(dev, new_dev, type); - copy_var(dev, new_dev, mode); - copy_string(dev, new_dev, bus); - copy_string(dev, new_dev, sysfs_file); - copy_string(dev, new_dev, sysfs_value); - copy_string(dev, new_dev, id); - copy_string(dev, new_dev, place); - copy_string(dev, new_dev, kernel_name); - copy_string(dev, new_dev, owner); - copy_string(dev, new_dev, group); - return 0; + char *pos; + char *attr = NULL; + + if (*str[0] == '{') { + pos = strchr(*str, '}'); + if (pos == NULL) { + dbg("missing closing brace for format"); + return NULL; } + pos[0] = '\0'; + attr = *str+1; + *str = pos+1; + dbg("attribute='%s', str='%s'", attr, *str); } - - /* not found, lets create a new structure, and add it to the list */ - tmp_dev = malloc(sizeof(*tmp_dev)); - if (!tmp_dev) - return -ENOMEM; - memcpy(tmp_dev, new_dev, sizeof(*tmp_dev)); - list_add(&tmp_dev->node, &config_device_list); - //dump_dev(tmp_dev); - return 0; + return attr; } -static void dump_dev_list(void) +/* extract possible format length and move str behind it*/ +static int get_format_len(char **str) { - struct list_head *tmp; - - list_for_each(tmp, &config_device_list) { - struct config_device *dev = list_entry(tmp, struct config_device, node); - dump_dev(dev); - } -} - -static int get_value(const char *left, char **orig_string, char **ret_string) -{ - char *temp; - char *string = *orig_string; - - /* eat any whitespace */ - while (isspace(*string)) - ++string; - - /* split based on '=' */ - temp = strsep(&string, "="); - if (strcasecmp(temp, left) == 0) { - /* got it, now strip off the '"' */ - while (isspace(*string)) - ++string; - if (*string == '"') - ++string; - temp = strsep(&string, "\""); - *ret_string = temp; - *orig_string = string; - return 0; + int num; + char *tail; + + if (isdigit(*str[0])) { + num = (int) strtoul(*str, &tail, 10); + if (num > 0) { + *str = tail; + dbg("format length=%i", num); + return num; + } else { + dbg("format parsing error '%s'", *str); + } } - return -ENODEV; -} - -static int get_pair(char **orig_string, char **left, char **right) -{ - char *temp; - char *string = *orig_string; - - /* eat any whitespace */ - while (isspace(*string)) - ++string; - - /* split based on '=' */ - temp = strsep(&string, "="); - *left = temp; - - /* take the right side and strip off the '"' */ - while (isspace(*string)) - ++string; - if (*string == '"') - ++string; - temp = strsep(&string, "\""); - *right = temp; - *orig_string = string; - - return 0; + return -1; } -static int namedev_init_config(void) +/** 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 line[255]; - char *temp; - char *temp2; - char *temp3; - FILE *fd; - int retval = 0; - struct config_device dev; - - dbg("opening %s to read as config", udev_config_filename); - fd = fopen(udev_config_filename, "r"); - if (fd == NULL) { - dbg("Can't open %s", udev_config_filename); - return -ENODEV; - } + char filename[NAME_SIZE]; + int num = 0; + struct udevice db_udev; - /* loop through the whole file */ + strfieldcpy(filename, name); while (1) { - /* get a line */ - temp = fgets(line, sizeof(line), fd); - if (temp == NULL) - break; - - dbg_parse("read %s", temp); - - /* eat the whitespace at the beginning of the line */ - while (isspace(*temp)) - ++temp; - - /* no more line? */ - if (*temp == 0x00) - continue; - - /* see if this is a comment */ - if (*temp == COMMENT_CHARACTER) - continue; - - memset(&dev, 0x00, sizeof(struct config_device)); - - /* parse the line */ - temp2 = strsep(&temp, ","); - if (strcasecmp(temp2, TYPE_LABEL) == 0) { - /* label type */ - dev.type = LABEL; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* file="value" */ - temp2 = strsep(&temp, ","); - retval = get_pair(&temp, &temp2, &temp3); - if (retval) - continue; - strcpy(dev.sysfs_file, temp2); - strcpy(dev.sysfs_value, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg_parse("LABEL name = '%s', bus = '%s', " - "sysfs_file = '%s', sysfs_value = '%s'", - dev.name, dev.bus, dev.sysfs_file, - dev.sysfs_value); - } - - if (strcasecmp(temp2, TYPE_NUMBER) == 0) { - /* number type */ - dev.type = NUMBER; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* ID="id" */ - temp2 = strsep(&temp, ","); - retval = get_value("id", &temp, &temp3); - if (retval) - continue; - strcpy(dev.id, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg_parse("NUMBER name = '%s', bus = '%s', id = '%s'", - dev.name, dev.bus, dev.id); + 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; } - if (strcasecmp(temp2, TYPE_TOPOLOGY) == 0) { - /* number type */ - dev.type = TOPOLOGY; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* PLACE="place" */ - temp2 = strsep(&temp, ","); - retval = get_value("place", &temp, &temp3); - if (retval) - continue; - strcpy(dev.place, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg_parse("TOPOLOGY name = '%s', bus = '%s', place = '%s'", - dev.name, dev.bus, dev.place); - } - - if (strcasecmp(temp2, TYPE_REPLACE) == 0) { - /* number type */ - dev.type = REPLACE; - - /* KERNEL="kernel_name" */ - retval = get_value("KERNEL", &temp, &temp3); - if (retval) - continue; - strcpy(dev.kernel_name, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - dbg_parse("REPLACE name = %s, kernel_name = %s", - dev.name, dev.kernel_name); - } - if (strcasecmp(temp2, TYPE_CALLOUT) == 0) { - /* number type */ - dev.type = CALLOUT; - - /* PROGRAM="executable" */ - retval = get_value("PROGRAM", &temp, &temp3); - if (retval) - continue; - strcpy(dev.exec_program, temp3); - - /* BUS="bus" */ - temp2 = strsep(&temp, ","); - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* ID="id" */ - temp2 = strsep(&temp, ","); - retval = get_value("ID", &temp, &temp3); - if (retval) - continue; - strcpy(dev.id, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - dbg_parse("CALLOUT name = %s, program = %s", - dev.name, dev.exec_program); - } - - retval = add_dev(&dev); - if (retval) { - dbg("add_dev returned with error %d", retval); - goto exit; + 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'; } +} -exit: - fclose(fd); - return retval; -} - - -static int namedev_init_permissions(void) +static void apply_format(struct udevice *udev, char *string, size_t maxsize, + struct sysfs_class_device *class_dev, + struct sysfs_device *sysfs_device) { - char line[255]; - char *temp; - char *temp2; - FILE *fd; - int retval = 0; - struct config_device dev; - - dbg("opening %s to read as permissions config", udev_config_permission_filename); - fd = fopen(udev_config_permission_filename, "r"); - if (fd == NULL) { - dbg("Can't open %s", udev_config_permission_filename); - return -ENODEV; - } - - /* loop through the whole file */ + char temp[NAME_SIZE]; + char temp2[NAME_SIZE]; + char *tail; + char *pos; + char *attr; + int len; + int i; + char c; + char *spos; + char *rest; + int slen; + struct sysfs_attribute *tmpattr; + unsigned int next_free_number; + struct sysfs_class_device *class_dev_parent; + + pos = string; while (1) { - /* get a line */ - temp = fgets(line, sizeof(line), fd); - if (temp == NULL) + pos = strchr(pos, '%'); + if (pos == NULL) break; - dbg_parse("read %s", temp); - - /* eat the whitespace at the beginning of the line */ - while (isspace(*temp)) - ++temp; - - /* no more line? */ - if (*temp == 0x00) - continue; + 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); - /* see if this is a comment */ - if (*temp == COMMENT_CHARACTER) - continue; - memset(&dev, 0x00, sizeof(dev)); - - /* parse the line */ - temp2 = strsep(&temp, ":"); - strncpy(dev.name, temp2, sizeof(dev.name)); - - temp2 = strsep(&temp, ":"); - strncpy(dev.owner, temp2, sizeof(dev.owner)); - - temp2 = strsep(&temp, ":"); - strncpy(dev.group, temp2, sizeof(dev.owner)); - - dev.mode = strtol(temp, NULL, 8); - - dbg_parse("name = %s, owner = %s, group = %s, mode = %#o", - dev.name, dev.owner, dev.group, - dev.mode); - retval = add_dev(&dev); - if (retval) { - dbg("add_dev returned with error %d", retval); - goto exit; + 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; + strfieldcatmax(string, udev->bus_id, maxsize); + dbg("substitute bus_id '%s'", udev->bus_id); + break; + case 'k': + if (strlen(udev->kernel_name) == 0) + break; + strfieldcatmax(string, udev->kernel_name, maxsize); + dbg("substitute kernel name '%s'", udev->kernel_name); + break; + case 'n': + if (strlen(udev->kernel_number) == 0) + break; + strfieldcatmax(string, udev->kernel_number, maxsize); + dbg("substitute kernel number '%s'", udev->kernel_number); + break; + case 'm': + strintcatmax(string, minor(udev->devt), maxsize); + dbg("substitute minor number '%u'", minor(udev->devt)); + break; + case 'M': + strintcatmax(string, major(udev->devt), maxsize); + dbg("substitute major number '%u'", major(udev->devt)); + break; + case 'c': + if (strlen(udev->program_result) == 0) + break; + /* get part part of the result string */ + i = 0; + if (attr != NULL) + i = strtoul(attr, &rest, 10); + if (i > 0) { + foreach_strpart(udev->program_result, " \n\r", spos, slen) { + i--; + if (i == 0) + break; + } + if (i > 0) { + dbg("requested part of result string not found"); + break; + } + if (rest[0] == '+') + strfieldcpy(temp2, spos); + else + strfieldcpymax(temp2, spos, slen+1); + strfieldcatmax(string, temp2, maxsize); + dbg("substitute part of result string '%s'", temp2); + } else { + strfieldcatmax(string, udev->program_result, maxsize); + dbg("substitute result string '%s'", udev->program_result); + } + break; + case 's': + if (attr != NULL) { + tmpattr = find_sysfs_attribute(class_dev, sysfs_device, attr); + if (tmpattr == NULL) { + 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 { + dbg("missing attribute"); + } + 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, "%s/.tmp-%u-%u", udev_root, major(udev->devt), minor(udev->devt)); + udev->tmp_node[NAME_SIZE] = '\0'; + udev_make_node(udev, udev->tmp_node, udev->devt, 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); + break; } - } + /* truncate to specified length */ + if (len > 0) + pos[len] = '\0'; -exit: - fclose(fd); - return retval; -} + strfieldcatmax(string, tail, maxsize); + } +} -static mode_t get_default_mode(struct sysfs_class_device *class_dev) +static void fix_kernel_name(struct udevice *udev) { - /* just default everyone to rw for the world! */ - return 0666; + char *temp = udev->kernel_name; + + while (*temp != 0x00) { + /* Some block devices have a ! in their name, + * we need to change that to / */ + if (*temp == '!') + *temp = '/'; + ++temp; + } } - -static int exec_callout(struct config_device *dev, char *value, int len) +static int execute_program(struct udevice *udev, const char *path, char *value, int len) { int retval; - int res; + int count; int status; int fds[2]; pid_t pid; - int value_set = 0; - char buffer[256]; + char *pos; + char arg[PROGRAM_SIZE]; + char *argv[(PROGRAM_SIZE / 2) + 1]; + int i; + + strfieldcpy(arg, path); + i = 0; + if (strchr(path, ' ')) { + pos = arg; + while (pos != NULL) { + if (pos[0] == '\'') { + /* don't separate if in apostrophes */ + pos++; + argv[i] = strsep(&pos, "\'"); + while (pos && pos[0] == ' ') + pos++; + } 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]); + } - dbg("callout to %s\n", dev->exec_program); retval = pipe(fds); if (retval != 0) { dbg("pipe failed"); return -1; } + pid = fork(); - if (pid == -1) { + switch(pid) { + case 0: + /* child */ + /* 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); + case -1: dbg("fork failed"); return -1; - } - - if (pid == 0) { - /* - * child - */ - close(STDOUT_FILENO); - dup(fds[1]); /* dup write side of pipe to STDOUT */ - retval = execve(dev->exec_program, main_argv, main_envp); - if (retval != 0) { - dbg("child execve failed"); - exit(1); - } - return -1; /* avoid compiler warning */ - } else { - /* - * Parent reads from fds[0]. - */ + default: + /* parent reads from fds[0] */ close(fds[1]); retval = 0; + i = 0; while (1) { - res = read(fds[0], buffer, sizeof(buffer) - 1); - if (res <= 0) + count = read(fds[0], value + i, len - i-1); + if (count <= 0) break; - buffer[res] = '\0'; - if (res > len) { - dbg("callout len %d too short\n", len); - retval = -1; - } - if (value_set) { - dbg("callout value already set"); + + i += count; + if (i >= len-1) { + dbg("result len %d too short", len); retval = -1; - } else { - value_set = 1; - strncpy(value, buffer, len); + break; } } - close(fds[0]); - res = wait(&status); - if (res < 0) { - dbg("wait failed result %d", res); + + if (count < 0) { + dbg("read failed with '%s'", strerror(errno)); retval = -1; } -#ifndef __KLIBC__ + if (i > 0 && value[i-1] == '\n') + i--; + value[i] = '\0'; + dbg("result is '%s'", value); + + close(fds[0]); + waitpid(pid, &status, 0); + if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) { - dbg("callout program status 0x%x", status); + dbg("exec program status 0x%x", status); retval = -1; } -#endif } return retval; } -static int get_attr(struct sysfs_class_device *class_dev, struct udevice *udev) +static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr) +{ + struct sysfs_attribute *tmpattr = NULL; + char *c; + + dbg("look for device attribute '%s'", attr); + /* try to find the attribute in the class device directory */ + tmpattr = sysfs_get_classdev_attr(class_dev, attr); + if (tmpattr) + goto attr_found; + + /* look in the class device directory if present */ + if (sysfs_device) { + tmpattr = sysfs_get_device_attr(sysfs_device, attr); + if (tmpattr) + goto attr_found; + } + + return NULL; + +attr_found: + c = strchr(tmpattr->value, '\n'); + if (c != NULL) + c[0] = '\0'; + + dbg("found attribute '%s'", tmpattr->path); + return tmpattr; +} + +static int compare_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, struct sysfs_pair *pair) +{ + struct sysfs_attribute *tmpattr; + int i; + int len; + + if ((pair == NULL) || (pair->file[0] == '\0') || (pair->value == '\0')) + return -ENODEV; + + tmpattr = find_sysfs_attribute(class_dev, sysfs_device, pair->file); + if (tmpattr == NULL) + return -ENODEV; + + /* strip trailing whitespace of value, if not asked to match for it */ + if (! isspace(pair->value[strlen(pair->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); + } + } + + dbg("compare attribute '%s' value '%s' with '%s'", + pair->file, tmpattr->value, pair->value); + if (strcmp_pattern(pair->value, tmpattr->value) != 0) + return -ENODEV; + + dbg("found matching attribute '%s' with value '%s'", + pair->file, pair->value); + return 0; +} + +static int match_sysfs_pairs(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) +{ + struct sysfs_pair *pair; + int i; + + for (i = 0; i < MAX_SYSFS_PAIRS; ++i) { + pair = &dev->sysfs_pair[i]; + if ((pair->file[0] == '\0') || (pair->value[0] == '\0')) + break; + if (compare_sysfs_attribute(class_dev, sysfs_device, pair) != 0) { + dbg("sysfs attribute doesn't match"); + return -ENODEV; + } + } + + return 0; +} + +static int match_id(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) +{ + char path[SYSFS_PATH_MAX]; + char *temp = NULL; + + /* we have to have a sysfs device for ID to work */ + if (!sysfs_device) + return -ENODEV; + + strfieldcpy(path, sysfs_device->path); + temp = strrchr(path, '/'); + temp++; + dbg("search '%s' in '%s', path='%s'", dev->id, temp, path); + if (strcmp_pattern(dev->id, temp) != 0) + return -ENODEV; + else + return 0; +} + +static int match_place(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) { - struct list_head *tmp; - int retval = 0; + char path[SYSFS_PATH_MAX]; int found; + char *temp = NULL; + + /* we have to have a sysfs device for PLACE to work */ + if (!sysfs_device) + return -ENODEV; - udev->mode = 0; - if (class_dev->sysdevice) { - dbg_parse("class_dev->sysdevice->path = '%s'", class_dev->sysdevice->path); - dbg_parse("class_dev->sysdevice->bus_id = '%s'", class_dev->sysdevice->bus_id); + found = 0; + strfieldcpy(path, sysfs_device->path); + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->place, temp, path); + if (strstr(temp, dev->place) != NULL) { + found = 1; } else { - dbg_parse("class_dev->name = '%s'", class_dev->name); + *temp = 0x00; + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->place, temp, path); + if (strstr(temp, dev->place) != NULL) + found = 1; + } + if (!found) { + dbg("place doesn't match"); + return -ENODEV; } - list_for_each(tmp, &config_device_list) { - struct config_device *dev = list_entry(tmp, struct config_device, node); - switch (dev->type) { - case LABEL: - { - struct sysfs_attribute *tmpattr = NULL; - struct sysfs_class_device *class_dev_parent = NULL; - char *temp = NULL; - - dbg_parse("LABEL: match file '%s' with value '%s'", - dev->sysfs_file, dev->sysfs_value); - /* try to find the attribute in the class device directory */ - tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file); - if (tmpattr) - goto label_found; - - /* look in the class device directory if present */ - if (class_dev->sysdevice) { - tmpattr = sysfs_get_device_attr(class_dev->sysdevice, dev->sysfs_file); - if (tmpattr) - goto label_found; + + return 0; +} + +static int match_rule(struct udevice *udev, struct config_device *dev, + struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) +{ + /* 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"); + } + + /* walk up the chain of physical devices and find a match */ + while (1) { + /* 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; } + dbg(FIELD_DRIVER " matches"); + } - /* bah, let's go backwards up a level to see if the device is there, - * as block partitions don't point to the physical device. Need to fix that - * up in the kernel... - */ - if (strstr(class_dev->path, "block")) { - dbg_parse("looking at block device..."); - if (isdigit(class_dev->path[strlen(class_dev->path)-1])) { - char path[SYSFS_PATH_MAX]; - - dbg_parse("really is a partition..."); - strcpy(path, class_dev->path); - temp = strrchr(path, '/'); - *temp = 0x00; - dbg_parse("looking for a class device at '%s'", path); - class_dev_parent = sysfs_open_class_device(path); - if (class_dev_parent == NULL) { - dbg("sysfs_open_class_device at '%s' failed", path); - continue; - } - dbg_parse("class_dev_parent->name = %s", class_dev_parent->name); - - /* try to find the attribute in the class device directory */ - tmpattr = sysfs_get_classdev_attr(class_dev_parent, dev->sysfs_file); - if (tmpattr) - goto label_found; - - /* look in the class device directory if present */ - if (class_dev_parent->sysdevice) { - tmpattr = sysfs_get_device_attr(class_dev_parent->sysdevice, dev->sysfs_file); - if (tmpattr) - goto label_found; - } - - } + /* check for matching bus value */ + if (dev->bus[0] != '\0') { + if (sysfs_device == NULL) { + dbg("device has no bus"); + goto try_parent; } - if (class_dev_parent) - sysfs_close_class_device(class_dev_parent); - - continue; - -label_found: - tmpattr->value[strlen(tmpattr->value)-1] = 0x00; - dbg_parse("file '%s' found with value '%s' compare with '%s'", dev->sysfs_file, tmpattr->value, dev->sysfs_value); - if (strcmp(dev->sysfs_value, tmpattr->value) != 0) { - if (class_dev_parent) - sysfs_close_class_device(class_dev_parent); - continue; + 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; } + dbg(FIELD_BUS " matches"); + } - strcpy(udev->name, dev->name); - if (isdigit(class_dev->path[strlen(class_dev->path)-1])) { - temp = &class_dev->path[strlen(class_dev->path)-1]; - strcat(udev->name, temp); + /* check for matching bus id */ + if (dev->id[0] != '\0') { + dbg("check " FIELD_ID); + if (match_id(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_ID " is not matching"); + goto try_parent; } - if (dev->mode != 0) { - udev->mode = dev->mode; - strcpy(udev->owner, dev->owner); - strcpy(udev->group, dev->group); + dbg(FIELD_ID " matches"); + } + + /* check for matching place of device */ + if (dev->place[0] != '\0') { + dbg("check " FIELD_PLACE); + if (match_place(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_PLACE " is not matching"); + goto try_parent; } - dbg_parse("file '%s' with value '%s' becomes '%s' - owner = %s, group = %s, mode = %#o", - dev->sysfs_file, dev->sysfs_value, udev->name, - dev->owner, dev->group, dev->mode); - if (class_dev_parent) - sysfs_close_class_device(class_dev_parent); - goto done; - break; + dbg(FIELD_PLACE " matches"); + } + + /* check for matching sysfs pairs */ + if (dev->sysfs_pair[0].file[0] != '\0') { + dbg("check " FIELD_SYSFS " pairs"); + if (match_sysfs_pairs(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_SYSFS " is not matching"); + goto try_parent; } - case NUMBER: - { - char path[SYSFS_PATH_MAX]; - char *temp; - - found = 0; - if (!class_dev->sysdevice) - continue; - strcpy(path, class_dev->sysdevice->path); - temp = strrchr(path, '/'); - dbg_parse("NUMBER path = '%s'", path); - dbg_parse("NUMBER temp = '%s' id = '%s'", temp, dev->id); - if (strstr(temp, dev->id) != NULL) { - found = 1; - } else { - *temp = 0x00; - temp = strrchr(path, '/'); - dbg_parse("NUMBERY temp = '%s' id = '%s'", temp, dev->id); - if (strstr(temp, dev->id) != NULL) - found = 1; + dbg(FIELD_SYSFS " matches"); + } + + /* found matching physical device */ + break; +try_parent: + dbg("try parent sysfs device"); + sysfs_device = sysfs_get_device_parent(sysfs_device); + if (sysfs_device == NULL) + goto exit; + dbg("sysfs_device->path='%s'", sysfs_device->path); + dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id); + } + + /* execute external program */ + if (dev->program[0] != '\0') { + char program[PROGRAM_SIZE]; + + dbg("check " FIELD_PROGRAM); + 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; + } + dbg(FIELD_PROGRAM " returned successful"); + } + + /* check for matching result of external program */ + if (dev->result[0] != '\0') { + 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"); + goto try_parent; + } + dbg(FIELD_RESULT " matches"); + } + + /* rule matches */ + return 0; + +exit: + return -1; +} + +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; + char *pos; + + 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); + } + + if (sysfs_device) { + 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); + } + + strfieldcpy(udev->kernel_name, class_dev->name); + fix_kernel_name(udev); + dbg("udev->kernel_name = '%s'", udev->kernel_name); + + /* get kernel number */ + pos = class_dev->name + strlen(class_dev->name); + while (isdigit(*(pos-1))) + pos--; + strfieldcpy(udev->kernel_number, pos); + dbg("kernel_number='%s'", udev->kernel_number); + + /* look for a matching rule to apply */ + list_for_each_entry(dev, &config_device_list, node) { + dbg("process rule"); + if (match_rule(udev, dev, class_dev, sysfs_device) == 0) { + + /* FIXME: remove old style ignore rule and make OPTION="ignore" mandatory */ + if (dev->name[0] == '\0' && dev->symlink[0] == '\0' && + dev->mode == 0000 && dev->owner[0] == '\0' && dev->group[0] == '\0' && + !dev->ignore_device && !dev->partitions && !dev->ignore_remove) { + info("configured rule in '%s[%i]' applied, '%s' is ignored", + dev->config_file, dev->config_line, udev->kernel_name); + return -1; } - if (!found) - continue; - strcpy(udev->name, dev->name); - if (dev->mode != 0) { - udev->mode = dev->mode; - strcpy(udev->owner, dev->owner); - strcpy(udev->group, dev->group); + /* apply options */ + if (dev->ignore_device) { + info("configured rule in '%s[%i]' applied, '%s' is ignored", + dev->config_file, dev->config_line, udev->kernel_name); + return -1; } - dbg_parse("device id '%s' becomes '%s' - owner = %s, group = %s, mode = %#o", - dev->id, udev->name, - dev->owner, dev->group, dev->mode); - goto done; - break; + if (dev->ignore_remove) { + udev->ignore_remove = dev->ignore_remove; + dbg_parse("remove event should be ignored"); } - case TOPOLOGY: - { - char path[SYSFS_PATH_MAX]; - char *temp; - - if (!class_dev->sysdevice) - continue; - found = 0; - strcpy(path, class_dev->sysdevice->path); - temp = strrchr(path, '/'); - dbg_parse("TOPOLOGY path = '%s'", path); - dbg_parse("TOPOLOGY temp = '%s' place = '%s'", temp, dev->place); - if (strstr(temp, dev->place) != NULL) { - found = 1; - } else { - *temp = 0x00; - temp = strrchr(path, '/'); - dbg_parse("TOPOLOGY temp = '%s' place = '%s'", temp, dev->place); - if (strstr(temp, dev->place) != NULL) - found = 1; + /* apply all_partitions option only at a main block device */ + if (dev->partitions && udev->type == 'b' && udev->kernel_number[0] == '\0') { + udev->partitions = dev->partitions; + dbg("creation of partition nodes requested"); } - if (!found) - continue; - strcpy(udev->name, dev->name); - if (dev->mode != 0) { + /* apply permissions */ + if (dev->mode != 0000) { udev->mode = dev->mode; - strcpy(udev->owner, dev->owner); - strcpy(udev->group, dev->group); + dbg("applied mode=%#o to '%s'", udev->mode, udev->kernel_name); } - dbg_parse("device at '%s' becomes '%s' - owner = %s, group = %s, mode = %#o", - dev->place, udev->name, - dev->owner, dev->group, dev->mode); - goto done; - break; - } - case CALLOUT: - { - char value[ID_SIZE]; - - if (exec_callout(dev, value, sizeof(value))) - continue; - if (strncmp(value, dev->id, sizeof(value)) != 0) - continue; - strcpy(udev->name, dev->name); - if (dev->mode != 0) { - udev->mode = dev->mode; - strcpy(udev->owner, dev->owner); - strcpy(udev->group, dev->group); - } - dbg_parse("device callout '%s' becomes '%s' - owner = %s, group = %s, mode = %#o", - dev->id, udev->name, - dev->owner, dev->group, dev->mode); - goto done; - break; + 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); } - case REPLACE: - if (strcmp(dev->kernel_name, class_dev->name) != 0) - continue; - strcpy(udev->name, dev->name); - if (dev->mode != 0) { - udev->mode = dev->mode; - strcpy(udev->owner, dev->owner); - strcpy(udev->group, dev->group); + 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); } - dbg_parse("'%s' becomes '%s' - owner = %s, group = %s, mode = %#o", - dev->kernel_name, udev->name, - dev->owner, dev->group, dev->mode); - goto done; - break; - case KERNEL_NAME: - break; - default: - dbg_parse("Unknown type of device '%d'", dev->type); - break; - } - } - strcpy(udev->name, class_dev->name); - -done: - /* mode was never set above */ - if (!udev->mode) { - udev->mode = get_default_mode(class_dev); - udev->owner[0] = 0x00; - udev->group[0] = 0x00; - } - return retval; -} -int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *dev) -{ - int retval; + /* collect symlinks for this or the final matching rule */ + if (dev->symlink[0] != '\0') { + 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, temp); + } - retval = get_attr(class_dev, dev); - if (retval) - dbg("get_attr failed"); + /* rule matches */ + if (dev->name[0] != '\0') { + info("configured rule in '%s[%i]' applied, '%s' becomes '%s'", + dev->config_file, dev->config_line, udev->kernel_name, dev->name); - return retval; -} + strfieldcpy(udev->name, dev->name); + 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; -int namedev_init(void) -{ - int retval; - - retval = namedev_init_config(); - if (retval) - return retval; + if (udev->type != 'n') + 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); - retval = namedev_init_permissions(); - if (retval) - return retval; + goto exit; + } + } + } - dump_dev_list(); - return retval; -} + /* no rule matched, so we use the kernel name */ + strfieldcpy(udev->name, udev->kernel_name); + dbg("no rule found, use kernel name '%s'", udev->name); +exit: + if (udev->tmp_node[0] != '\0') { + dbg("removing temporary device node"); + unlink_secure(udev->tmp_node); + udev->tmp_node[0] = '\0'; + } + return 0; +}