X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;ds=sidebyside;f=udev%2Flib%2Flibudev-device.c;h=c27290835af255a5ccec73f2ee4ca2cf5ab6059e;hb=9925ab0451b307b5766b12134bdc178e4c89f297;hp=cc44c78ad79c3b91426915a4c40ec2accb97e38c;hpb=38f27948cdafd8a4b90a6b4f1f54b89891983506;p=elogind.git diff --git a/udev/lib/libudev-device.c b/udev/lib/libudev-device.c index cc44c78ad..c27290835 100644 --- a/udev/lib/libudev-device.c +++ b/udev/lib/libudev-device.c @@ -37,11 +37,12 @@ struct udev_device { char *syspath; const char *devpath; const char *sysname; - char *devname; + char *devnode; char *subsystem; - struct list_head link_list; - struct list_head env_list; + struct udev_list_node devlink_list; + struct udev_list_node properties_list; char *action; + int event_timeout; char *driver; char *devpath_old; char *physdevpath; @@ -51,7 +52,8 @@ struct udev_device { int num_fake_partitions; int devlink_priority; int ignore_remove; - struct list_head attr_list; + struct udev_list_node attr_list; + int info_loaded; }; static size_t syspath_to_db_path(struct udev_device *udev_device, char *filename, size_t len) @@ -71,41 +73,60 @@ static int device_read_db(struct udev_device *udev_device) char filename[UTIL_PATH_SIZE]; char line[UTIL_LINE_SIZE]; FILE *f; - int rc = 0; syspath_to_db_path(udev_device, filename, sizeof(filename)); if (lstat(filename, &stats) != 0) { - info(udev_device->udev, "no db file to read %s: %s\n", filename, strerror(errno)); + info(udev_device->udev, "no db file to read %s: %m\n", filename); return -1; } if ((stats.st_mode & S_IFMT) == S_IFLNK) { char target[UTIL_PATH_SIZE]; int target_len; + char *next; - info(udev_device->udev, "found a symlink as db file\n"); target_len = readlink(filename, target, sizeof(target)); if (target_len > 0) target[target_len] = '\0'; else { - info(udev_device->udev, "error reading db link %s: %s\n", filename, strerror(errno)); + info(udev_device->udev, "error reading db link %s: %m\n", filename); return -1; } - dbg(udev_device->udev, "db link points to '%s'\n", target); - if (asprintf(&udev_device->devname, "%s/%s", udev_get_dev_path(udev_device->udev), target) < 0) + + next = strchr(target, ' '); + if (next != NULL) { + next[0] = '\0'; + next = &next[1]; + } + if (asprintf(&udev_device->devnode, "%s/%s", udev_get_dev_path(udev_device->udev), target) < 0) return -ENOMEM; + while (next != NULL) { + char linkname[UTIL_PATH_SIZE]; + const char *lnk; + + lnk = next; + next = strchr(next, ' '); + if (next != NULL) { + next[0] = '\0'; + next = &next[1]; + } + util_strlcpy(linkname, udev_get_dev_path(udev_device->udev), sizeof(linkname)); + util_strlcat(linkname, "/", sizeof(linkname)); + util_strlcat(linkname, lnk, sizeof(linkname)); + udev_device_add_devlink(udev_device, linkname); + } + info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode); return 0; } f = fopen(filename, "r"); if (f == NULL) { - info(udev_device->udev, "error reading db file %s: %s\n", filename, strerror(errno)); + info(udev_device->udev, "error reading db file %s: %m\n", filename); return -1; } while (fgets(line, sizeof(line), f)) { ssize_t len; const char *val; - unsigned int maj, min; len = strlen(line); if (len < 4) @@ -115,41 +136,86 @@ static int device_read_db(struct udev_device *udev_device) switch(line[0]) { case 'N': - asprintf(&udev_device->devname, "%s/%s", udev_get_dev_path(udev_device->udev), val); - break; - case 'M': - sscanf(val, "%u:%u", &maj, &min); - device_set_devnum(udev_device, makedev(maj, min)); + asprintf(&udev_device->devnode, "%s/%s", udev_get_dev_path(udev_device->udev), val); break; case 'S': util_strlcpy(filename, udev_get_dev_path(udev_device->udev), sizeof(filename)); util_strlcat(filename, "/", sizeof(filename)); util_strlcat(filename, val, sizeof(filename)); - device_add_devlink(udev_device, filename); + udev_device_add_devlink(udev_device, filename); break; case 'L': - device_set_devlink_priority(udev_device, atoi(val)); + udev_device_set_devlink_priority(udev_device, atoi(val)); break; case 'T': - device_set_timeout(udev_device, atoi(val)); + udev_device_set_event_timeout(udev_device, atoi(val)); break; case 'A': - device_set_num_fake_partitions(udev_device, atoi(val)); + udev_device_set_num_fake_partitions(udev_device, atoi(val)); break; case 'R': - device_set_ignore_remove(udev_device, atoi(val)); + udev_device_set_ignore_remove(udev_device, atoi(val)); break; case 'E': - device_add_property_from_string(udev_device, val); + udev_device_add_property_from_string(udev_device, val); break; } } fclose(f); - return rc; + info(udev_device->udev, "device %p filled with db file data\n", udev_device); + return 0; } -struct udev_device *device_init(struct udev *udev) +static int device_read_uevent_file(struct udev_device *udev_device) +{ + char filename[UTIL_PATH_SIZE]; + FILE *f; + char line[UTIL_LINE_SIZE]; + int maj = 0; + int min = 0; + + util_strlcpy(filename, udev_device->syspath, sizeof(filename)); + util_strlcat(filename, "/uevent", sizeof(filename)); + f = fopen(filename, "r"); + if (f == NULL) + return -1; + + while (fgets(line, sizeof(line), f)) { + char *pos; + + pos = strchr(line, '\n'); + if (pos == NULL) + continue; + pos[0] = '\0'; + + if (strncmp(line, "MAJOR=", 6) == 0) + maj = strtoull(&line[6], NULL, 10); + else if (strncmp(line, "MINOR=", 6) == 0) + min = strtoull(&line[6], NULL, 10); + + udev_device_add_property_from_string(udev_device, line); + } + + udev_device->devnum = makedev(maj, min); + + fclose(f); + return 0; +} + +static void device_load_info(struct udev_device *device) +{ + device_read_uevent_file(device); + device_read_db(device); + device->info_loaded = 1; +} + +void udev_device_set_info_loaded(struct udev_device *device) +{ + device->info_loaded = 1; +} + +struct udev_device *device_new(struct udev *udev) { struct udev_device *udev_device; @@ -162,9 +228,9 @@ struct udev_device *device_init(struct udev *udev) memset(udev_device, 0x00, sizeof(struct udev_device)); udev_device->refcount = 1; udev_device->udev = udev; - INIT_LIST_HEAD(&udev_device->link_list); - INIT_LIST_HEAD(&udev_device->env_list); - INIT_LIST_HEAD(&udev_device->attr_list); + udev_list_init(&udev_device->devlink_list); + udev_list_init(&udev_device->properties_list); + udev_list_init(&udev_device->attr_list); info(udev_device->udev, "udev_device: %p created\n", udev_device); return udev_device; } @@ -185,7 +251,10 @@ struct udev_device *device_init(struct udev *udev) **/ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath) { + size_t len; + const char *subdir; char path[UTIL_PATH_SIZE]; + char *pos; struct stat statbuf; struct udev_device *udev_device; @@ -194,63 +263,249 @@ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char * if (syspath == NULL) return NULL; - util_strlcpy(path, syspath, sizeof(path)); - util_strlcat(path, "/uevent", sizeof(path)); - if (stat(path, &statbuf) != 0) { - info(udev, "not a device :%s\n", syspath); + /* path starts in sys */ + len = strlen(udev_get_sys_path(udev)); + if (strncmp(syspath, udev_get_sys_path(udev), len) != 0) { + info(udev, "not in sys :%s\n", syspath); return NULL; } - udev_device = device_init(udev); - if (udev_device == NULL) + /* path is not a root directory */ + subdir = &syspath[len+1]; + pos = strrchr(subdir, '/'); + if (pos == NULL || pos < &subdir[2]) { + info(udev, "not a subdir :%s\n", syspath); return NULL; + } /* resolve possible symlink to real path */ util_strlcpy(path, syspath, sizeof(path)); util_resolve_sys_link(udev, path, sizeof(path)); - device_set_syspath(udev_device, path); + + /* try to resolve the silly block layout if needed */ + if (strncmp(&path[len], "/block/", 7) == 0) { + char block[UTIL_PATH_SIZE]; + char part[UTIL_PATH_SIZE]; + + util_strlcpy(block, path, sizeof(block)); + pos = strrchr(block, '/'); + if (pos == NULL) + return NULL; + util_strlcpy(part, pos, sizeof(part)); + pos[0] = '\0'; + if (util_resolve_sys_link(udev, block, sizeof(block)) == 0) { + util_strlcpy(path, block, sizeof(path)); + util_strlcat(path, part, sizeof(path)); + } + } + + /* path exists in sys */ + if (strncmp(&syspath[len], "/devices/", 9) == 0 || + strncmp(&syspath[len], "/class/", 7) == 0 || + strncmp(&syspath[len], "/block/", 7) == 0) { + char file[UTIL_PATH_SIZE]; + + /* all "devices" require a "uevent" file */ + util_strlcpy(file, path, sizeof(file)); + util_strlcat(file, "/uevent", sizeof(file)); + if (stat(file, &statbuf) != 0) { + info(udev, "not a device: %s\n", syspath); + return NULL; + } + } else { + /* everything else just needs to be a directory */ + if (stat(path, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode)) { + info(udev, "directory not found: %s\n", syspath); + return NULL; + } + } + + udev_device = device_new(udev); + if (udev_device == NULL) + return NULL; + + udev_device_set_syspath(udev_device, path); info(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device)); - if (device_read_db(udev_device) >= 0) - info(udev, "device %p filled with udev database data\n", udev_device); return udev_device; } +struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum) +{ + char path[UTIL_PATH_SIZE]; + const char *type_str; + struct udev_enumerate *udev_enumerate; + struct udev_list_entry *list_entry; + struct udev_device *device = NULL; + + if (type == 'b') + type_str = "block"; + else if (type == 'c') + type_str = "char"; + else + return NULL; + + /* /sys/dev/{block,char}/: link */ + snprintf(path, sizeof(path), "%s/dev/%s/%u:%u", udev_get_sys_path(udev), + type_str, major(devnum), minor(devnum)); + if (util_resolve_sys_link(udev, path, sizeof(path)) == 0) + return udev_device_new_from_syspath(udev, path); + + udev_enumerate = udev_enumerate_new(udev); + if (udev_enumerate == NULL) + return NULL; + + /* fallback to search sys devices for the major/minor */ + if (type == 'b') + udev_enumerate_add_match_subsystem(udev_enumerate, "block"); + else if (type == 'c') + udev_enumerate_add_nomatch_subsystem(udev_enumerate, "block"); + udev_enumerate_scan_devices(udev_enumerate); + udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) { + struct udev_device *device_loop; + + device_loop = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry)); + if (device_loop != NULL) { + if (udev_device_get_devnum(device_loop) == devnum) { + if (type == 'b' && strcmp(udev_device_get_subsystem(device_loop), "block") != 0) + continue; + if (type == 'c' && strcmp(udev_device_get_subsystem(device_loop), "block") == 0) + continue; + device = device_loop; + break; + } + udev_device_unref(device_loop); + } + } + udev_enumerate_unref(udev_enumerate); + return device; +} + +struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname) +{ + size_t sys_path_len; + char path_full[UTIL_PATH_SIZE]; + char *path; + struct stat statbuf; + + sys_path_len = util_strlcpy(path_full, udev_get_sys_path(udev), sizeof(path_full)); + path = &path_full[sys_path_len]; + + if (strcmp(subsystem, "subsystem") == 0) { + util_strlcpy(path, "/subsystem/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + + util_strlcpy(path, "/bus/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + + util_strlcpy(path, "/class/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + goto out; + } + + if (strcmp(subsystem, "module") == 0) { + util_strlcpy(path, "/module/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + goto out; + } + + if (strcmp(subsystem, "drivers") == 0) { + char subsys[UTIL_NAME_SIZE]; + char *driver; + + util_strlcpy(subsys, sysname, sizeof(subsys)); + driver = strchr(subsys, ':'); + if (driver != NULL) { + driver[0] = '\0'; + driver = &driver[1]; + util_strlcpy(path, "/subsystem/", sizeof(path_full) - sys_path_len); + util_strlcat(path, subsys, sizeof(path_full) - sys_path_len); + util_strlcat(path, "/drivers/", sizeof(path_full) - sys_path_len); + util_strlcat(path, driver, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + + util_strlcpy(path, "/bus/", sizeof(path_full) - sys_path_len); + util_strlcat(path, subsys, sizeof(path_full) - sys_path_len); + util_strlcat(path, "/drivers/", sizeof(path_full) - sys_path_len); + util_strlcat(path, driver, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + } + goto out; + } + + util_strlcpy(path, "/subsystem/", sizeof(path_full) - sys_path_len); + util_strlcat(path, subsystem, sizeof(path_full) - sys_path_len); + util_strlcat(path, "/devices/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + + util_strlcpy(path, "/bus/", sizeof(path_full) - sys_path_len); + util_strlcat(path, subsystem, sizeof(path_full) - sys_path_len); + util_strlcat(path, "/devices/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; + + util_strlcpy(path, "/class/", sizeof(path_full) - sys_path_len); + util_strlcat(path, subsystem, sizeof(path_full) - sys_path_len); + util_strlcat(path, "/", sizeof(path_full) - sys_path_len); + util_strlcat(path, sysname, sizeof(path_full) - sys_path_len); + if (stat(path_full, &statbuf) == 0) + goto found; +out: + return NULL; +found: + return udev_device_new_from_syspath(udev, path_full); +} + static struct udev_device *device_new_from_parent(struct udev_device *udev_device) { struct udev_device *udev_device_parent = NULL; char path[UTIL_PATH_SIZE]; - char *pos; + const char *subdir; - if (udev_device == NULL) - return NULL; + /* follow "device" link in deprecated sys layout */ + if (strncmp(udev_device->devpath, "/class/", 7) == 0 || + strncmp(udev_device->devpath, "/block/", 7) == 0) { + util_strlcpy(path, udev_device->syspath, sizeof(path)); + util_strlcat(path, "/device", sizeof(path)); + if (util_resolve_sys_link(udev_device->udev, path, sizeof(path)) == 0) + udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path); + return udev_device_parent; + } util_strlcpy(path, udev_device->syspath, sizeof(path)); + subdir = &path[strlen(udev_get_sys_path(udev_device->udev))+1]; while (1) { - pos = strrchr(path, '/'); - if (pos == path || pos == NULL) + char *pos; + + pos = strrchr(subdir, '/'); + if (pos == NULL || pos < &subdir[2]) break; pos[0] = '\0'; udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path); if (udev_device_parent != NULL) return udev_device_parent; } - - /* follow "device" link in deprecated sys /sys/class/ layout */ - if (strncmp(udev_device->devpath, "/class/", 7) == 0) { - util_strlcpy(path, udev_device->syspath, sizeof(path)); - util_strlcat(path, "/device", sizeof(path)); - if (util_resolve_sys_link(udev_device->udev, path, sizeof(path)) == 0) { - udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path); - if (udev_device_parent != NULL) - return udev_device_parent; - } - } return NULL; } struct udev_device *udev_device_get_parent(struct udev_device *udev_device) { + if (udev_device == NULL) + return NULL; + if (udev_device->parent_device != NULL) { info(udev_device->udev, "returning existing parent %p\n", udev_device->parent_device); return udev_device->parent_device; @@ -259,6 +514,22 @@ struct udev_device *udev_device_get_parent(struct udev_device *udev_device) return udev_device->parent_device; } +struct udev_device *udev_device_get_parent_with_subsystem(struct udev_device *udev_device, const char *subsystem) +{ + struct udev_device *parent; + + parent = udev_device_get_parent(udev_device); + while (parent != NULL) { + const char *parent_subsystem; + + parent_subsystem = udev_device_get_subsystem(parent); + if (parent_subsystem != NULL && strcmp(parent_subsystem, subsystem) == 0) + break; + parent = udev_device_get_parent(parent); + } + return parent; +} + /** * udev_device_get_udev: * @udev_device: udev device @@ -308,15 +579,15 @@ void udev_device_unref(struct udev_device *udev_device) if (udev_device->parent_device != NULL) udev_device_unref(udev_device->parent_device); free(udev_device->syspath); - free(udev_device->devname); + free(udev_device->devnode); free(udev_device->subsystem); - util_name_list_cleanup(udev_device->udev, &udev_device->link_list); - util_name_list_cleanup(udev_device->udev, &udev_device->env_list); + udev_list_cleanup(udev_device->udev, &udev_device->devlink_list); + udev_list_cleanup(udev_device->udev, &udev_device->properties_list); free(udev_device->action); free(udev_device->driver); free(udev_device->devpath_old); free(udev_device->physdevpath); - util_name_list_cleanup(udev_device->udev, &udev_device->attr_list); + udev_list_cleanup(udev_device->udev, &udev_device->attr_list); info(udev_device->udev, "udev_device: %p released\n", udev_device); free(udev_device); } @@ -361,7 +632,7 @@ const char *udev_device_get_sysname(struct udev_device *udev_device) } /** - * udev_device_get_devname: + * udev_device_get_devnode: * @udev_device: udev device * * Retrieve the device node file name belonging to the udev device. @@ -369,11 +640,13 @@ const char *udev_device_get_sysname(struct udev_device *udev_device) * * Returns: the device node file name of the udev device, or #NULL if no device node exists **/ -const char *udev_device_get_devname(struct udev_device *udev_device) +const char *udev_device_get_devnode(struct udev_device *udev_device) { if (udev_device == NULL) return NULL; - return udev_device->devname; + if (!udev_device->info_loaded) + device_load_info(udev_device); + return udev_device->devnode; } /** @@ -419,64 +692,46 @@ const char *udev_device_get_subsystem(struct udev_device *udev_device) } /** - * udev_device_get_devlinks: + * udev_device_get_devlinks_list_entry: * @udev_device: udev device - * @cb: function to be called for every device link found - * @data: data to be passed to the function * - * Retrieve the device links pointing to the device file of the - * udev device. For every device link, the passed function will be - * called with the device link string. - * The path is an absolute path, and starts with the device directory. - * If the function returns 1, remaning device links will be ignored. + * Retrieve the list of device links pointing to the device file of + * the udev device. The next list entry can be retrieved with + * udev_list_entry_next(), which returns #NULL if no more entries exist. + * The devlink path can be retrieved from the list entry by + * udev_list_entry_get_name(). The path is an absolute path, and starts with + * the device directory. * - * Returns: the number of device links passed to the caller, or a negative value on error + * Returns: the first entry of the device node link list **/ -int udev_device_get_devlinks(struct udev_device *udev_device, - int (*cb)(struct udev_device *udev_device, const char *value, void *data), - void *data) +struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device) { - struct util_name_entry *name_loop; - int count = 0; - if (udev_device == NULL) - return -1; - list_for_each_entry(name_loop, &udev_device->link_list, node) { - count++; - if (cb(udev_device, name_loop->name, data) != 0) - break; - } - return count; + return NULL; + if (!udev_device->info_loaded) + device_load_info(udev_device); + return udev_list_get_entry(&udev_device->devlink_list); } /** - * udev_device_get_properties: + * udev_device_get_properties_list_entry: * @udev_device: udev device - * @cb: function to be called for every property found - * @data: data to be passed to the function * - * Retrieve the property key/value pairs belonging to the - * udev device. For every key/value pair, the passed function will be - * called. If the function returns 1, remaning properties will be - * ignored. + * Retrieve the list of key/value device properties of the udev + * device. The next list entry can be retrieved with udev_list_entry_next(), + * which returns #NULL if no more entries exist. The property name + * can be retrieved from the list entry by udev_list_get_name(), + * the property value by udev_list_get_value(). * - * Returns: the number of properties passed to the caller, or a negative value on error + * Returns: the first entry of the property list **/ -int udev_device_get_properties(struct udev_device *udev_device, - int (*cb)(struct udev_device *udev_device, const char *key, const char *value, void *data), - void *data) +struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device) { - struct util_name_entry *name_loop; - int count = 0; - if (udev_device == NULL) - return -1; - list_for_each_entry(name_loop, &udev_device->env_list, node) { - count++; - if (cb(udev_device, name_loop->name, name_loop->value, data) != 0) - break; - } - return count; + return NULL; + if (!udev_device->info_loaded) + device_load_info(udev_device); + return udev_list_get_entry(&udev_device->properties_list); } const char *udev_device_get_driver(struct udev_device *udev_device) @@ -497,6 +752,8 @@ dev_t udev_device_get_devnum(struct udev_device *udev_device) { if (udev_device == NULL) return makedev(0, 0); + if (!udev_device->info_loaded) + device_load_info(udev_device); return udev_device->devnum; } @@ -516,7 +773,7 @@ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device) const char *udev_device_get_attr_value(struct udev_device *udev_device, const char *attr) { - struct util_name_entry *name_loop; + struct udev_list_entry *list_entry; char path[UTIL_PATH_SIZE]; char value[UTIL_NAME_SIZE]; struct stat statbuf; @@ -525,10 +782,10 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch const char *val = NULL; /* look for possibly already cached result */ - list_for_each_entry(name_loop, &udev_device->attr_list, node) { - if (strcmp(name_loop->name, attr) == 0) { - info(udev_device->udev, "'%s' in cache '%s'\n", attr, name_loop->value); - return name_loop->value; + udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_device->attr_list)) { + if (strcmp(udev_list_entry_get_name(list_entry), attr) == 0) { + info(udev_device->udev, "got '%s' (%s) from cache\n", attr, udev_list_entry_get_value(list_entry)); + return udev_list_entry_get_value(list_entry); } } @@ -537,7 +794,7 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch util_strlcat(path, attr, sizeof(path)); if (lstat(path, &statbuf) != 0) { - info(udev_device->udev, "stat '%s' failed: %s\n", path, strerror(errno)); + info(udev_device->udev, "stat '%s' failed: %m\n", path); goto out; } @@ -554,7 +811,8 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch if (pos != NULL) { pos = &pos[1]; info(udev_device->udev, "cache '%s' with link value '%s'\n", attr, pos); - val = util_name_list_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0)->value; + list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0); + val = udev_list_entry_get_value(list_entry); } } goto out; @@ -585,14 +843,16 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch value[size] = '\0'; util_remove_trailing_chars(value, '\n'); info(udev_device->udev, "'%s' has attribute value '%s'\n", path, value); - val = util_name_list_add(udev_device->udev, &udev_device->attr_list, attr, value, 0)->value; + list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, value, 0, 0); + val = udev_list_entry_get_value(list_entry); out: return val; } -int device_set_syspath(struct udev_device *udev_device, const char *syspath) +int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath) { const char *pos; + free(udev_device->syspath); udev_device->syspath = strdup(syspath); if (udev_device->syspath == NULL) return -ENOMEM; @@ -604,7 +864,7 @@ int device_set_syspath(struct udev_device *udev_device, const char *syspath) return 0; } -int device_set_subsystem(struct udev_device *udev_device, const char *subsystem) +int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem) { udev_device->subsystem = strdup(subsystem); if (udev_device->subsystem == NULL) @@ -612,29 +872,29 @@ int device_set_subsystem(struct udev_device *udev_device, const char *subsystem) return 0; } -int device_set_devname(struct udev_device *udev_device, const char *devname) +int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode) { - udev_device->devname = strdup(devname); - if (udev_device->devname == NULL) + udev_device->devnode = strdup(devnode); + if (udev_device->devnode == NULL) return -ENOMEM; return 0; } -int device_add_devlink(struct udev_device *udev_device, const char *devlink) +int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink) { - if (util_name_list_add(udev_device->udev, &udev_device->link_list, devlink, NULL, 0) == NULL) + if (udev_list_entry_add(udev_device->udev, &udev_device->devlink_list, devlink, NULL, 1, 0) == NULL) return -ENOMEM; return 0; } -int device_add_property(struct udev_device *udev_device, const char *key, const char *value) +int udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value) { - if (util_name_list_add(udev_device->udev, &udev_device->env_list, key, value, 0) == NULL) + if (udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0) == NULL) return -ENOMEM; return 0; } -int device_add_property_from_string(struct udev_device *udev_device, const char *property) +int udev_device_add_property_from_string(struct udev_device *udev_device, const char *property) { char name[UTIL_PATH_SIZE]; char *val; @@ -647,19 +907,20 @@ int device_add_property_from_string(struct udev_device *udev_device, const char val = &val[1]; if (val[0] == '\0') val = NULL; - device_add_property(udev_device, name, val); + udev_device_add_property(udev_device, name, val); return 0; } -int device_set_action(struct udev_device *udev_device, const char *action) +int udev_device_set_action(struct udev_device *udev_device, const char *action) { + udev_device_add_property(udev_device, "ACTION", action); udev_device->action = strdup(action); if (udev_device->action == NULL) return -ENOMEM; return 0; } -int device_set_driver(struct udev_device *udev_device, const char *driver) +int udev_device_set_driver(struct udev_device *udev_device, const char *driver) { udev_device->driver = strdup(driver); if (udev_device->driver == NULL) @@ -667,14 +928,12 @@ int device_set_driver(struct udev_device *udev_device, const char *driver) return 0; } -const char *device_get_devpath_old(struct udev_device *udev_device) +const char *udev_device_get_devpath_old(struct udev_device *udev_device) { - if (udev_device == NULL) - return NULL; return udev_device->devpath_old; } -int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old) +int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old) { udev_device->devpath_old = strdup(devpath_old); if (udev_device->devpath_old == NULL) @@ -682,14 +941,12 @@ int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_ return 0; } -const char *device_get_physdevpath(struct udev_device *udev_device) +const char *udev_device_get_physdevpath(struct udev_device *udev_device) { - if (udev_device == NULL) - return NULL; return udev_device->physdevpath; } -int device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath) +int udev_device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath) { udev_device->physdevpath = strdup(physdevpath); if (udev_device->physdevpath == NULL) @@ -697,65 +954,75 @@ int device_set_physdevpath(struct udev_device *udev_device, const char *physdevp return 0; } -int device_get_timeout(struct udev_device *udev_device) +int udev_device_get_timeout(struct udev_device *udev_device) { - if (udev_device == NULL) - return -1; return udev_device->timeout; } -int device_set_timeout(struct udev_device *udev_device, int timeout) +int udev_device_set_timeout(struct udev_device *udev_device, int timeout) { udev_device->timeout = timeout; return 0; } +int udev_device_get_event_timeout(struct udev_device *udev_device) +{ + if (!udev_device->info_loaded) + device_load_info(udev_device); + return udev_device->event_timeout; +} -int device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum) +int udev_device_set_event_timeout(struct udev_device *udev_device, int event_timeout) +{ + udev_device->event_timeout = event_timeout; + return 0; +} + +int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum) { udev_device->seqnum = seqnum; return 0; } -int device_set_devnum(struct udev_device *udev_device, dev_t devnum) +int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum) { udev_device->devnum = devnum; return 0; } -int device_get_num_fake_partitions(struct udev_device *udev_device) +int udev_device_get_num_fake_partitions(struct udev_device *udev_device) { - if (udev_device == NULL) - return -1; + if (!udev_device->info_loaded) + device_load_info(udev_device); return udev_device->num_fake_partitions; } -int device_set_num_fake_partitions(struct udev_device *udev_device, int num) +int udev_device_set_num_fake_partitions(struct udev_device *udev_device, int num) { udev_device->num_fake_partitions = num; return 0; } -int device_get_devlink_priority(struct udev_device *udev_device) +int udev_device_get_devlink_priority(struct udev_device *udev_device) { - if (udev_device == NULL) - return -1; + if (!udev_device->info_loaded) + device_load_info(udev_device); return udev_device->devlink_priority; } -int device_set_devlink_priority(struct udev_device *udev_device, int prio) +int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio) { udev_device->devlink_priority = prio; return 0; } -int device_get_ignore_remove(struct udev_device *udev_device) +int udev_device_get_ignore_remove(struct udev_device *udev_device) { - if (udev_device == NULL) - return -1; + if (!udev_device->info_loaded) + device_load_info(udev_device); return udev_device->ignore_remove; } -int device_set_ignore_remove(struct udev_device *udev_device, int ignore) +int udev_device_set_ignore_remove(struct udev_device *udev_device, int ignore) { udev_device->ignore_remove = ignore; return 0;