From 0f86dc900e93f2819c4d4e048d0b05ab5408a047 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:13:57 +0900 Subject: [PATCH 01/15] udev-event: make udev_event_new() take exec_delay --- src/test/test-udev.c | 2 +- src/udev/udev-event.c | 3 ++- src/udev/udev.h | 2 +- src/udev/udevadm-test.c | 2 +- src/udev/udevd.c | 7 ++----- 5 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/test/test-udev.c b/src/test/test-udev.c index 1285117c32..60267b70c6 100644 --- a/src/test/test-udev.c +++ b/src/test/test-udev.c @@ -82,7 +82,7 @@ int main(int argc, char *argv[]) { goto out; } - assert_se(event = udev_event_new(dev)); + assert_se(event = udev_event_new(dev, 0)); assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0); diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index a0f6a5daa4..17aaa42842 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -42,7 +42,7 @@ typedef struct Spawn { size_t result_len; } Spawn; -struct udev_event *udev_event_new(struct udev_device *dev) { +struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay) { struct udev_event *event; assert(dev); @@ -54,6 +54,7 @@ struct udev_event *udev_event_new(struct udev_device *dev) { *event = (struct udev_event) { .dev = dev, .birth_usec = now(CLOCK_MONOTONIC), + .exec_delay = exec_delay, }; return event; diff --git a/src/udev/udev.h b/src/udev/udev.h index f723dd7067..246f74e6ee 100644 --- a/src/udev/udev.h +++ b/src/udev/udev.h @@ -60,7 +60,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event int udev_rules_apply_static_dev_perms(struct udev_rules *rules); /* udev-event.c */ -struct udev_event *udev_event_new(struct udev_device *dev); +struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay); struct udev_event *udev_event_free(struct udev_event *event); ssize_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size, diff --git a/src/udev/udevadm-test.c b/src/udev/udevadm-test.c index 20f713d738..df66997184 100644 --- a/src/udev/udevadm-test.c +++ b/src/udev/udevadm-test.c @@ -128,7 +128,7 @@ int test_main(int argc, char *argv[], void *userdata) { /* don't read info from the db */ udev_device_set_info_loaded(dev); - event = udev_event_new(dev); + event = udev_event_new(dev, 0); sigfillset(&mask); sigprocmask(SIG_SETMASK, &mask, &sigmask_orig); diff --git a/src/udev/udevd.c b/src/udev/udevd.c index 8391638d34..9985907e80 100644 --- a/src/udev/udevd.c +++ b/src/udev/udevd.c @@ -409,15 +409,12 @@ static void worker_spawn(Manager *manager, struct event *event) { assert(dev); log_debug("seq %llu running", udev_device_get_seqnum(dev)); - udev_event = udev_event_new(dev); - if (udev_event == NULL) { + udev_event = udev_event_new(dev, arg_exec_delay); + if (!udev_event) { r = -ENOMEM; goto out; } - if (arg_exec_delay > 0) - udev_event->exec_delay = arg_exec_delay; - /* * Take a shared lock on the device node; this establishes * a concept of device "ownership" to serialize device From e0bb2ff94b884268045f23b296fc222946eedf0d Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:19:31 +0900 Subject: [PATCH 02/15] udev-event: make udev_event_new() take sd_netlink and take a reference of that --- src/test/test-udev.c | 2 +- src/udev/udev-event.c | 3 ++- src/udev/udev.h | 2 +- src/udev/udevadm-test.c | 2 +- src/udev/udevd.c | 7 ++----- 5 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/test/test-udev.c b/src/test/test-udev.c index 60267b70c6..7d4eacb8a1 100644 --- a/src/test/test-udev.c +++ b/src/test/test-udev.c @@ -82,7 +82,7 @@ int main(int argc, char *argv[]) { goto out; } - assert_se(event = udev_event_new(dev, 0)); + assert_se(event = udev_event_new(dev, 0, NULL)); assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0); diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index 17aaa42842..cca6c42363 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -42,7 +42,7 @@ typedef struct Spawn { size_t result_len; } Spawn; -struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay) { +struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay, sd_netlink *rtnl) { struct udev_event *event; assert(dev); @@ -55,6 +55,7 @@ struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay) { .dev = dev, .birth_usec = now(CLOCK_MONOTONIC), .exec_delay = exec_delay, + .rtnl = sd_netlink_ref(rtnl), }; return event; diff --git a/src/udev/udev.h b/src/udev/udev.h index 246f74e6ee..34c63a6eac 100644 --- a/src/udev/udev.h +++ b/src/udev/udev.h @@ -60,7 +60,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event int udev_rules_apply_static_dev_perms(struct udev_rules *rules); /* udev-event.c */ -struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay); +struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay, sd_netlink *rtnl); struct udev_event *udev_event_free(struct udev_event *event); ssize_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size, diff --git a/src/udev/udevadm-test.c b/src/udev/udevadm-test.c index df66997184..ec3d8460e8 100644 --- a/src/udev/udevadm-test.c +++ b/src/udev/udevadm-test.c @@ -128,7 +128,7 @@ int test_main(int argc, char *argv[], void *userdata) { /* don't read info from the db */ udev_device_set_info_loaded(dev); - event = udev_event_new(dev, 0); + event = udev_event_new(dev, 0, NULL); sigfillset(&mask); sigprocmask(SIG_SETMASK, &mask, &sigmask_orig); diff --git a/src/udev/udevd.c b/src/udev/udevd.c index 9985907e80..efab86b413 100644 --- a/src/udev/udevd.c +++ b/src/udev/udevd.c @@ -409,7 +409,7 @@ static void worker_spawn(Manager *manager, struct event *event) { assert(dev); log_debug("seq %llu running", udev_device_get_seqnum(dev)); - udev_event = udev_event_new(dev, arg_exec_delay); + udev_event = udev_event_new(dev, arg_exec_delay, rtnl); if (!udev_event) { r = -ENOMEM; goto out; @@ -440,9 +440,6 @@ static void worker_spawn(Manager *manager, struct event *event) { } } - /* needed for renaming netifs */ - udev_event->rtnl = rtnl; - /* apply rules, create node, symlinks */ udev_event_execute_rules(udev_event, arg_event_timeout_usec, arg_event_timeout_warn_usec, @@ -452,7 +449,7 @@ static void worker_spawn(Manager *manager, struct event *event) { udev_event_execute_run(udev_event, arg_event_timeout_usec, arg_event_timeout_warn_usec); - if (udev_event->rtnl) + if (!rtnl) /* in case rtnl was initialized */ rtnl = sd_netlink_ref(udev_event->rtnl); From 480ecb7d28193bbfcd1a7534b1ee37c268494680 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:01:39 +0900 Subject: [PATCH 03/15] udev: use sd_device for udev_event.dev_db Also, this adds sd_device_unref for the object in udev_event_free() for safety and readability of code. --- src/udev/udev-event.c | 25 +++++++++++-------------- src/udev/udev-rules.c | 10 ++++------ src/udev/udev.h | 2 +- 3 files changed, 16 insertions(+), 21 deletions(-) diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index cca6c42363..1270369321 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -67,6 +67,8 @@ struct udev_event *udev_event_free(struct udev_event *event) { if (!event) return NULL; + udev_device_unref(event->dev); + sd_device_unref(event->dev_db_clone); sd_netlink_unref(event->rtnl); while ((p = hashmap_steal_first_key(event->run_list))) free(p); @@ -739,8 +741,8 @@ static int update_devnode(struct udev_event *event) { return log_device_error_errno(dev, r, "Failed to get devnum: %m"); /* remove/update possible left-over symlinks from old database entry */ - if (event->dev_db) - (void) udev_node_update_old_links(dev, event->dev_db->device); + if (event->dev_db_clone) + (void) udev_node_update_old_links(dev, event->dev_db_clone); if (!event->owner_set) { r = device_get_devnode_uid(dev, &event->uid); @@ -812,7 +814,6 @@ int udev_event_execute_rules(struct udev_event *event, usec_t timeout_usec, usec_t timeout_warn_usec, Hashmap *properties_list, struct udev_rules *rules) { - _cleanup_(sd_device_unrefp) sd_device *clone = NULL; sd_device *dev = event->dev->device; const char *subsystem, *action; int r; @@ -833,28 +834,24 @@ int udev_event_execute_rules(struct udev_event *event, return 0; } - r = device_clone_with_db(dev, &clone); + r = device_clone_with_db(dev, &event->dev_db_clone); if (r < 0) log_device_debug_errno(dev, r, "Failed to clone sd_device object, ignoring: %m"); - if (clone) { - event->dev_db = udev_device_new(NULL, clone); - if (!event->dev_db) - return -ENOMEM; - + if (event->dev_db_clone) { r = sd_device_get_devnum(dev, NULL); if (r < 0) { if (r != -ENOENT) log_device_debug_errno(dev, r, "Failed to get devnum, ignoring: %m"); if (streq(action, "move")) { - r = device_copy_properties(dev, clone); + r = device_copy_properties(dev, event->dev_db_clone); if (r < 0) log_device_debug_errno(dev, r, "Failed to copy properties from cloned device, ignoring: %m"); } } else /* Disable watch during event processing. */ - (void) udev_watch_end(clone); + (void) udev_watch_end(event->dev_db_clone); } (void) udev_rules_apply_to_event(rules, event, @@ -865,12 +862,12 @@ int udev_event_execute_rules(struct udev_event *event, (void) update_devnode(event); /* preserve old, or get new initialization timestamp */ - r = device_ensure_usec_initialized(dev, clone); + r = device_ensure_usec_initialized(dev, event->dev_db_clone); if (r < 0) log_device_debug_errno(dev, r, "Failed to set initialization timestamp, ignoring: %m"); /* (re)write database file */ - r = device_tag_index(dev, clone, true); + r = device_tag_index(dev, event->dev_db_clone, true); if (r < 0) log_device_debug_errno(dev, r, "Failed to update tags under /run/udev/tag/, ignoring: %m"); @@ -880,7 +877,7 @@ int udev_event_execute_rules(struct udev_event *event, device_set_is_initialized(dev); - event->dev_db = udev_device_unref(event->dev_db); + event->dev_db_clone = sd_device_unref(event->dev_db_clone); return 0; } diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 7703e867f8..d5ebd3bb17 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -16,6 +16,7 @@ #include "alloc-util.h" #include "conf-files.h" #include "def.h" +#include "device-util.h" #include "dirent-util.h" #include "escape.h" #include "fd-util.h" @@ -2030,13 +2031,10 @@ int udev_rules_apply_to_event( const char *key = rules_str(rules, cur->key.value_off); const char *value; - value = udev_device_get_property_value(event->dev_db, key); - if (value != NULL) + if (sd_device_get_property_value(event->dev_db_clone, key, &value) >= 0) udev_device_add_property(event->dev, key, value); - else { - if (cur->key.op != OP_NOMATCH) - goto nomatch; - } + else if (cur->key.op != OP_NOMATCH) + goto nomatch; break; } case TK_M_IMPORT_CMDLINE: { diff --git a/src/udev/udev.h b/src/udev/udev.h index 34c63a6eac..c963af8cb4 100644 --- a/src/udev/udev.h +++ b/src/udev/udev.h @@ -23,7 +23,7 @@ struct udev_event { struct udev_device *dev; struct udev_device *dev_parent; - struct udev_device *dev_db; + sd_device *dev_db_clone; char *name; char *program_result; mode_t mode; From 5ba7e79885ba769f5a016631bf95c756c1c7e02c Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:15:25 +0900 Subject: [PATCH 04/15] udev-rules: make match_attr() take sd_device instead of udev_device --- src/udev/udev-rules.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index d5ebd3bb17..daa3fd2208 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1673,11 +1673,9 @@ static int match_key(struct udev_rules *rules, struct token *token, const char * return -1; } -static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur) { - const char *name; - char nbuf[UTIL_NAME_SIZE]; - const char *value; - char vbuf[UTIL_NAME_SIZE]; +static int match_attr(struct udev_rules *rules, sd_device *dev, struct udev_event *event, struct token *cur) { + char nbuf[UTIL_NAME_SIZE], vbuf[UTIL_NAME_SIZE]; + const char *name, *value; size_t len; name = rules_str(rules, cur->key.attr_off); @@ -1687,8 +1685,7 @@ static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct name = nbuf; _fallthrough_; case SB_NONE: - value = udev_device_get_sysattr_value(dev, name); - if (value == NULL) + if (sd_device_get_sysattr_value(dev, name, &value) < 0) return -1; break; case SB_SUBSYS: @@ -1831,7 +1828,7 @@ int udev_rules_apply_to_event( goto nomatch; break; case TK_M_ATTR: - if (match_attr(rules, event->dev, event, cur) != 0) + if (match_attr(rules, event->dev->device, event, cur) != 0) goto nomatch; break; case TK_M_SYSCTL: { @@ -1885,7 +1882,7 @@ int udev_rules_apply_to_event( goto try_parent; break; case TK_M_ATTRS: - if (match_attr(rules, event->dev_parent, event, key) != 0) + if (match_attr(rules, event->dev_parent->device, event, key) != 0) goto try_parent; break; case TK_M_TAGS: { From f3d241feb2f2337098b53bfa1f86014b5c882df5 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:16:00 +0900 Subject: [PATCH 05/15] udev: use sd_device for udev_event.dev_parent --- src/udev/udev-event.c | 8 ++++---- src/udev/udev-rules.c | 24 ++++++++++++++++-------- src/udev/udev.h | 2 +- 3 files changed, 21 insertions(+), 13 deletions(-) diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index 1270369321..29845486ac 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -159,7 +159,7 @@ static ssize_t subst_format_var(struct udev_event *event, case SUBST_ID: if (!event->dev_parent) return 0; - r = sd_device_get_sysname(event->dev_parent->device, &val); + r = sd_device_get_sysname(event->dev_parent, &val); if (r < 0) return r; l = strpcpy(&s, l, val); @@ -167,7 +167,7 @@ static ssize_t subst_format_var(struct udev_event *event, case SUBST_DRIVER: if (!event->dev_parent) return 0; - r = sd_device_get_driver(event->dev_parent->device, &val); + r = sd_device_get_driver(event->dev_parent, &val); if (r < 0) return r == -ENOENT ? 0 : r; l = strpcpy(&s, l, val); @@ -240,8 +240,8 @@ static ssize_t subst_format_var(struct udev_event *event, (void) sd_device_get_sysattr_value(dev, attr, &val); /* try to read the attribute of the parent device, other matches have selected */ - if (!val && event->dev_parent && event->dev_parent->device != dev) - (void) sd_device_get_sysattr_value(event->dev_parent->device, attr, &val); + if (!val && event->dev_parent && event->dev_parent != dev) + (void) sd_device_get_sysattr_value(event->dev_parent, attr, &val); if (!val) return 0; diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index daa3fd2208..cf1c44236f 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1861,32 +1861,39 @@ int udev_rules_apply_to_event( next++; /* loop over parents */ - event->dev_parent = event->dev; + event->dev_parent = event->dev->device; for (;;) { struct token *key; + const char *val; /* loop over sequence of parent match keys */ for (key = cur; key < next; key++ ) { dump_token(rules, key); switch(key->type) { case TK_M_KERNELS: - if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0) + if (sd_device_get_sysname(event->dev_parent, &val) < 0) + goto try_parent; + if (match_key(rules, key, val) != 0) goto try_parent; break; case TK_M_SUBSYSTEMS: - if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0) + if (sd_device_get_subsystem(event->dev_parent, &val) < 0) + goto try_parent; + if (match_key(rules, key, val) != 0) goto try_parent; break; case TK_M_DRIVERS: - if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0) + if (sd_device_get_driver(event->dev_parent, &val) < 0) + goto try_parent; + if (match_key(rules, key, val) != 0) goto try_parent; break; case TK_M_ATTRS: - if (match_attr(rules, event->dev_parent->device, event, key) != 0) + if (match_attr(rules, event->dev_parent, event, key) != 0) goto try_parent; break; case TK_M_TAGS: { - bool match = udev_device_has_tag(event->dev_parent, rules_str(rules, cur->key.value_off)); + bool match = sd_device_has_tag(event->dev_parent, rules_str(rules, cur->key.value_off)); if (match && key->key.op == OP_NOMATCH) goto try_parent; @@ -1901,9 +1908,10 @@ int udev_rules_apply_to_event( break; try_parent: - event->dev_parent = udev_device_get_parent(event->dev_parent); - if (event->dev_parent == NULL) + if (sd_device_get_parent(event->dev_parent, &event->dev_parent) < 0) { + event->dev_parent = NULL; goto nomatch; + } } /* move behind our sequence of parent match keys */ cur = next; diff --git a/src/udev/udev.h b/src/udev/udev.h index c963af8cb4..85fcdc439f 100644 --- a/src/udev/udev.h +++ b/src/udev/udev.h @@ -22,7 +22,7 @@ struct udev_event { struct udev_device *dev; - struct udev_device *dev_parent; + sd_device *dev_parent; sd_device *dev_db_clone; char *name; char *program_result; From 29b5eb5adf081fd599713ab577fb9ab034ea57e5 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:24:14 +0900 Subject: [PATCH 06/15] udev-rules: make import_property_from_string() take sd_device Also, this makes the function return negative errno, though its return value is always ignored. --- src/udev/udev-rules.c | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index cf1c44236f..5c046ea838 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -16,6 +16,7 @@ #include "alloc-util.h" #include "conf-files.h" #include "def.h" +#include "device-private.h" #include "device-util.h" #include "dirent-util.h" #include "escape.h" @@ -557,7 +558,7 @@ static gid_t add_gid(struct udev_rules *rules, const char *group) { return gid; } -static int import_property_from_string(struct udev_device *dev, char *line) { +static int import_property_from_string(sd_device *dev, char *line) { char *key; char *val; size_t len; @@ -569,12 +570,12 @@ static int import_property_from_string(struct udev_device *dev, char *line) { /* comment or empty line */ if (IN_SET(key[0], '#', '\0')) - return -1; + return 0; /* split key/value */ val = strchr(key, '='); - if (val == NULL) - return -1; + if (!val) + return -EINVAL; val[0] = '\0'; val++; @@ -585,7 +586,7 @@ static int import_property_from_string(struct udev_device *dev, char *line) { /* terminate key */ len = strlen(key); if (len == 0) - return -1; + return -EINVAL; while (isspace(key[len-1])) len--; key[len] = '\0'; @@ -593,27 +594,25 @@ static int import_property_from_string(struct udev_device *dev, char *line) { /* terminate value */ len = strlen(val); if (len == 0) - return -1; + return -EINVAL; while (isspace(val[len-1])) len--; val[len] = '\0'; if (len == 0) - return -1; + return -EINVAL; /* unquote */ if (IN_SET(val[0], '"', '\'')) { if (len == 1 || val[len-1] != val[0]) { log_debug("inconsistent quoting: '%s', skip", line); - return -1; + return -EINVAL; } val[len-1] = '\0'; val++; } - udev_device_add_property(dev, key, val); - - return 0; + return device_add_property(dev, key, val); } static int import_file_into_properties(struct udev_device *dev, const char *filename) { @@ -633,7 +632,7 @@ static int import_file_into_properties(struct udev_device *dev, const char *file if (r == 0) break; - (void) import_property_from_string(dev, line); + (void) import_property_from_string(dev->device, line); } return 0; @@ -660,7 +659,7 @@ static int import_program_into_properties(struct udev_event *event, pos[0] = '\0'; pos = &pos[1]; } - (void) import_property_from_string(event->dev, line); + (void) import_property_from_string(event->dev->device, line); line = pos; } return 0; From 13c7b75f2ff04ed0a4a3671e45c907770fbef1aa Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:26:39 +0900 Subject: [PATCH 07/15] udev-rules: make import_file_into_properties() take sd_device --- src/udev/udev-rules.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 5c046ea838..43e80c7278 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -615,7 +615,7 @@ static int import_property_from_string(sd_device *dev, char *line) { return device_add_property(dev, key, val); } -static int import_file_into_properties(struct udev_device *dev, const char *filename) { +static int import_file_into_properties(sd_device *dev, const char *filename) { _cleanup_fclose_ FILE *f = NULL; int r; @@ -632,7 +632,7 @@ static int import_file_into_properties(struct udev_device *dev, const char *file if (r == 0) break; - (void) import_property_from_string(dev->device, line); + (void) import_property_from_string(dev, line); } return 0; @@ -1975,7 +1975,7 @@ int udev_rules_apply_to_event( char import[UTIL_PATH_SIZE]; udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false); - if (import_file_into_properties(event->dev, import) != 0) + if (import_file_into_properties(event->dev->device, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; break; From 1ce7fecb4f9a586d42565ae657231f5a1930ab4c Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:31:19 +0900 Subject: [PATCH 08/15] udev-rules: make import_parent_into_properties() take sd_device --- src/udev/udev-rules.c | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 43e80c7278..559a0ff7b6 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -665,24 +665,21 @@ static int import_program_into_properties(struct udev_event *event, return 0; } -static int import_parent_into_properties(struct udev_device *dev, const char *filter) { - struct udev_device *dev_parent; - struct udev_list_entry *list_entry; +static int import_parent_into_properties(sd_device *dev, const char *filter) { + const char *key, *val; + sd_device *parent; + int r; assert(dev); assert(filter); - dev_parent = udev_device_get_parent(dev); - if (dev_parent == NULL) - return -1; - - udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(dev_parent)) { - const char *key = udev_list_entry_get_name(list_entry); - const char *val = udev_list_entry_get_value(list_entry); + r = sd_device_get_parent(dev, &parent); + if (r < 0) + return r; + FOREACH_DEVICE_PROPERTY(parent, key, val) if (fnmatch(filter, key, 0) == 0) - udev_device_add_property(dev, key, val); - } + device_add_property(dev, key, val); return 0; } @@ -2069,7 +2066,7 @@ int udev_rules_apply_to_event( char import[UTIL_PATH_SIZE]; udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false); - if (import_parent_into_properties(event->dev, import) != 0) + if (import_parent_into_properties(event->dev->device, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; break; From 92b80c6baac8c94cefbdd7b74f37b339ceb35752 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:28:01 +0900 Subject: [PATCH 09/15] udev-rules: drop unused member file_list in struct udev_rules --- src/udev/udev-rules.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 559a0ff7b6..b43a37b8e1 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1514,7 +1514,6 @@ static int parse_file(struct udev_rules *rules, const char *filename) { struct udev_rules *udev_rules_new(int resolve_names) { struct udev_rules *rules; - struct udev_list file_list; struct token end_token; char **files, **f; int r; @@ -1523,7 +1522,6 @@ struct udev_rules *udev_rules_new(int resolve_names) { if (rules == NULL) return NULL; rules->resolve_names = resolve_names; - udev_list_init(NULL, &file_list, true); /* init token array and string buffer */ rules->tokens = malloc_multiply(PREALLOC_TOKEN, sizeof(struct token)); From 1017d66bf511427f19b15fac927be7afae931126 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:30:43 +0900 Subject: [PATCH 10/15] udev-rules: use structured initializer --- src/udev/udev-rules.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index b43a37b8e1..49ee14c650 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1518,10 +1518,13 @@ struct udev_rules *udev_rules_new(int resolve_names) { char **files, **f; int r; - rules = new0(struct udev_rules, 1); - if (rules == NULL) + rules = new(struct udev_rules, 1); + if (!rules) return NULL; - rules->resolve_names = resolve_names; + + *rules = (struct udev_rules) { + .resolve_names = resolve_names, + }; /* init token array and string buffer */ rules->tokens = malloc_multiply(PREALLOC_TOKEN, sizeof(struct token)); From dbea7f24d2311f47947fbe7adea68fb65cca17a5 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 15:39:53 +0900 Subject: [PATCH 11/15] udev-rules: replace two udev_list_entry_foreach() by corresponding FOREACH_DEVICE_*() macros --- src/udev/udev-rules.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 49ee14c650..a5ead0930b 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1767,18 +1767,15 @@ int udev_rules_apply_to_event( goto nomatch; break; case TK_M_DEVLINK: { - struct udev_list_entry *list_entry; + const char *devlink; bool match = false; - udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) { - const char *devlink; - - devlink = udev_list_entry_get_name(list_entry) + STRLEN("/dev/"); - if (match_key(rules, cur, devlink) == 0) { + FOREACH_DEVICE_DEVLINK(event->dev->device, devlink) + if (match_key(rules, cur, devlink + STRLEN("/dev/")) == 0) { match = true; break; } - } + if (!match) goto nomatch; break; @@ -1802,15 +1799,15 @@ int udev_rules_apply_to_event( break; } case TK_M_TAG: { - struct udev_list_entry *list_entry; bool match = false; + const char *tag; - udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(event->dev)) { - if (streq(rules_str(rules, cur->key.value_off), udev_list_entry_get_name(list_entry))) { + FOREACH_DEVICE_TAG(event->dev->device, tag) + if (streq(rules_str(rules, cur->key.value_off), tag)) { match = true; break; } - } + if ((!match && (cur->key.op != OP_NOMATCH)) || (match && (cur->key.op == OP_NOMATCH))) goto nomatch; From cf697ec00e57712a33f5e129ca5349eacb199c4d Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 16:15:07 +0900 Subject: [PATCH 12/15] udev-rules: replace udev_device by sd_device in udev_rules_apply_to_event() --- src/udev/udev-rules.c | 156 ++++++++++++++++++++++-------------------- 1 file changed, 83 insertions(+), 73 deletions(-) diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index a5ead0930b..11104d62d0 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -1727,18 +1727,23 @@ int udev_rules_apply_to_event( usec_t timeout_usec, usec_t timeout_warn_usec, Hashmap *properties_list) { - struct token *cur; - struct token *rule; + sd_device *dev = event->dev->device; enum escape_type esc = ESCAPE_UNSET; + struct token *cur, *rule; + const char *action, *val; bool can_set_name; int r; if (!rules->tokens) return 0; - can_set_name = ((!streq(udev_device_get_action(event->dev), "remove")) && - (major(udev_device_get_devnum(event->dev)) > 0 || - udev_device_get_ifindex(event->dev) > 0)); + r = sd_device_get_property_value(dev, "ACTION", &action); + if (r < 0) + return r; + + can_set_name = (!streq(action, "remove") && + (sd_device_get_devnum(dev, NULL) >= 0 || + sd_device_get_ifindex(dev, NULL) >= 0)); /* loop through token list, match, run actions or forward to next rule */ cur = &rules->tokens[0]; @@ -1755,22 +1760,26 @@ int udev_rules_apply_to_event( esc = ESCAPE_UNSET; break; case TK_M_ACTION: - if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0) + if (match_key(rules, cur, action) != 0) goto nomatch; break; case TK_M_DEVPATH: - if (match_key(rules, cur, udev_device_get_devpath(event->dev)) != 0) + if (sd_device_get_devpath(dev, &val) < 0) + goto nomatch; + if (match_key(rules, cur, val) != 0) goto nomatch; break; case TK_M_KERNEL: - if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0) + if (sd_device_get_sysname(dev, &val) < 0) + goto nomatch; + if (match_key(rules, cur, val) != 0) goto nomatch; break; case TK_M_DEVLINK: { const char *devlink; bool match = false; - FOREACH_DEVICE_DEVLINK(event->dev->device, devlink) + FOREACH_DEVICE_DEVLINK(dev, devlink) if (match_key(rules, cur, devlink + STRLEN("/dev/")) == 0) { match = true; break; @@ -1786,15 +1795,16 @@ int udev_rules_apply_to_event( break; case TK_M_ENV: { const char *key_name = rules_str(rules, cur->key.attr_off); - const char *value; - value = udev_device_get_property_value(event->dev, key_name); + if (sd_device_get_property_value(dev, key_name, &val) < 0) { + /* check global properties */ + if (properties_list) + val = hashmap_get(properties_list, key_name); + else + val = NULL; + } - /* check global properties */ - if (!value && properties_list) - value = hashmap_get(properties_list, key_name); - - if (match_key(rules, cur, strempty(value))) + if (match_key(rules, cur, strempty(val))) goto nomatch; break; } @@ -1802,7 +1812,7 @@ int udev_rules_apply_to_event( bool match = false; const char *tag; - FOREACH_DEVICE_TAG(event->dev->device, tag) + FOREACH_DEVICE_TAG(dev, tag) if (streq(rules_str(rules, cur->key.value_off), tag)) { match = true; break; @@ -1814,15 +1824,19 @@ int udev_rules_apply_to_event( break; } case TK_M_SUBSYSTEM: - if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0) + if (sd_device_get_subsystem(dev, &val) < 0) + goto nomatch; + if (match_key(rules, cur, val) != 0) goto nomatch; break; case TK_M_DRIVER: - if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0) + if (sd_device_get_driver(dev, &val) < 0) + goto nomatch; + if (match_key(rules, cur, val) != 0) goto nomatch; break; case TK_M_ATTR: - if (match_attr(rules, event->dev->device, event, cur) != 0) + if (match_attr(rules, dev, event, cur) != 0) goto nomatch; break; case TK_M_SYSCTL: { @@ -1855,10 +1869,9 @@ int udev_rules_apply_to_event( next++; /* loop over parents */ - event->dev_parent = event->dev->device; + event->dev_parent = dev; for (;;) { struct token *key; - const char *val; /* loop over sequence of parent match keys */ for (key = cur; key < next; key++ ) { @@ -1921,9 +1934,11 @@ int udev_rules_apply_to_event( if (filename[0] != '/') { char tmp[UTIL_PATH_SIZE]; + if (sd_device_get_syspath(dev, &val) < 0) + goto nomatch; + strscpy(tmp, sizeof(tmp), filename); - strscpyl(filename, sizeof(filename), - udev_device_get_syspath(event->dev), "/", tmp, NULL); + strscpyl(filename, sizeof(filename), val, "/", tmp, NULL); } } attr_subst_subdir(filename, sizeof(filename)); @@ -1938,8 +1953,7 @@ int udev_rules_apply_to_event( break; } case TK_M_PROGRAM: { - char program[UTIL_PATH_SIZE]; - char result[UTIL_LINE_SIZE]; + char program[UTIL_PATH_SIZE], result[UTIL_LINE_SIZE]; event->program_result = mfree(event->program_result); udev_event_apply_format(event, rules_str(rules, cur->key.value_off), program, sizeof(program), false); @@ -1970,7 +1984,7 @@ int udev_rules_apply_to_event( char import[UTIL_PATH_SIZE]; udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false); - if (import_file_into_properties(event->dev->device, import) != 0) + if (import_file_into_properties(dev, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; break; @@ -2015,7 +2029,7 @@ int udev_rules_apply_to_event( rules_str(rules, rule->rule.filename_off), rule->rule.filename_line); - r = udev_builtin_run(event->dev->device, cur->key.builtin_cmd, command, false); + r = udev_builtin_run(dev, cur->key.builtin_cmd, command, false); if (r < 0) { /* remember failure */ log_debug_errno(r, "IMPORT builtin '%s' fails: %m", @@ -2027,11 +2041,11 @@ int udev_rules_apply_to_event( break; } case TK_M_IMPORT_DB: { - const char *key = rules_str(rules, cur->key.value_off); - const char *value; + const char *key; - if (sd_device_get_property_value(event->dev_db_clone, key, &value) >= 0) - udev_device_add_property(event->dev, key, value); + key = rules_str(rules, cur->key.value_off); + if (sd_device_get_property_value(event->dev_db_clone, key, &val) >= 0) + device_add_property(dev, key, val); else if (cur->key.op != OP_NOMATCH) goto nomatch; break; @@ -2042,7 +2056,6 @@ int udev_rules_apply_to_event( const char *key; key = rules_str(rules, cur->key.value_off); - r = proc_cmdline_get_key(key, PROC_CMDLINE_VALUE_OPTIONAL, &value); if (r < 0) log_debug_errno(r, "Failed to read %s from /proc/cmdline, ignoring: %m", key); @@ -2050,10 +2063,10 @@ int udev_rules_apply_to_event( imported = true; if (value) - udev_device_add_property(event->dev, key, value); + device_add_property(dev, key, value); else /* we import simple flags as 'FLAG=1' */ - udev_device_add_property(event->dev, key, "1"); + device_add_property(dev, key, "1"); } if (!imported && cur->key.op != OP_NOMATCH) @@ -2064,7 +2077,7 @@ int udev_rules_apply_to_event( char import[UTIL_PATH_SIZE]; udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false); - if (import_parent_into_properties(event->dev->device, import) != 0) + if (import_parent_into_properties(dev, import) != 0) if (cur->key.op != OP_NOMATCH) goto nomatch; break; @@ -2080,7 +2093,7 @@ int udev_rules_apply_to_event( esc = ESCAPE_REPLACE; break; case TK_A_DB_PERSIST: - udev_device_set_db_persist(event->dev); + device_set_db_persist(dev); break; case TK_A_INOTIFY_WATCH: if (event->inotify_watch_final) @@ -2090,7 +2103,7 @@ int udev_rules_apply_to_event( event->inotify_watch = cur->key.watch; break; case TK_A_DEVLINK_PRIO: - udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio); + device_set_devlink_priority(dev, cur->key.devlink_prio); break; case TK_A_OWNER: { char owner[UTIL_NAME_SIZE]; @@ -2135,9 +2148,8 @@ int udev_rules_apply_to_event( break; } case TK_A_MODE: { - char mode_str[UTIL_NAME_SIZE]; + char mode_str[UTIL_NAME_SIZE], *endptr; mode_t mode; - char *endptr; if (event->mode_final) break; @@ -2229,30 +2241,29 @@ int udev_rules_apply_to_event( break; } case TK_A_ENV: { - const char *name = rules_str(rules, cur->key.attr_off); - char *value = rules_str(rules, cur->key.value_off); char value_new[UTIL_NAME_SIZE]; - const char *value_old = NULL; + const char *name, *value_old; - if (value[0] == '\0') { + name = rules_str(rules, cur->key.attr_off); + val = rules_str(rules, cur->key.value_off); + if (val[0] == '\0') { if (cur->key.op == OP_ADD) break; - udev_device_add_property(event->dev, name, NULL); + device_add_property(dev, name, NULL); break; } - if (cur->key.op == OP_ADD) - value_old = udev_device_get_property_value(event->dev, name); - if (value_old) { + if (cur->key.op == OP_ADD && + sd_device_get_property_value(dev, name, &value_old) >= 0) { char temp[UTIL_NAME_SIZE]; /* append value separated by space */ - udev_event_apply_format(event, value, temp, sizeof(temp), false); + udev_event_apply_format(event, val, temp, sizeof(temp), false); strscpyl(value_new, sizeof(value_new), value_old, " ", temp, NULL); } else - udev_event_apply_format(event, value, value_new, sizeof(value_new), false); + udev_event_apply_format(event, val, value_new, sizeof(value_new), false); - udev_device_add_property(event->dev, name, value_new); + device_add_property(dev, name, value_new); break; } case TK_A_TAG: { @@ -2261,7 +2272,7 @@ int udev_rules_apply_to_event( udev_event_apply_format(event, rules_str(rules, cur->key.value_off), tag, sizeof(tag), false); if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL)) - udev_device_cleanup_tags_list(event->dev); + device_cleanup_tags(dev); for (p = tag; *p != '\0'; p++) { if ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z') || @@ -2272,17 +2283,17 @@ int udev_rules_apply_to_event( break; } if (cur->key.op == OP_REMOVE) - udev_device_remove_tag(event->dev, tag); + device_remove_tag(dev, tag); else - udev_device_add_tag(event->dev, tag); + device_add_tag(dev, tag); break; } case TK_A_NAME: { - const char *name = rules_str(rules, cur->key.value_off); - char name_str[UTIL_PATH_SIZE]; + const char *name; int count; + name = rules_str(rules, cur->key.value_off); if (event->name_final) break; if (cur->key.op == OP_ASSIGN_FINAL) @@ -2293,8 +2304,9 @@ int udev_rules_apply_to_event( if (count > 0) log_debug("%i character(s) replaced", count); } - if (major(udev_device_get_devnum(event->dev)) && - !streq(name_str, udev_device_get_devnode(event->dev) + STRLEN("/dev/"))) { + if (sd_device_get_devnum(dev, NULL) >= 0 && + (sd_device_get_devname(dev, &val) < 0 || + !streq(name_str, val + STRLEN("/dev/")))) { log_error("NAME=\"%s\" ignored, kernel device nodes cannot be renamed; please fix it in %s:%u\n", name, rules_str(rules, rule->rule.filename_off), @@ -2311,19 +2323,17 @@ int udev_rules_apply_to_event( break; } case TK_A_DEVLINK: { - char temp[UTIL_PATH_SIZE]; - char filename[UTIL_PATH_SIZE]; - char *pos, *next; + char temp[UTIL_PATH_SIZE], filename[UTIL_PATH_SIZE], *pos, *next; int count = 0; if (event->devlink_final) break; - if (major(udev_device_get_devnum(event->dev)) == 0) + if (sd_device_get_devnum(dev, NULL) < 0) break; if (cur->key.op == OP_ASSIGN_FINAL) event->devlink_final = true; if (IN_SET(cur->key.op, OP_ASSIGN, OP_ASSIGN_FINAL)) - udev_device_cleanup_devlinks_list(event->dev); + device_cleanup_devlinks(dev); /* allow multiple symlinks separated by spaces */ udev_event_apply_format(event, rules_str(rules, cur->key.value_off), temp, sizeof(temp), esc != ESCAPE_NONE); @@ -2337,12 +2347,12 @@ int udev_rules_apply_to_event( while (isspace(pos[0])) pos++; next = strchr(pos, ' '); - while (next != NULL) { + while (next) { next[0] = '\0'; log_debug("LINK '%s' %s:%u", pos, rules_str(rules, rule->rule.filename_off), rule->rule.filename_line); strscpyl(filename, sizeof(filename), "/dev/", pos, NULL); - udev_device_add_devlink(event->dev, filename); + device_add_devlink(dev, filename); while (isspace(next[1])) next++; pos = &next[1]; @@ -2352,18 +2362,19 @@ int udev_rules_apply_to_event( log_debug("LINK '%s' %s:%u", pos, rules_str(rules, rule->rule.filename_off), rule->rule.filename_line); strscpyl(filename, sizeof(filename), "/dev/", pos, NULL); - udev_device_add_devlink(event->dev, filename); + device_add_devlink(dev, filename); } break; } case TK_A_ATTR: { - const char *key_name = rules_str(rules, cur->key.attr_off); - char attr[UTIL_PATH_SIZE]; - char value[UTIL_NAME_SIZE]; + char attr[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE]; _cleanup_fclose_ FILE *f = NULL; + const char *key_name; - if (util_resolve_subsys_kernel(key_name, attr, sizeof(attr), 0) != 0) - strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL); + key_name = rules_str(rules, cur->key.attr_off); + if (util_resolve_subsys_kernel(key_name, attr, sizeof(attr), 0) != 0 && + sd_device_get_syspath(dev, &val) >= 0) + strscpyl(attr, sizeof(attr), val, "/", key_name, NULL); attr_subst_subdir(attr, sizeof(attr)); udev_event_apply_format(event, rules_str(rules, cur->key.value_off), value, sizeof(value), false); @@ -2378,8 +2389,7 @@ int udev_rules_apply_to_event( break; } case TK_A_SYSCTL: { - char filename[UTIL_PATH_SIZE]; - char value[UTIL_NAME_SIZE]; + char filename[UTIL_PATH_SIZE], value[UTIL_NAME_SIZE]; udev_event_apply_format(event, rules_str(rules, cur->key.attr_off), filename, sizeof(filename), false); sysctl_normalize(filename); From cf28ad46890df60d03a20e83fe8217d486dc45bb Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Mon, 29 Oct 2018 16:27:13 +0900 Subject: [PATCH 13/15] udev-event: make udev_event_new() take sd_device instead of udev_device --- src/test/test-udev.c | 3 ++- src/udev/udev-event.c | 28 ++++++++++++++-------------- src/udev/udev-rules.c | 6 +++--- src/udev/udev.h | 5 ++--- src/udev/udevadm-test.c | 3 ++- src/udev/udevd.c | 7 +++---- 6 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/test/test-udev.c b/src/test/test-udev.c index 7d4eacb8a1..5c85e92fa7 100644 --- a/src/test/test-udev.c +++ b/src/test/test-udev.c @@ -12,6 +12,7 @@ #include #include "fs-util.h" +#include "libudev-device-internal.h" #include "log.h" #include "missing.h" #include "selinux-util.h" @@ -82,7 +83,7 @@ int main(int argc, char *argv[]) { goto out; } - assert_se(event = udev_event_new(dev, 0, NULL)); + assert_se(event = udev_event_new(dev->device, 0, NULL)); assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0); diff --git a/src/udev/udev-event.c b/src/udev/udev-event.c index 29845486ac..c1d0b3662b 100644 --- a/src/udev/udev-event.c +++ b/src/udev/udev-event.c @@ -16,7 +16,7 @@ #include "device-util.h" #include "fd-util.h" #include "format-util.h" -#include "libudev-device-internal.h" +#include "libudev-private.h" #include "netlink-util.h" #include "path-util.h" #include "process-util.h" @@ -42,7 +42,7 @@ typedef struct Spawn { size_t result_len; } Spawn; -struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay, sd_netlink *rtnl) { +struct udev_event *udev_event_new(sd_device *dev, int exec_delay, sd_netlink *rtnl) { struct udev_event *event; assert(dev); @@ -52,7 +52,7 @@ struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay, sd_ne return NULL; *event = (struct udev_event) { - .dev = dev, + .dev = sd_device_ref(dev), .birth_usec = now(CLOCK_MONOTONIC), .exec_delay = exec_delay, .rtnl = sd_netlink_ref(rtnl), @@ -67,7 +67,7 @@ struct udev_event *udev_event_free(struct udev_event *event) { if (!event) return NULL; - udev_device_unref(event->dev); + sd_device_unref(event->dev); sd_device_unref(event->dev_db_clone); sd_netlink_unref(event->rtnl); while ((p = hashmap_steal_first_key(event->run_list))) @@ -129,7 +129,7 @@ static const struct subst_map_entry map[] = { static ssize_t subst_format_var(struct udev_event *event, const struct subst_map_entry *entry, char *attr, char *dest, size_t l) { - sd_device *parent, *dev = event->dev->device; + sd_device *parent, *dev = event->dev; const char *val = NULL; char *s = dest; dev_t devnum; @@ -406,9 +406,9 @@ subst: subst_len = subst_format_var(event, entry, attr, s, l); if (subst_len < 0) { if (format_dollar) - log_device_warning_errno(event->dev->device, subst_len, "Failed to substitute variable '$%s', ignoring: %m", entry->name); + log_device_warning_errno(event->dev, subst_len, "Failed to substitute variable '$%s', ignoring: %m", entry->name); else - log_device_warning_errno(event->dev->device, subst_len, "Failed to apply format '%%%c', ignoring: %m", entry->fmt); + log_device_warning_errno(event->dev, subst_len, "Failed to apply format '%%%c', ignoring: %m", entry->fmt); continue; } @@ -640,9 +640,9 @@ int udev_event_spawn(struct udev_event *event, free_and_replace(argv[0], program); } - r = device_get_properties_strv(event->dev->device, &envp); + r = device_get_properties_strv(event->dev, &envp); if (r < 0) - return log_device_error_errno(event->dev->device, r, "Failed to get device properties"); + return log_device_error_errno(event->dev, r, "Failed to get device properties"); log_debug("Starting '%s'", cmd); @@ -686,7 +686,7 @@ int udev_event_spawn(struct udev_event *event, } static int rename_netif(struct udev_event *event) { - sd_device *dev = event->dev->device; + sd_device *dev = event->dev; const char *action, *oldname; char name[IFNAMSIZ]; int ifindex, r; @@ -729,7 +729,7 @@ static int rename_netif(struct udev_event *event) { } static int update_devnode(struct udev_event *event) { - sd_device *dev = event->dev->device; + sd_device *dev = event->dev; const char *action; bool apply; int r; @@ -784,7 +784,7 @@ static void event_execute_rules_on_remove( Hashmap *properties_list, struct udev_rules *rules) { - sd_device *dev = event->dev->device; + sd_device *dev = event->dev; int r; r = device_read_db_force(dev); @@ -814,7 +814,7 @@ int udev_event_execute_rules(struct udev_event *event, usec_t timeout_usec, usec_t timeout_warn_usec, Hashmap *properties_list, struct udev_rules *rules) { - sd_device *dev = event->dev->device; + sd_device *dev = event->dev; const char *subsystem, *action; int r; @@ -894,7 +894,7 @@ void udev_event_execute_run(struct udev_event *event, usec_t timeout_usec, usec_ udev_event_apply_format(event, cmd, command, sizeof(command), false); if (builtin_cmd >= 0 && builtin_cmd < _UDEV_BUILTIN_MAX) - udev_builtin_run(event->dev->device, builtin_cmd, command, false); + udev_builtin_run(event->dev, builtin_cmd, command, false); else { if (event->exec_delay > 0) { log_debug("delay execution of '%s'", command); diff --git a/src/udev/udev-rules.c b/src/udev/udev-rules.c index 11104d62d0..ad4b32abea 100644 --- a/src/udev/udev-rules.c +++ b/src/udev/udev-rules.c @@ -24,7 +24,7 @@ #include "fileio.h" #include "fs-util.h" #include "glob-util.h" -#include "libudev-device-internal.h" +#include "libudev-private.h" #include "path-util.h" #include "proc-cmdline.h" #include "stat-util.h" @@ -659,7 +659,7 @@ static int import_program_into_properties(struct udev_event *event, pos[0] = '\0'; pos = &pos[1]; } - (void) import_property_from_string(event->dev->device, line); + (void) import_property_from_string(event->dev, line); line = pos; } return 0; @@ -1727,7 +1727,7 @@ int udev_rules_apply_to_event( usec_t timeout_usec, usec_t timeout_warn_usec, Hashmap *properties_list) { - sd_device *dev = event->dev->device; + sd_device *dev = event->dev; enum escape_type esc = ESCAPE_UNSET; struct token *cur, *rule; const char *action, *val; diff --git a/src/udev/udev.h b/src/udev/udev.h index 85fcdc439f..162859ab40 100644 --- a/src/udev/udev.h +++ b/src/udev/udev.h @@ -9,7 +9,6 @@ #include #include -#include "libudev.h" #include "sd-device.h" #include "sd-netlink.h" @@ -21,7 +20,7 @@ #include "util.h" struct udev_event { - struct udev_device *dev; + sd_device *dev; sd_device *dev_parent; sd_device *dev_db_clone; char *name; @@ -60,7 +59,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event int udev_rules_apply_static_dev_perms(struct udev_rules *rules); /* udev-event.c */ -struct udev_event *udev_event_new(struct udev_device *dev, int exec_delay, sd_netlink *rtnl); +struct udev_event *udev_event_new(sd_device *dev, int exec_delay, sd_netlink *rtnl); struct udev_event *udev_event_free(struct udev_event *event); ssize_t udev_event_apply_format(struct udev_event *event, const char *src, char *dest, size_t size, diff --git a/src/udev/udevadm-test.c b/src/udev/udevadm-test.c index ec3d8460e8..002c390c4e 100644 --- a/src/udev/udevadm-test.c +++ b/src/udev/udevadm-test.c @@ -12,6 +12,7 @@ #include #include +#include "libudev-device-internal.h" #include "string-util.h" #include "udev-builtin.h" #include "udev.h" @@ -128,7 +129,7 @@ int test_main(int argc, char *argv[], void *userdata) { /* don't read info from the db */ udev_device_set_info_loaded(dev); - event = udev_event_new(dev, 0, NULL); + event = udev_event_new(dev->device, 0, NULL); sigfillset(&mask); sigprocmask(SIG_SETMASK, &mask, &sigmask_orig); diff --git a/src/udev/udevd.c b/src/udev/udevd.c index efab86b413..0757628d0d 100644 --- a/src/udev/udevd.c +++ b/src/udev/udevd.c @@ -342,7 +342,7 @@ static void worker_spawn(Manager *manager, struct event *event) { pid = fork(); switch (pid) { case 0: { - struct udev_device *dev = NULL; + _cleanup_(udev_device_unrefp) struct udev_device *dev = NULL; _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL; int fd_monitor; _cleanup_close_ int fd_signal = -1, fd_ep = -1; @@ -409,7 +409,7 @@ static void worker_spawn(Manager *manager, struct event *event) { assert(dev); log_debug("seq %llu running", udev_device_get_seqnum(dev)); - udev_event = udev_event_new(dev, arg_exec_delay, rtnl); + udev_event = udev_event_new(dev->device, arg_exec_delay, rtnl); if (!udev_event) { r = -ENOMEM; goto out; @@ -473,8 +473,7 @@ skip: log_error_errno(r, "failed to send result of seq %llu to main daemon: %m", udev_device_get_seqnum(dev)); - udev_device_unref(dev); - dev = NULL; + dev = udev_device_unref(dev); /* wait for more device messages from main udevd, or term signal */ while (dev == NULL) { From 77ad202c72b991d35f9a943601884be77772b795 Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:52:39 +0900 Subject: [PATCH 14/15] udevadm-test: replace udev_device by sd_device --- src/udev/udevadm-test.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/src/udev/udevadm-test.c b/src/udev/udevadm-test.c index 002c390c4e..cfaaf03db9 100644 --- a/src/udev/udevadm-test.c +++ b/src/udev/udevadm-test.c @@ -12,7 +12,10 @@ #include #include -#include "libudev-device-internal.h" +#include "sd-device.h" + +#include "device-private.h" +#include "device-util.h" #include "string-util.h" #include "udev-builtin.h" #include "udev.h" @@ -89,11 +92,10 @@ static int parse_argv(int argc, char *argv[]) { int test_main(int argc, char *argv[], void *userdata) { _cleanup_(udev_rules_unrefp) struct udev_rules *rules = NULL; - _cleanup_(udev_device_unrefp) struct udev_device *dev = NULL; _cleanup_(udev_event_freep) struct udev_event *event = NULL; - struct udev_list_entry *entry; + _cleanup_(sd_device_unrefp) sd_device *dev = NULL; + const char *cmd, *key, *value; sigset_t mask, sigmask_orig; - const char *cmd; Iterator i; void *val; int r; @@ -120,16 +122,16 @@ int test_main(int argc, char *argv[], void *userdata) { goto out; } - dev = udev_device_new_from_synthetic_event(NULL, arg_syspath, arg_action); - if (dev == NULL) { - r = log_error_errno(errno, "Failed to open device '%s': %m", arg_syspath); + r = device_new_from_synthetic_event(&dev, arg_syspath, arg_action); + if (r < 0) { + log_error_errno(r, "Failed to open device '%s': %m", arg_syspath); goto out; } /* don't read info from the db */ - udev_device_set_info_loaded(dev); + device_seal(dev); - event = udev_event_new(dev->device, 0, NULL); + event = udev_event_new(dev, 0, NULL); sigfillset(&mask); sigprocmask(SIG_SETMASK, &mask, &sigmask_orig); @@ -139,8 +141,8 @@ int test_main(int argc, char *argv[], void *userdata) { NULL, rules); - udev_list_entry_foreach(entry, udev_device_get_properties_list_entry(dev)) - printf("%s=%s\n", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry)); + FOREACH_DEVICE_PROPERTY(dev, key, value) + printf("%s=%s\n", key, value); HASHMAP_FOREACH_KEY(val, cmd, event->run_list, i) { char program[UTIL_PATH_SIZE]; From b74a0b6ae70de510f32359ae737ca1a50cf328ff Mon Sep 17 00:00:00 2001 From: Yu Watanabe Date: Thu, 1 Nov 2018 22:58:42 +0900 Subject: [PATCH 15/15] test: replace udev_device by sd_device in test-udev --- src/test/test-udev.c | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/src/test/test-udev.c b/src/test/test-udev.c index 5c85e92fa7..e972b56b2c 100644 --- a/src/test/test-udev.c +++ b/src/test/test-udev.c @@ -11,8 +11,8 @@ #include #include +#include "device-private.h" #include "fs-util.h" -#include "libudev-device-internal.h" #include "log.h" #include "missing.h" #include "selinux-util.h" @@ -53,10 +53,11 @@ static int fake_filesystems(void) { } int main(int argc, char *argv[]) { - _cleanup_(udev_event_freep) struct udev_event *event = NULL; - _cleanup_(udev_device_unrefp) struct udev_device *dev = NULL; _cleanup_(udev_rules_unrefp) struct udev_rules *rules = NULL; - const char *devpath, *action; + _cleanup_(udev_event_freep) struct udev_event *event = NULL; + _cleanup_(sd_device_unrefp) sd_device *dev = NULL; + const char *devpath, *devname, *action; + int r; test_setup_logging(LOG_INFO); @@ -77,31 +78,35 @@ int main(int argc, char *argv[]) { rules = udev_rules_new(1); const char *syspath = strjoina("/sys", devpath); - dev = udev_device_new_from_synthetic_event(NULL, syspath, action); - if (!dev) { - log_debug("unknown device '%s'", devpath); + r = device_new_from_synthetic_event(&dev, syspath, action); + if (r < 0) { + log_debug_errno(r, "Failed to open device '%s'", devpath); goto out; } - assert_se(event = udev_event_new(dev->device, 0, NULL)); + assert_se(event = udev_event_new(dev, 0, NULL)); assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGHUP, SIGCHLD, -1) >= 0); /* do what devtmpfs usually provides us */ - if (udev_device_get_devnode(dev)) { + if (sd_device_get_devname(dev, &devname) >= 0) { + const char *subsystem; mode_t mode = 0600; - if (streq(udev_device_get_subsystem(dev), "block")) + if (sd_device_get_subsystem(dev, &subsystem) >= 0 && streq(subsystem, "block")) mode |= S_IFBLK; else mode |= S_IFCHR; if (!streq(action, "remove")) { - (void) mkdir_parents_label(udev_device_get_devnode(dev), 0755); - assert_se(mknod(udev_device_get_devnode(dev), mode, udev_device_get_devnum(dev)) == 0); + dev_t devnum = makedev(0, 0); + + (void) mkdir_parents_label(devname, 0755); + (void) sd_device_get_devnum(dev, &devnum); + assert_se(mknod(devname, mode, devnum) == 0); } else { - assert_se(unlink(udev_device_get_devnode(dev)) == 0); - (void) rmdir_parents(udev_device_get_devnode(dev), "/"); + assert_se(unlink(devname) == 0); + (void) rmdir_parents(devname, "/"); } }