/* SPDX-License-Identifier: GPL-2.0+ */ /* * */ #include #include #include #include #include #include #include #include "fd-util.h" #include "set.h" #include "string-util.h" #include "udev-util.h" #include "udev.h" #include "udevadm-util.h" #include "util.h" static int verbose; static int dry_run; static int exec_list(struct udev_enumerate *udev_enumerate, const char *action, Set *settle_set) { struct udev_list_entry *entry; int r; udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(udev_enumerate)) { char filename[UTIL_PATH_SIZE]; const char *syspath; _cleanup_close_ int fd = -1; syspath = udev_list_entry_get_name(entry); if (verbose) printf("%s\n", syspath); if (dry_run) continue; strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL); fd = open(filename, O_WRONLY|O_CLOEXEC); if (fd < 0) continue; if (settle_set) { r = set_put_strdup(settle_set, syspath); if (r < 0) return log_oom(); } if (write(fd, action, strlen(action)) < 0) log_debug_errno(errno, "error writing '%s' to '%s': %m", action, filename); } return 0; } static const char *keyval(const char *str, const char **val, char *buf, size_t size) { char *pos; strscpy(buf, size,str); pos = strchr(buf, '='); if (pos != NULL) { pos[0] = 0; pos++; } *val = pos; return buf; } static void help(void) { printf("%s trigger [OPTIONS] DEVPATH\n\n" "Request events from the kernel.\n\n" " -h --help Show this help\n" " -V --version Show package version\n" " -v --verbose Print the list of devices while running\n" " -n --dry-run Do not actually trigger the events\n" " -t --type= Type of events to trigger\n" " devices sysfs devices (default)\n" " subsystems sysfs subsystems and drivers\n" " -c --action=ACTION Event action value, default is \"change\"\n" " -s --subsystem-match=SUBSYSTEM Trigger devices from a matching subsystem\n" " -S --subsystem-nomatch=SUBSYSTEM Exclude devices from a matching subsystem\n" " -a --attr-match=FILE[=VALUE] Trigger devices with a matching attribute\n" " -A --attr-nomatch=FILE[=VALUE] Exclude devices with a matching attribute\n" " -p --property-match=KEY=VALUE Trigger devices with a matching property\n" " -g --tag-match=KEY=VALUE Trigger devices with a matching property\n" " -y --sysname-match=NAME Trigger devices with this /sys path\n" " --name-match=NAME Trigger devices with this /dev name\n" " -b --parent-match=NAME Trigger devices with that parent device\n" " -w --settle Wait for the triggered events to complete\n" , program_invocation_short_name); } static int adm_trigger(struct udev *udev, int argc, char *argv[]) { enum { ARG_NAME = 0x100, }; static const struct option options[] = { { "verbose", no_argument, NULL, 'v' }, { "dry-run", no_argument, NULL, 'n' }, { "type", required_argument, NULL, 't' }, { "action", required_argument, NULL, 'c' }, { "subsystem-match", required_argument, NULL, 's' }, { "subsystem-nomatch", required_argument, NULL, 'S' }, { "attr-match", required_argument, NULL, 'a' }, { "attr-nomatch", required_argument, NULL, 'A' }, { "property-match", required_argument, NULL, 'p' }, { "tag-match", required_argument, NULL, 'g' }, { "sysname-match", required_argument, NULL, 'y' }, { "name-match", required_argument, NULL, ARG_NAME }, { "parent-match", required_argument, NULL, 'b' }, { "settle", no_argument, NULL, 'w' }, { "version", no_argument, NULL, 'V' }, { "help", no_argument, NULL, 'h' }, {} }; enum { TYPE_DEVICES, TYPE_SUBSYSTEMS, } device_type = TYPE_DEVICES; const char *action = "change"; _cleanup_(udev_enumerate_unrefp) struct udev_enumerate *udev_enumerate = NULL; _cleanup_(udev_monitor_unrefp) struct udev_monitor *udev_monitor = NULL; _cleanup_close_ int fd_ep = -1; int fd_udev = -1; struct epoll_event ep_udev; bool settle = false; _cleanup_set_free_free_ Set *settle_set = NULL; int c, r; udev_enumerate = udev_enumerate_new(udev); if (!udev_enumerate) return 1; while ((c = getopt_long(argc, argv, "vnt:c:s:S:a:A:p:g:y:b:wVh", options, NULL)) >= 0) { const char *key; const char *val; char buf[UTIL_PATH_SIZE]; switch (c) { case 'v': verbose = 1; break; case 'n': dry_run = 1; break; case 't': if (streq(optarg, "devices")) device_type = TYPE_DEVICES; else if (streq(optarg, "subsystems")) device_type = TYPE_SUBSYSTEMS; else { log_error("unknown type --type=%s", optarg); return 2; } break; case 'c': if (!STR_IN_SET(optarg, "add", "remove", "change")) { log_error("unknown action '%s'", optarg); return 2; } else action = optarg; break; case 's': r = udev_enumerate_add_match_subsystem(udev_enumerate, optarg); if (r < 0) { log_error_errno(r, "could not add subsystem match '%s': %m", optarg); return 2; } break; case 'S': r = udev_enumerate_add_nomatch_subsystem(udev_enumerate, optarg); if (r < 0) { log_error_errno(r, "could not add negative subsystem match '%s': %m", optarg); return 2; } break; case 'a': key = keyval(optarg, &val, buf, sizeof(buf)); r = udev_enumerate_add_match_sysattr(udev_enumerate, key, val); if (r < 0) { log_error_errno(r, "could not add sysattr match '%s=%s': %m", key, val); return 2; } break; case 'A': key = keyval(optarg, &val, buf, sizeof(buf)); r = udev_enumerate_add_nomatch_sysattr(udev_enumerate, key, val); if (r < 0) { log_error_errno(r, "could not add negative sysattr match '%s=%s': %m", key, val); return 2; } break; case 'p': key = keyval(optarg, &val, buf, sizeof(buf)); r = udev_enumerate_add_match_property(udev_enumerate, key, val); if (r < 0) { log_error_errno(r, "could not add property match '%s=%s': %m", key, val); return 2; } break; case 'g': r = udev_enumerate_add_match_tag(udev_enumerate, optarg); if (r < 0) { log_error_errno(r, "could not add tag match '%s': %m", optarg); return 2; } break; case 'y': r = udev_enumerate_add_match_sysname(udev_enumerate, optarg); if (r < 0) { log_error_errno(r, "could not add sysname match '%s': %m", optarg); return 2; } break; case 'b': { _cleanup_(udev_device_unrefp) struct udev_device *dev; dev = find_device(udev, optarg, "/sys"); if (!dev) { log_error("unable to open the device '%s'", optarg); return 2; } r = udev_enumerate_add_match_parent(udev_enumerate, dev); if (r < 0) { log_error_errno(r, "could not add parent match '%s': %m", optarg); return 2; } break; } case 'w': settle = true; break; case ARG_NAME: { _cleanup_(udev_device_unrefp) struct udev_device *dev; dev = find_device(udev, optarg, "/dev/"); if (!dev) { log_error("unable to open the device '%s'", optarg); return 2; } r = udev_enumerate_add_match_parent(udev_enumerate, dev); if (r < 0) { log_error_errno(r, "could not add parent match '%s': %m", optarg); return 2; } break; } case 'V': print_version(); return 0; case 'h': help(); return 0; case '?': return 1; default: assert_not_reached("Unknown option"); } } for (; optind < argc; optind++) { _cleanup_(udev_device_unrefp) struct udev_device *dev; dev = find_device(udev, argv[optind], NULL); if (!dev) { log_error("unable to open the device '%s'", argv[optind]); return 2; } r = udev_enumerate_add_match_parent(udev_enumerate, dev); if (r < 0) { log_error_errno(r, "could not add tag match '%s': %m", optarg); return 2; } } if (settle) { fd_ep = epoll_create1(EPOLL_CLOEXEC); if (fd_ep < 0) { log_error_errno(errno, "error creating epoll fd: %m"); return 1; } udev_monitor = udev_monitor_new_from_netlink(udev, "udev"); if (!udev_monitor) { log_error("error: unable to create netlink socket"); return 3; } fd_udev = udev_monitor_get_fd(udev_monitor); if (udev_monitor_enable_receiving(udev_monitor) < 0) { log_error("error: unable to subscribe to udev events"); return 4; } ep_udev = (struct epoll_event) { .events = EPOLLIN, .data.fd = fd_udev }; if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) { log_error_errno(errno, "fail to add fd to epoll: %m"); return 5; } settle_set = set_new(&string_hash_ops); if (!settle_set) { log_oom(); return 1; } } switch (device_type) { case TYPE_SUBSYSTEMS: udev_enumerate_scan_subsystems(udev_enumerate); break; case TYPE_DEVICES: udev_enumerate_scan_devices(udev_enumerate); break; default: assert_not_reached("device_type"); } r = exec_list(udev_enumerate, action, settle_set); if (r < 0) return 1; while (!set_isempty(settle_set)) { int fdcount; struct epoll_event ev[4]; int i; fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1); if (fdcount < 0) { if (errno != EINTR) log_error_errno(errno, "error receiving uevent message: %m"); continue; } for (i = 0; i < fdcount; i++) { if (ev[i].data.fd == fd_udev && ev[i].events & EPOLLIN) { _cleanup_(udev_device_unrefp) struct udev_device *device; const char *syspath = NULL; device = udev_monitor_receive_device(udev_monitor); if (!device) continue; syspath = udev_device_get_syspath(device); if (verbose) printf("settle %s\n", syspath); if (!set_remove(settle_set, syspath)) log_debug("Got epoll event on syspath %s not present in syspath set", syspath); } } } return 0; } const struct udevadm_cmd udevadm_trigger = { .name = "trigger", .cmd = adm_trigger, .help = "Request events from the kernel", };