X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=udev%2Fudevadm-trigger.c;h=e7940ef92d608a6274690e75f6d8cb1571645c69;hb=41b7a00922bdb1a501cbf2e39282fe64bb94cb6d;hp=322040582e75506c5e91a91f09b43e9d39ce56af;hpb=32bf83996b1f7d7df83f99e6bf063685146ffe06;p=elogind.git diff --git a/udev/udevadm-trigger.c b/udev/udevadm-trigger.c index 322040582..e7940ef92 100644 --- a/udev/udevadm-trigger.c +++ b/udev/udevadm-trigger.c @@ -1,20 +1,19 @@ /* - * Copyright (C) 2004-2006 Kay Sievers + * Copyright (C) 2004-2008 Kay Sievers * Copyright (C) 2006 Hannes Reinecke * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the - * Free Software Foundation version 2 of the License. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ #include @@ -34,7 +33,6 @@ #include #include "udev.h" -#include "udevd.h" #include "udev_rules.h" static int verbose; @@ -49,7 +47,7 @@ static struct sockaddr_un saddr; static socklen_t saddrlen; /* devices that should run last cause of their dependencies */ -static int delay_device(const char *devpath) +static int delay_device(const char *syspath) { static const char *delay_device_list[] = { "*/md*", @@ -59,87 +57,85 @@ static int delay_device(const char *devpath) int i; for (i = 0; delay_device_list[i] != NULL; i++) - if (fnmatch(delay_device_list[i], devpath, 0) == 0) + if (fnmatch(delay_device_list[i], syspath, 0) == 0) return 1; return 0; } -static int device_list_insert(const char *path) +static int device_list_insert(struct udev *udev, const char *path) { - char filename[PATH_SIZE]; - char devpath[PATH_SIZE]; + char filename[UTIL_PATH_SIZE]; struct stat statbuf; - dbg("add '%s'\n" , path); + dbg(udev, "add '%s'\n" , path); /* we only have a device, if we have an uevent file */ - strlcpy(filename, path, sizeof(filename)); - strlcat(filename, "/uevent", sizeof(filename)); + util_strlcpy(filename, path, sizeof(filename)); + util_strlcat(filename, "/uevent", sizeof(filename)); if (stat(filename, &statbuf) < 0) return -1; if (!(statbuf.st_mode & S_IWUSR)) return -1; - strlcpy(devpath, &path[strlen(sysfs_path)], sizeof(devpath)); - /* resolve possible link to real target */ - if (lstat(path, &statbuf) < 0) + util_strlcpy(filename, path, sizeof(filename)); + if (lstat(filename, &statbuf) < 0) return -1; if (S_ISLNK(statbuf.st_mode)) - if (sysfs_resolve_link(devpath, sizeof(devpath)) != 0) + if (util_resolve_sys_link(udev, filename, sizeof(filename)) != 0) return -1; - name_list_add(&device_list, devpath, 1); + name_list_add(udev, &device_list, filename, 1); return 0; } -static void trigger_uevent(const char *devpath, const char *action) +static void trigger_uevent(struct udev *udev, const char *syspath, const char *action) { - char filename[PATH_SIZE]; + char filename[UTIL_PATH_SIZE]; int fd; - strlcpy(filename, sysfs_path, sizeof(filename)); - strlcat(filename, devpath, sizeof(filename)); - strlcat(filename, "/uevent", sizeof(filename)); + util_strlcpy(filename, syspath, sizeof(filename)); + util_strlcat(filename, "/uevent", sizeof(filename)); if (verbose) - printf("%s\n", devpath); + printf("%s\n", syspath); if (dry_run) return; fd = open(filename, O_WRONLY); if (fd < 0) { - dbg("error on opening %s: %s\n", filename, strerror(errno)); + dbg(udev, "error on opening %s: %s\n", filename, strerror(errno)); return; } if (write(fd, action, strlen(action)) < 0) - info("error writing '%s' to '%s': %s\n", action, filename, strerror(errno)); + info(udev, "error writing '%s' to '%s': %s\n", action, filename, strerror(errno)); close(fd); } -static int pass_to_socket(const char *devpath, const char *action, const char *env) +static int pass_to_socket(struct udev *udev, const char *syspath, const char *action, const char *env) { - struct udevice *udev; + struct udevice *udevice; struct name_entry *name_loop; char buf[4096]; size_t bufpos = 0; ssize_t count; - char path[PATH_SIZE]; + char path[UTIL_PATH_SIZE]; int fd; - char link_target[PATH_SIZE]; + char link_target[UTIL_PATH_SIZE]; int len; + const char *devpath = &syspath[strlen(udev_get_sys_path(udev))]; int err = 0; if (verbose) printf("%s\n", devpath); - udev = udev_device_init(); - if (udev == NULL) + udevice = udev_device_init(udev); + if (udevice == NULL) return -1; - udev_db_get_device(udev, devpath); + udev_db_get_device(udevice, devpath); /* add header */ bufpos = snprintf(buf, sizeof(buf)-1, "%s@%s", action, devpath); @@ -158,9 +154,9 @@ static int pass_to_socket(const char *devpath, const char *action, const char *e bufpos++; /* add subsystem */ - strlcpy(path, sysfs_path, sizeof(path)); - strlcat(path, devpath, sizeof(path)); - strlcat(path, "/subsystem", sizeof(path)); + util_strlcpy(path, udev_get_sys_path(udev), sizeof(path)); + util_strlcat(path, devpath, sizeof(path)); + util_strlcat(path, "/subsystem", sizeof(path)); len = readlink(path, link_target, sizeof(link_target)); if (len > 0) { char *pos; @@ -175,29 +171,28 @@ static int pass_to_socket(const char *devpath, const char *action, const char *e /* add symlinks and node name */ path[0] = '\0'; - list_for_each_entry(name_loop, &udev->symlink_list, node) { - strlcat(path, udev_root, sizeof(path)); - strlcat(path, "/", sizeof(path)); - strlcat(path, name_loop->name, sizeof(path)); - strlcat(path, " ", sizeof(path)); + list_for_each_entry(name_loop, &udevice->symlink_list, node) { + util_strlcat(path, udev_get_dev_path(udev), sizeof(path)); + util_strlcat(path, "/", sizeof(path)); + util_strlcat(path, name_loop->name, sizeof(path)); + util_strlcat(path, " ", sizeof(path)); } - remove_trailing_chars(path, ' '); + util_remove_trailing_chars(path, ' '); if (path[0] != '\0') { bufpos += snprintf(&buf[bufpos], sizeof(buf)-1, "DEVLINKS=%s", path); bufpos++; } - if (udev->name[0] != '\0') { - strlcpy(path, udev_root, sizeof(path)); - strlcat(path, "/", sizeof(path)); - strlcat(path, udev->name, sizeof(path)); + if (udevice->name[0] != '\0') { + util_strlcpy(path, udev_get_dev_path(udev), sizeof(path)); + util_strlcat(path, "/", sizeof(path)); + util_strlcat(path, udevice->name, sizeof(path)); bufpos += snprintf(&buf[bufpos], sizeof(buf)-1, "DEVNAME=%s", path); bufpos++; } /* add keys from device "uevent" file */ - strlcpy(path, sysfs_path, sizeof(path)); - strlcat(path, devpath, sizeof(path)); - strlcat(path, "/uevent", sizeof(path)); + util_strlcpy(path, syspath, sizeof(path)); + util_strlcat(path, "/uevent", sizeof(path)); fd = open(path, O_RDONLY); if (fd >= 0) { char value[4096]; @@ -216,7 +211,7 @@ static int pass_to_socket(const char *devpath, const char *action, const char *e if (next == NULL) break; next[0] = '\0'; - bufpos += strlcpy(&buf[bufpos], key, sizeof(buf) - bufpos-1); + bufpos += util_strlcpy(&buf[bufpos], key, sizeof(buf) - bufpos-1); bufpos++; key = &next[1]; } @@ -224,8 +219,8 @@ static int pass_to_socket(const char *devpath, const char *action, const char *e } /* add keys from database */ - list_for_each_entry(name_loop, &udev->env_list, node) { - bufpos += strlcpy(&buf[bufpos], name_loop->name, sizeof(buf) - bufpos-1); + list_for_each_entry(name_loop, &udevice->env_list, node) { + bufpos += util_strlcpy(&buf[bufpos], name_loop->name, sizeof(buf) - bufpos-1); bufpos++; } if (bufpos > sizeof(buf)) @@ -238,7 +233,7 @@ static int pass_to_socket(const char *devpath, const char *action, const char *e return err; } -static void exec_list(const char *action, const char *env) +static void exec_list(struct udev *udev, const char *action, const char *env) { struct name_entry *loop_device; struct name_entry *tmp_device; @@ -247,9 +242,9 @@ static void exec_list(const char *action, const char *env) if (delay_device(loop_device->name)) continue; if (sock >= 0) - pass_to_socket(loop_device->name, action, env); + pass_to_socket(udev, loop_device->name, action, env); else - trigger_uevent(loop_device->name, action); + trigger_uevent(udev, loop_device->name, action); list_del(&loop_device->node); free(loop_device); } @@ -257,9 +252,9 @@ static void exec_list(const char *action, const char *env) /* trigger remaining delayed devices */ list_for_each_entry_safe(loop_device, tmp_device, &device_list, node) { if (sock >= 0) - pass_to_socket(loop_device->name, action, env); + pass_to_socket(udev, loop_device->name, action, env); else - trigger_uevent(loop_device->name, action); + trigger_uevent(udev, loop_device->name, action); list_del(&loop_device->node); free(loop_device); } @@ -287,11 +282,11 @@ static int subsystem_filtered(const char *subsystem) static int attr_match(const char *path, const char *attr_value) { - char attr[NAME_SIZE]; - char file[PATH_SIZE]; + char attr[UTIL_NAME_SIZE]; + char file[UTIL_PATH_SIZE]; char *match_value; - strlcpy(attr, attr_value, sizeof(attr)); + util_strlcpy(attr, attr_value, sizeof(attr)); /* separate attr and match value */ match_value = strchr(attr, '='); @@ -300,13 +295,13 @@ static int attr_match(const char *path, const char *attr_value) match_value = &match_value[1]; } - strlcpy(file, path, sizeof(file)); - strlcat(file, "/", sizeof(file)); - strlcat(file, attr, sizeof(file)); + util_strlcpy(file, path, sizeof(file)); + util_strlcat(file, "/", sizeof(file)); + util_strlcat(file, attr, sizeof(file)); if (match_value != NULL) { /* match file content */ - char value[NAME_SIZE]; + char value[UTIL_NAME_SIZE]; int fd; ssize_t size; @@ -318,7 +313,7 @@ static int attr_match(const char *path, const char *attr_value) if (size < 0) return 0; value[size] = '\0'; - remove_trailing_chars(value, '\n'); + util_remove_trailing_chars(value, '\n'); /* match if attribute value matches */ if (fnmatch(match_value, value, 0) == 0) @@ -357,9 +352,9 @@ enum scan_type { SCAN_SUBSYSTEM, }; -static void scan_subsystem(const char *subsys, enum scan_type scan) +static void scan_subsystem(struct udev *udev, const char *subsys, enum scan_type scan) { - char base[PATH_SIZE]; + char base[UTIL_PATH_SIZE]; DIR *dir; struct dirent *dent; const char *subdir; @@ -371,14 +366,14 @@ static void scan_subsystem(const char *subsys, enum scan_type scan) else return; - strlcpy(base, sysfs_path, sizeof(base)); - strlcat(base, "/", sizeof(base)); - strlcat(base, subsys, sizeof(base)); + util_strlcpy(base, udev_get_sys_path(udev), sizeof(base)); + util_strlcat(base, "/", sizeof(base)); + util_strlcat(base, subsys, sizeof(base)); dir = opendir(base); if (dir != NULL) { for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) { - char dirname[PATH_SIZE]; + char dirname[UTIL_PATH_SIZE]; DIR *dir2; struct dirent *dent2; @@ -389,36 +384,36 @@ static void scan_subsystem(const char *subsys, enum scan_type scan) if (subsystem_filtered(dent->d_name)) continue; - strlcpy(dirname, base, sizeof(dirname)); - strlcat(dirname, "/", sizeof(dirname)); - strlcat(dirname, dent->d_name, sizeof(dirname)); + util_strlcpy(dirname, base, sizeof(dirname)); + util_strlcat(dirname, "/", sizeof(dirname)); + util_strlcat(dirname, dent->d_name, sizeof(dirname)); if (scan == SCAN_SUBSYSTEM) { if (attr_filtered(dirname)) continue; if (!subsystem_filtered("subsystem")) - device_list_insert(dirname); + device_list_insert(udev, dirname); if (subsystem_filtered("drivers")) continue; } - strlcat(dirname, subdir, sizeof(dirname)); + util_strlcat(dirname, subdir, sizeof(dirname)); /* look for devices/drivers */ dir2 = opendir(dirname); if (dir2 != NULL) { for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) { - char dirname2[PATH_SIZE]; + char dirname2[UTIL_PATH_SIZE]; if (dent2->d_name[0] == '.') continue; - strlcpy(dirname2, dirname, sizeof(dirname2)); - strlcat(dirname2, "/", sizeof(dirname2)); - strlcat(dirname2, dent2->d_name, sizeof(dirname2)); + util_strlcpy(dirname2, dirname, sizeof(dirname2)); + util_strlcat(dirname2, "/", sizeof(dirname2)); + util_strlcat(dirname2, dent2->d_name, sizeof(dirname2)); if (attr_filtered(dirname2)) continue; - device_list_insert(dirname2); + device_list_insert(udev, dirname2); } closedir(dir2); } @@ -427,41 +422,41 @@ static void scan_subsystem(const char *subsys, enum scan_type scan) } } -static void scan_block(void) +static void scan_block(struct udev *udev) { - char base[PATH_SIZE]; + char base[UTIL_PATH_SIZE]; DIR *dir; struct dirent *dent; if (subsystem_filtered("block")) return; - strlcpy(base, sysfs_path, sizeof(base)); - strlcat(base, "/block", sizeof(base)); + util_strlcpy(base, udev_get_sys_path(udev), sizeof(base)); + util_strlcat(base, "/block", sizeof(base)); dir = opendir(base); if (dir != NULL) { for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) { - char dirname[PATH_SIZE]; + char dirname[UTIL_PATH_SIZE]; DIR *dir2; struct dirent *dent2; if (dent->d_name[0] == '.') continue; - strlcpy(dirname, base, sizeof(dirname)); - strlcat(dirname, "/", sizeof(dirname)); - strlcat(dirname, dent->d_name, sizeof(dirname)); + util_strlcpy(dirname, base, sizeof(dirname)); + util_strlcat(dirname, "/", sizeof(dirname)); + util_strlcat(dirname, dent->d_name, sizeof(dirname)); if (attr_filtered(dirname)) continue; - if (device_list_insert(dirname) != 0) + if (device_list_insert(udev, dirname) != 0) continue; /* look for partitions */ dir2 = opendir(dirname); if (dir2 != NULL) { for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) { - char dirname2[PATH_SIZE]; + char dirname2[UTIL_PATH_SIZE]; if (dent2->d_name[0] == '.') continue; @@ -469,12 +464,12 @@ static void scan_block(void) if (!strcmp(dent2->d_name,"device")) continue; - strlcpy(dirname2, dirname, sizeof(dirname2)); - strlcat(dirname2, "/", sizeof(dirname2)); - strlcat(dirname2, dent2->d_name, sizeof(dirname2)); + util_strlcpy(dirname2, dirname, sizeof(dirname2)); + util_strlcat(dirname2, "/", sizeof(dirname2)); + util_strlcat(dirname2, dent2->d_name, sizeof(dirname2)); if (attr_filtered(dirname2)) continue; - device_list_insert(dirname2); + device_list_insert(udev, dirname2); } closedir(dir2); } @@ -483,19 +478,19 @@ static void scan_block(void) } } -static void scan_class(void) +static void scan_class(struct udev *udev) { - char base[PATH_SIZE]; + char base[UTIL_PATH_SIZE]; DIR *dir; struct dirent *dent; - strlcpy(base, sysfs_path, sizeof(base)); - strlcat(base, "/class", sizeof(base)); + util_strlcpy(base, udev_get_sys_path(udev), sizeof(base)); + util_strlcat(base, "/class", sizeof(base)); dir = opendir(base); if (dir != NULL) { for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) { - char dirname[PATH_SIZE]; + char dirname[UTIL_PATH_SIZE]; DIR *dir2; struct dirent *dent2; @@ -505,13 +500,13 @@ static void scan_class(void) if (subsystem_filtered(dent->d_name)) continue; - strlcpy(dirname, base, sizeof(dirname)); - strlcat(dirname, "/", sizeof(dirname)); - strlcat(dirname, dent->d_name, sizeof(dirname)); + util_strlcpy(dirname, base, sizeof(dirname)); + util_strlcat(dirname, "/", sizeof(dirname)); + util_strlcat(dirname, dent->d_name, sizeof(dirname)); dir2 = opendir(dirname); if (dir2 != NULL) { for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) { - char dirname2[PATH_SIZE]; + char dirname2[UTIL_PATH_SIZE]; if (dent2->d_name[0] == '.') continue; @@ -519,12 +514,12 @@ static void scan_class(void) if (!strcmp(dent2->d_name, "device")) continue; - strlcpy(dirname2, dirname, sizeof(dirname2)); - strlcat(dirname2, "/", sizeof(dirname2)); - strlcat(dirname2, dent2->d_name, sizeof(dirname2)); + util_strlcpy(dirname2, dirname, sizeof(dirname2)); + util_strlcat(dirname2, "/", sizeof(dirname2)); + util_strlcat(dirname2, dent2->d_name, sizeof(dirname2)); if (attr_filtered(dirname2)) continue; - device_list_insert(dirname2); + device_list_insert(udev, dirname2); } closedir(dir2); } @@ -533,36 +528,36 @@ static void scan_class(void) } } -static void scan_failed(void) +static void scan_failed(struct udev *udev) { - char base[PATH_SIZE]; + char base[UTIL_PATH_SIZE]; DIR *dir; struct dirent *dent; - strlcpy(base, udev_root, sizeof(base)); - strlcat(base, "/.udev/failed", sizeof(base)); + util_strlcpy(base, udev_get_dev_path(udev), sizeof(base)); + util_strlcat(base, "/.udev/failed", sizeof(base)); dir = opendir(base); if (dir != NULL) { for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) { - char device[PATH_SIZE]; + char device[UTIL_PATH_SIZE]; size_t start; if (dent->d_name[0] == '.') continue; - start = strlcpy(device, sysfs_path, sizeof(device)); + start = util_strlcpy(device, udev_get_sys_path(udev), sizeof(device)); if(start >= sizeof(device)) start = sizeof(device) - 1; - strlcat(device, dent->d_name, sizeof(device)); - path_decode(&device[start]); - device_list_insert(device); + util_strlcat(device, dent->d_name, sizeof(device)); + util_path_decode(&device[start]); + device_list_insert(udev, device); } closedir(dir); } } -int udevadm_trigger(int argc, char *argv[]) +int udevadm_trigger(struct udev *udev, int argc, char *argv[]) { int failed = 0; const char *sockpath = NULL; @@ -584,10 +579,7 @@ int udevadm_trigger(int argc, char *argv[]) {} }; - logging_init("udevtrigger"); - udev_config_init(); - dbg("version %s\n", VERSION); - sysfs_init(); + dbg(udev, "version %s\n", VERSION); while (1) { option = getopt_long(argc, argv, "vnFo:hce::s:S:a:A:", options, NULL); @@ -615,16 +607,16 @@ int udevadm_trigger(int argc, char *argv[]) env = optarg; break; case 's': - name_list_add(&filter_subsystem_match_list, optarg, 0); + name_list_add(udev, &filter_subsystem_match_list, optarg, 0); break; case 'S': - name_list_add(&filter_subsystem_nomatch_list, optarg, 0); + name_list_add(udev, &filter_subsystem_nomatch_list, optarg, 0); break; case 'a': - name_list_add(&filter_attr_match_list, optarg, 0); + name_list_add(udev, &filter_attr_match_list, optarg, 0); break; case 'A': - name_list_add(&filter_attr_nomatch_list, optarg, 0); + name_list_add(udev, &filter_attr_nomatch_list, optarg, 0); break; case 'h': printf("Usage: udevadm trigger OPTIONS\n" @@ -656,15 +648,15 @@ int udevadm_trigger(int argc, char *argv[]) saddr.sun_family = AF_LOCAL; if (sockpath[0] == '@') { /* abstract namespace socket requested */ - strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1); + util_strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1); saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]); } else if (stat(sockpath, &stats) == 0 && S_ISSOCK(stats.st_mode)) { /* existing socket file */ - strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path)); + util_strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path)); saddrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path); } else { /* no socket file, assume abstract namespace socket */ - strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1); + util_strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1); saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]); } } else if (env != NULL) { @@ -673,44 +665,42 @@ int udevadm_trigger(int argc, char *argv[]) } if (failed) { - scan_failed(); - exec_list(action, env); + scan_failed(udev); + exec_list(udev, action, env); } else { - char base[PATH_SIZE]; + char base[UTIL_PATH_SIZE]; struct stat statbuf; /* if we have /sys/subsystem, forget all the old stuff */ - strlcpy(base, sysfs_path, sizeof(base)); - strlcat(base, "/subsystem", sizeof(base)); + util_strlcpy(base, udev_get_sys_path(udev), sizeof(base)); + util_strlcat(base, "/subsystem", sizeof(base)); if (stat(base, &statbuf) == 0) { - scan_subsystem("subsystem", SCAN_SUBSYSTEM); - exec_list(action, env); - scan_subsystem("subsystem", SCAN_DEVICES); - exec_list(action, env); + scan_subsystem(udev, "subsystem", SCAN_SUBSYSTEM); + exec_list(udev, action, env); + scan_subsystem(udev, "subsystem", SCAN_DEVICES); + exec_list(udev, action, env); } else { - scan_subsystem("bus", SCAN_SUBSYSTEM); - exec_list(action, env); - scan_subsystem("bus", SCAN_DEVICES); - scan_class(); + scan_subsystem(udev, "bus", SCAN_SUBSYSTEM); + exec_list(udev, action, env); + scan_subsystem(udev, "bus", SCAN_DEVICES); + scan_class(udev); /* scan "block" if it isn't a "class" */ - strlcpy(base, sysfs_path, sizeof(base)); - strlcat(base, "/class/block", sizeof(base)); + util_strlcpy(base, udev_get_sys_path(udev), sizeof(base)); + util_strlcat(base, "/class/block", sizeof(base)); if (stat(base, &statbuf) != 0) - scan_block(); - exec_list(action, env); + scan_block(udev); + exec_list(udev, action, env); } } exit: - name_list_cleanup(&filter_subsystem_match_list); - name_list_cleanup(&filter_subsystem_nomatch_list); - name_list_cleanup(&filter_attr_match_list); - name_list_cleanup(&filter_attr_nomatch_list); + name_list_cleanup(udev, &filter_subsystem_match_list); + name_list_cleanup(udev, &filter_subsystem_nomatch_list); + name_list_cleanup(udev, &filter_attr_match_list); + name_list_cleanup(udev, &filter_attr_nomatch_list); if (sock >= 0) close(sock); - sysfs_cleanup(); - logging_close(); return 0; }