SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
bdb577f545cc20fd74fd12e5c2e93c5bb87c65e5
systemd/src/udev/udevadm-trigger.c
T
Lennart Poettering dc53421de5 udevadm: improve debug logging when triggering/watching events 
Let's make debugging udev triggering a bit easier, by generating debug
log messages whenever we trigger a device, and also when we see the
event in pid1.
2023-05-23 09:53:37 -07:00

569 lines
25 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0-or-later */
#include <errno.h>
#include <getopt.h>
#include "sd-device.h"
#include "sd-event.h"
#include "device-enumerator-private.h"
#include "device-private.h"
#include "device-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "id128-util.h"
#include "parse-util.h"
#include "path-util.h"
#include "process-util.h"
#include "set.h"
#include "static-destruct.h"
#include "string-util.h"
#include "strv.h"
#include "udevadm.h"
#include "udevadm-util.h"
#include "udev-ctrl.h"
#include "virt.h"
static bool arg_verbose = false;
static bool arg_dry_run = false;
static bool arg_quiet = false;
static bool arg_uuid = false;
static bool arg_settle = false;
static int exec_list(
sd_device_enumerator *e,
sd_device_action_t action,
Set **ret_settle_path_or_ids) {
_cleanup_set_free_ Set *settle_path_or_ids = NULL;
int uuid_supported = -1;
const char *action_str;
sd_device *d;
int r, ret = 0;
assert(e);
action_str = device_action_to_string(action);
FOREACH_DEVICE_AND_SUBSYSTEM(e, d) {
sd_id128_t id = SD_ID128_NULL;
const char *syspath;
r = sd_device_get_syspath(d, &syspath);
if (r < 0) {
log_debug_errno(r, "Failed to get syspath of enumerated devices, ignoring: %m");
continue;
}
if (arg_verbose)
printf("%s\n", syspath);
if (arg_dry_run)
continue;
/* Use the UUID mode if the user explicitly asked for it, or if --settle has been specified,
* so that we can recognize our own uevent. */
r = sd_device_trigger_with_uuid(d, action, (arg_uuid || arg_settle) && uuid_supported != 0 ? &id : NULL);
if (r == -EINVAL && !arg_uuid && arg_settle && uuid_supported < 0) {
/* If we specified a UUID because of the settling logic, and we got EINVAL this might
* be caused by an old kernel which doesn't know the UUID logic (pre-4.13). Let's try
* if it works without the UUID logic then. */
r = sd_device_trigger(d, action);
if (r != -EINVAL)
uuid_supported = false; /* dropping the uuid stuff changed the return code,
* hence don't bother next time */
}
if (r < 0) {
/* ENOENT may be returned when a device does not have /uevent or is already
* removed. Hence, this is logged at debug level and ignored.
*
* ENODEV may be returned by some buggy device drivers e.g. /sys/devices/vio.
* See,
* https://github.com/systemd/systemd/issues/13652#issuecomment-535129791 and
* https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1845319.
* So, this error is ignored, but logged at warning level to encourage people to
* fix the driver.
*
* EROFS is returned when /sys is read only. In that case, all subsequent
* writes will also fail, hence return immediately.
*
* EACCES or EPERM may be returned when this is invoked by non-priviledged user.
* We do NOT return immediately, but continue operation and propagate the error.
* Why? Some device can be owned by a user, e.g., network devices configured in
* a network namespace. See, https://github.com/systemd/systemd/pull/18559 and
* https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ebb4a4bf76f164457184a3f43ebc1552416bc823
*
* All other errors are logged at error level, but let's continue the operation,
* and propagate the error.
*/
bool ignore = IN_SET(r, -ENOENT, -ENODEV);
int level =
arg_quiet ? LOG_DEBUG :
r == -ENOENT ? LOG_DEBUG :
r == -ENODEV ? LOG_WARNING : LOG_ERR;
log_device_full_errno(d, level, r,
"Failed to write '%s' to '%s/uevent'%s: %m",
action_str, syspath, ignore ? ", ignoring" : "");
if (r == -EROFS)
return r;
if (ret == 0 && !ignore)
ret = r;
continue;
} else
log_device_debug(d, "Triggered device with action '%s'.", action_str);
if (uuid_supported < 0)
uuid_supported = true;
/* If the user asked for it, write event UUID to stdout */
if (arg_uuid)
printf(SD_ID128_UUID_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(id));
if (arg_settle) {
if (uuid_supported) {
sd_id128_t *dup;
dup = newdup(sd_id128_t, &id, 1);
if (!dup)
return log_oom();
r = set_ensure_consume(&settle_path_or_ids, &id128_hash_ops_free, dup);
} else {
char *dup;
dup = strdup(syspath);
if (!dup)
return log_oom();
r = set_ensure_consume(&settle_path_or_ids, &path_hash_ops_free, dup);
}
if (r < 0)
return log_oom();
}
}
if (ret_settle_path_or_ids)
*ret_settle_path_or_ids = TAKE_PTR(settle_path_or_ids);
return ret;
}
static int device_monitor_handler(sd_device_monitor *m, sd_device *dev, void *userdata) {
Set *settle_path_or_ids = * (Set**) ASSERT_PTR(userdata);
const char *syspath;
sd_id128_t id;
int r;
assert(dev);
r = sd_device_get_syspath(dev, &syspath);
if (r < 0) {
log_device_debug_errno(dev, r, "Failed to get syspath of device event, ignoring: %m");
return 0;
}
if (sd_device_get_trigger_uuid(dev, &id) >= 0) {
_cleanup_free_ sd_id128_t *saved = NULL;
saved = set_remove(settle_path_or_ids, &id);
if (!saved) {
log_device_debug(dev, "Got uevent not matching expected UUID, ignoring.");
return 0;
}
} else {
_cleanup_free_ char *saved = NULL;
saved = set_remove(settle_path_or_ids, syspath);
if (!saved) {
const char *old_sysname;
/* When the device is renamed, the new name is broadcast, and the old name is saved
* in INTERFACE_OLD.
*
* TODO: remove support for INTERFACE_OLD when kernel baseline is bumped to 4.13 or
* higher. See 1193448cb68e5a90cab027e16a093bbd367e9494.
*/
if (sd_device_get_property_value(dev, "INTERFACE_OLD", &old_sysname) >= 0) {
_cleanup_free_ char *dir = NULL, *old_syspath = NULL;
r = path_extract_directory(syspath, &dir);
if (r < 0) {
log_device_debug_errno(dev, r,
"Failed to extract directory from '%s', ignoring: %m",
syspath);
return 0;
}
old_syspath = path_join(dir, old_sysname);
if (!old_syspath) {
log_oom_debug();
return 0;
}
saved = set_remove(settle_path_or_ids, old_syspath);
}
}
if (!saved) {
log_device_debug(dev, "Got uevent for unexpected device, ignoring.");
return 0;
}
}
if (arg_verbose)
printf("settle %s\n", syspath);
if (arg_uuid)
printf("settle " SD_ID128_UUID_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(id));
if (set_isempty(settle_path_or_ids))
return sd_event_exit(sd_device_monitor_get_event(m), 0);
return 0;
}
static char* keyval(const char *str, const char **key, const char **val) {
char *buf, *pos;
buf = strdup(str);
if (!buf)
return NULL;
pos = strchr(buf, '=');
if (pos) {
pos[0] = 0;
pos++;
}
*key = buf;
*val = pos;
return buf;
}
static int 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"
" -q --quiet Suppress error logging in triggering events\n"
" -t --type= Type of events to trigger\n"
" devices sysfs devices (default)\n"
" subsystems sysfs subsystems and drivers\n"
" -c --action=ACTION|help 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=TAG Trigger devices with a matching tag\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"
" --initialized-match Trigger devices that are already initialized\n"
" --initialized-nomatch Trigger devices that are not initialized yet\n"
" -w --settle Wait for the triggered events to complete\n"
" --wait-daemon[=SECONDS] Wait for udevd daemon to be initialized\n"
" before triggering uevents\n"
" --uuid Print synthetic uevent UUID\n"
" --prioritized-subsystem=SUBSYSTEM[,SUBSYSTEM…]\n"
" Trigger devices from a matching subsystem first\n",
program_invocation_short_name);
return 0;
}
int trigger_main(int argc, char *argv[], void *userdata) {
enum {
ARG_NAME = 0x100,
ARG_PING,
ARG_UUID,
ARG_PRIORITIZED_SUBSYSTEM,
ARG_INITIALIZED_MATCH,
ARG_INITIALIZED_NOMATCH,
};
static const struct option options[] = {
{ "verbose", no_argument, NULL, 'v' },
{ "dry-run", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "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' },
{ "initialized-match", no_argument, NULL, ARG_INITIALIZED_MATCH },
{ "initialized-nomatch", no_argument, NULL, ARG_INITIALIZED_NOMATCH },
{ "settle", no_argument, NULL, 'w' },
{ "wait-daemon", optional_argument, NULL, ARG_PING },
{ "version", no_argument, NULL, 'V' },
{ "help", no_argument, NULL, 'h' },
{ "uuid", no_argument, NULL, ARG_UUID },
{ "prioritized-subsystem", required_argument, NULL, ARG_PRIORITIZED_SUBSYSTEM },
{}
};
enum {
TYPE_DEVICES,
TYPE_SUBSYSTEMS,
TYPE_ALL,
} device_type = TYPE_DEVICES;
sd_device_action_t action = SD_DEVICE_CHANGE;
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *m = NULL;
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
_cleanup_set_free_ Set *settle_path_or_ids = NULL;
usec_t ping_timeout_usec = 5 * USEC_PER_SEC;
bool ping = false;
int c, r;
if (running_in_chroot() > 0) {
log_info("Running in chroot, ignoring request.");
return 0;
}
r = sd_device_enumerator_new(&e);
if (r < 0)
return r;
r = sd_device_enumerator_allow_uninitialized(e);
if (r < 0)
return r;
while ((c = getopt_long(argc, argv, "vnqt:c:s:S:a:A:p:g:y:b:wVh", options, NULL)) >= 0) {
_cleanup_free_ char *buf = NULL;
const char *key, *val;
switch (c) {
case 'v':
arg_verbose = true;
break;
case 'n':
arg_dry_run = true;
break;
case 'q':
arg_quiet = true;
break;
case 't':
if (streq(optarg, "devices"))
device_type = TYPE_DEVICES;
else if (streq(optarg, "subsystems"))
device_type = TYPE_SUBSYSTEMS;
else if (streq(optarg, "all"))
device_type = TYPE_ALL;
else
return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown type --type=%s", optarg);
break;
case 'c':
r = parse_device_action(optarg, &action);
if (r < 0)
return log_error_errno(r, "Unknown action '%s'", optarg);
if (r == 0)
return 0;
break;
case 's':
r = sd_device_enumerator_add_match_subsystem(e, optarg, true);
if (r < 0)
return log_error_errno(r, "Failed to add subsystem match '%s': %m", optarg);
break;
case 'S':
r = sd_device_enumerator_add_match_subsystem(e, optarg, false);
if (r < 0)
return log_error_errno(r, "Failed to add negative subsystem match '%s': %m", optarg);
break;
case 'a':
buf = keyval(optarg, &key, &val);
if (!buf)
return log_oom();
r = sd_device_enumerator_add_match_sysattr(e, key, val, true);
if (r < 0)
return log_error_errno(r, "Failed to add sysattr match '%s=%s': %m", key, val);
break;
case 'A':
buf = keyval(optarg, &key, &val);
if (!buf)
return log_oom();
r = sd_device_enumerator_add_match_sysattr(e, key, val, false);
if (r < 0)
return log_error_errno(r, "Failed to add negative sysattr match '%s=%s': %m", key, val);
break;
case 'p':
buf = keyval(optarg, &key, &val);
if (!buf)
return log_oom();
r = sd_device_enumerator_add_match_property(e, key, val);
if (r < 0)
return log_error_errno(r, "Failed to add property match '%s=%s': %m", key, val);
break;
case 'g':
r = sd_device_enumerator_add_match_tag(e, optarg);
if (r < 0)
return log_error_errno(r, "Failed to add tag match '%s': %m", optarg);
break;
case 'y':
r = sd_device_enumerator_add_match_sysname(e, optarg);
if (r < 0)
return log_error_errno(r, "Failed to add sysname match '%s': %m", optarg);
break;
case 'b': {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
r = find_device(optarg, "/sys", &dev);
if (r < 0)
return log_error_errno(r, "Failed to open the device '%s': %m", optarg);
r = device_enumerator_add_match_parent_incremental(e, dev);
if (r < 0)
return log_error_errno(r, "Failed to add parent match '%s': %m", optarg);
break;
}
case 'w':
arg_settle = true;
break;
case ARG_NAME: {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
r = find_device(optarg, "/dev", &dev);
if (r < 0)
return log_error_errno(r, "Failed to open the device '%s': %m", optarg);
r = device_enumerator_add_match_parent_incremental(e, dev);
if (r < 0)
return log_error_errno(r, "Failed to add parent match '%s': %m", optarg);
break;
}
case ARG_PING:
ping = true;
if (optarg) {
r = parse_sec(optarg, &ping_timeout_usec);
if (r < 0)
log_error_errno(r, "Failed to parse timeout value '%s', ignoring: %m", optarg);
}
break;
case ARG_UUID:
arg_uuid = true;
break;
case ARG_PRIORITIZED_SUBSYSTEM: {
_cleanup_strv_free_ char **subsystems = NULL;
subsystems = strv_split(optarg, ",");
if (!subsystems)
return log_error_errno(r, "Failed to parse prioritized subsystem '%s': %m", optarg);
STRV_FOREACH(p, subsystems) {
r = device_enumerator_add_prioritized_subsystem(e, *p);
if (r < 0)
return log_error_errno(r, "Failed to add prioritized subsystem '%s': %m", *p);
}
break;
}
case ARG_INITIALIZED_MATCH:
case ARG_INITIALIZED_NOMATCH:
r = device_enumerator_add_match_is_initialized(e, c == ARG_INITIALIZED_MATCH ? MATCH_INITIALIZED_YES : MATCH_INITIALIZED_NO);
if (r < 0)
return log_error_errno(r, "Failed to set initialized filter: %m");
break;
case 'V':
return print_version();
case 'h':
return help();
case '?':
return -EINVAL;
default:
assert_not_reached();
}
}
if (ping) {
_cleanup_(udev_ctrl_unrefp) UdevCtrl *uctrl = NULL;
r = udev_ctrl_new(&uctrl);
if (r < 0)
return log_error_errno(r, "Failed to initialize udev control: %m");
r = udev_ctrl_send_ping(uctrl);
if (r < 0)
return log_error_errno(r, "Failed to connect to udev daemon: %m");
r = udev_ctrl_wait(uctrl, ping_timeout_usec);
if (r < 0)
return log_error_errno(r, "Failed to wait for daemon to reply: %m");
}
for (; optind < argc; optind++) {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
r = find_device(argv[optind], NULL, &dev);
if (r < 0)
return log_error_errno(r, "Failed to open the device '%s': %m", argv[optind]);
r = device_enumerator_add_match_parent_incremental(e, dev);
if (r < 0)
return log_error_errno(r, "Failed to add parent match '%s': %m", argv[optind]);
}
if (arg_settle) {
r = sd_event_default(&event);
if (r < 0)
return log_error_errno(r, "Failed to get default event: %m");
r = sd_device_monitor_new(&m);
if (r < 0)
return log_error_errno(r, "Failed to create device monitor object: %m");
r = sd_device_monitor_attach_event(m, event);
if (r < 0)
return log_error_errno(r, "Failed to attach event to device monitor: %m");
r = sd_device_monitor_start(m, device_monitor_handler, &settle_path_or_ids);
if (r < 0)
return log_error_errno(r, "Failed to start device monitor: %m");
}
switch (device_type) {
case TYPE_SUBSYSTEMS:
r = device_enumerator_scan_subsystems(e);
if (r < 0)
return log_error_errno(r, "Failed to scan subsystems: %m");
break;
case TYPE_DEVICES:
r = device_enumerator_scan_devices(e);
if (r < 0)
return log_error_errno(r, "Failed to scan devices: %m");
break;
case TYPE_ALL:
r = device_enumerator_scan_devices_and_subsystems(e);
if (r < 0)
return log_error_errno(r, "Failed to scan devices and subsystems: %m");
break;
default:
assert_not_reached();
}
r = exec_list(e, action, arg_settle ? &settle_path_or_ids : NULL);
if (r < 0)
return r;
if (!set_isempty(settle_path_or_ids)) {
r = sd_event_loop(event);
if (r < 0)
return log_error_errno(r, "Event loop failed: %m");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink