udevadm: make use of the new uuid-enabled triggering for "udevadm trigger"

poettering · poettering · commit 730b9c1e1469 · 2021-05-26T21:44:36.000+02:00
This adds two things:

- A new switch --uuid is added to "udevadm trigger". If specified a
  random UUID is associated with the synthettic uevent and it is printed
  to stdout. It may then be used manually to match up uevents as they
  propagate through the system.

- The UUID logic is now implicitly enabled if "udevadm trigger --settle"
  is used, in order to wait for precisely the uevents we actually
  trigger. Fallback support is kept for pre-4.13 kernels (where the
  requests for trigger uevents with uuids results in EINVAL).
diff --git a/man/udevadm.xml b/man/udevadm.xml
@@ -375,6 +375,15 @@
             the same command to finish.</para>
           </listitem>
         </varlistentry>
+        <varlistentry>
+          <term><option>--uuid</option></term>
+          <listitem>
+            <para>Trigger the synthetic device events, and associate a randomized UUID with each. These UUIDs
+            are printed to standard output, one line for each event. These UUIDs are included in the uevent
+            environment block (in the <literal>SYNTH_UUID=</literal> property) and may be used to track
+            delivery of the generated events.</para>
+          </listitem>
+        </varlistentry>
         <varlistentry>
           <term><option>--wait-daemon[=<replaceable>SECONDS</replaceable>]</option></term>
           <listitem>
diff --git a/src/basic/hash-funcs.c b/src/basic/hash-funcs.c
@@ -57,6 +57,9 @@ void path_hash_func(const char *q, struct siphash *state) {
 DEFINE_HASH_OPS(path_hash_ops, char, path_hash_func, path_compare);
 DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(path_hash_ops_free,
                                     char, path_hash_func, path_compare, free);
+DEFINE_HASH_OPS_FULL(path_hash_ops_free_free,
+                     char, path_hash_func, path_compare, free,
+                     void, free);
 
 void trivial_hash_func(const void *p, struct siphash *state) {
         siphash24_compress(&p, sizeof(p), state);
diff --git a/src/basic/hash-funcs.h b/src/basic/hash-funcs.h
@@ -82,6 +82,7 @@ extern const struct hash_ops string_hash_ops_free_free;
 void path_hash_func(const char *p, struct siphash *state);
 extern const struct hash_ops path_hash_ops;
 extern const struct hash_ops path_hash_ops_free;
+extern const struct hash_ops path_hash_ops_free_free;
 
 /* This will compare the passed pointers directly, and will not dereference them. This is hence not useful for strings
  * or suchlike. */
diff --git a/src/udev/udevadm-trigger.c b/src/udev/udevadm-trigger.c
@@ -24,27 +24,48 @@
 static bool arg_verbose = false;
 static bool arg_dry_run = false;
 static bool arg_quiet = false;
+static bool arg_uuid = false;
 
-static int exec_list(sd_device_enumerator *e, sd_device_action_t action, Set **settle_set) {
+static int exec_list(
+                sd_device_enumerator *e,
+                sd_device_action_t action,
+                Hashmap *settle_hashmap) {
+
+        bool skip_uuid_logic = false;
         const char *action_str;
         sd_device *d;
         int r, ret = 0;
 
         action_str = device_action_to_string(action);
 
         FOREACH_DEVICE_AND_SUBSYSTEM(e, d) {
+                sd_id128_t id = SD_ID128_NULL;
                 const char *syspath;
 
-                if (sd_device_get_syspath(d, &syspath) < 0)
+                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", strna(syspath));
+                        printf("%s\n", syspath);
 
                 if (arg_dry_run)
                         continue;
 
-                r = sd_device_trigger(d, action);
+                /* 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 || settle_hashmap) && !skip_uuid_logic ? &id : NULL);
+                if (r == -EINVAL && !arg_uuid && settle_hashmap && !skip_uuid_logic) {
+                        /* 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)
+                                skip_uuid_logic = true; /* 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.
@@ -86,35 +107,80 @@ static int exec_list(sd_device_enumerator *e, sd_device_action_t action, Set **s
                         continue;
                 }
 
-                if (settle_set) {
-                        r = set_put_strdup(settle_set, syspath);
+                /* If the user asked for it, write event UUID to stdout */
+                if (arg_uuid)
+                        printf(SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(id));
+
+                if (settle_hashmap) {
+                        _cleanup_free_ sd_id128_t *mid = NULL;
+                        _cleanup_free_ char *sp = NULL;
+
+                        sp = strdup(syspath);
+                        if (!sp)
+                                return log_oom();
+
+                        mid = newdup(sd_id128_t, &id, 1);
+                        if (!d)
+                                return log_oom();
+
+                        r = hashmap_put(settle_hashmap, sp, mid);
                         if (r < 0)
                                 return log_oom();
+
+                        TAKE_PTR(sp);
+                        TAKE_PTR(mid);
                 }
         }
 
         return ret;
 }
 
 static int device_monitor_handler(sd_device_monitor *m, sd_device *dev, void *userdata) {
-        _cleanup_free_ char *val = NULL;
-        Set *settle_set = userdata;
+        Hashmap *settle_hashmap = userdata;
+        sd_id128_t *settle_id;
         const char *syspath;
+        char *k;
+        int r;
 
         assert(dev);
-        assert(settle_set);
+        assert(settle_hashmap);
 
-        if (sd_device_get_syspath(dev, &syspath) < 0)
+        r = sd_device_get_syspath(dev, &syspath);
+        if (r < 0) {
+                log_debug_errno(r, "Failed to get syspath of device event, ignoring: %m");
                 return 0;
+        }
+
+        settle_id = hashmap_get2(settle_hashmap, syspath, (void**) &k);
+        if (!settle_id) {
+                log_debug("Got uevent for unexpected device '%s', ignoring.", syspath);
+                return 0;
+        }
+        if (!sd_id128_is_null(*settle_id)) { /* If this is SD_ID128_NULL then we are on pre-4.13 and have no UUID to check, hence don't */
+                sd_id128_t event_id;
+
+                r = sd_device_get_trigger_uuid(dev, &event_id);
+                if (r < 0) {
+                        log_debug_errno(r, "Got uevent without synthetic UUID for device '%s', ignoring: %m", syspath);
+                        return 0;
+                }
+
+                if (!sd_id128_equal(event_id, *settle_id)) {
+                        log_debug("Got uevent not matching expected UUID for device '%s', ignoring.", syspath);
+                        return 0;
+                }
+        }
 
         if (arg_verbose)
                 printf("settle %s\n", syspath);
 
-        val = set_remove(settle_set, syspath);
-        if (!val)
-                log_debug("Got epoll event on syspath %s not present in syspath set", syspath);
+        if (arg_uuid)
+                printf("settle " SD_ID128_FORMAT_STR "\n", SD_ID128_FORMAT_VAL(*settle_id));
+
+        free(hashmap_remove(settle_hashmap, syspath));
+        free(k);
 
-        if (set_isempty(settle_set))
+        if (hashmap_isempty(settle_hashmap))
                 return sd_event_exit(sd_device_monitor_get_event(m), 0);
 
         return 0;
@@ -162,7 +228,8 @@ static int help(void) {
                "  -b --parent-match=NAME            Trigger devices with that parent device\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",
+               "                                    before triggering uevents\n"
+               "     --uuid                         Print synthetic uevent UUID\n",
                program_invocation_short_name);
 
         return 0;
@@ -172,6 +239,7 @@ int trigger_main(int argc, char *argv[], void *userdata) {
         enum {
                 ARG_NAME = 0x100,
                 ARG_PING,
+                ARG_UUID,
         };
 
         static const struct option options[] = {
@@ -193,6 +261,7 @@ int trigger_main(int argc, char *argv[], void *userdata) {
                 { "wait-daemon",       optional_argument, NULL, ARG_PING },
                 { "version",           no_argument,       NULL, 'V'      },
                 { "help",              no_argument,       NULL, 'h'      },
+                { "uuid",              no_argument,       NULL, ARG_UUID },
                 {}
         };
         enum {
@@ -203,7 +272,7 @@ int trigger_main(int argc, char *argv[], void *userdata) {
         _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_set = NULL;
+        _cleanup_hashmap_free_ Hashmap *settle_hashmap = NULL;
         usec_t ping_timeout_usec = 5 * USEC_PER_SEC;
         bool settle = false, ping = false;
         int c, r;
@@ -327,15 +396,18 @@ int trigger_main(int argc, char *argv[], void *userdata) {
                         break;
                 }
 
-                case ARG_PING: {
+                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 'V':
                         return print_version();
@@ -377,8 +449,8 @@ int trigger_main(int argc, char *argv[], void *userdata) {
         }
 
         if (settle) {
-                settle_set = set_new(&string_hash_ops_free);
-                if (!settle_set)
+                settle_hashmap = hashmap_new(&path_hash_ops_free_free);
+                if (!settle_hashmap)
                         return log_oom();
 
                 r = sd_event_default(&event);
@@ -393,7 +465,7 @@ int trigger_main(int argc, char *argv[], void *userdata) {
                 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_set);
+                r = sd_device_monitor_start(m, device_monitor_handler, settle_hashmap);
                 if (r < 0)
                         return log_error_errno(r, "Failed to start device monitor: %m");
         }
@@ -413,11 +485,11 @@ int trigger_main(int argc, char *argv[], void *userdata) {
                 assert_not_reached("Unknown device type");
         }
 
-        r = exec_list(e, action, settle ? &settle_set : NULL);
+        r = exec_list(e, action, settle_hashmap);
         if (r < 0)
                 return r;
 
-        if (event && !set_isempty(settle_set)) {
+        if (event && !hashmap_isempty(settle_hashmap)) {
                 r = sd_event_loop(event);
                 if (r < 0)
                         return log_error_errno(r, "Event loop failed: %m");
