2 This file is part of systemd.
4 Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
5 Copyright 2014-2015 Tom Gundersen <teg@jklm.no>
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
26 #include "sd-device.h"
28 #include "device-util.h"
29 #include "device-enumerator-private.h"
31 #define DEVICE_ENUMERATE_MAX_DEPTH 256
33 typedef enum DeviceEnumerationType {
34 DEVICE_ENUMERATION_TYPE_DEVICES,
35 DEVICE_ENUMERATION_TYPE_SUBSYSTEMS,
36 _DEVICE_ENUMERATION_TYPE_MAX,
37 _DEVICE_ENUMERATION_TYPE_INVALID = -1,
38 } DeviceEnumerationType;
40 struct sd_device_enumerator {
43 DeviceEnumerationType type;
48 Set *nomatch_subsystem;
49 Hashmap *match_sysattr;
50 Hashmap *nomatch_sysattr;
51 Hashmap *match_property;
54 sd_device *match_parent;
55 bool match_allow_uninitialized;
58 _public_ int sd_device_enumerator_new(sd_device_enumerator **ret) {
59 _cleanup_device_enumerator_unref_ sd_device_enumerator *enumerator = NULL;
63 enumerator = new0(sd_device_enumerator, 1);
67 enumerator->n_ref = 1;
68 enumerator->type = _DEVICE_ENUMERATION_TYPE_INVALID;
76 _public_ sd_device_enumerator *sd_device_enumerator_ref(sd_device_enumerator *enumerator) {
77 assert_return(enumerator, NULL);
79 assert_se((++ enumerator->n_ref) >= 2);
84 _public_ sd_device_enumerator *sd_device_enumerator_unref(sd_device_enumerator *enumerator) {
85 if (enumerator && (-- enumerator->n_ref) == 0) {
88 while ((device = prioq_pop(enumerator->devices)))
89 sd_device_unref(device);
91 prioq_free(enumerator->devices);
93 set_free_free(enumerator->match_subsystem);
94 set_free_free(enumerator->nomatch_subsystem);
95 hashmap_free_free_free(enumerator->match_sysattr);
96 hashmap_free_free_free(enumerator->nomatch_sysattr);
97 hashmap_free_free_free(enumerator->match_property);
98 set_free_free(enumerator->match_sysname);
99 set_free_free(enumerator->match_tag);
100 sd_device_unref(enumerator->match_parent);
108 _public_ int sd_device_enumerator_add_match_subsystem(sd_device_enumerator *enumerator, const char *subsystem, int match) {
112 assert_return(enumerator, -EINVAL);
113 assert_return(subsystem, -EINVAL);
116 set = &enumerator->match_subsystem;
118 set = &enumerator->nomatch_subsystem;
120 r = set_ensure_allocated(set, NULL);
124 r = set_put_strdup(*set, subsystem);
128 enumerator->scan_uptodate = false;
133 _public_ int sd_device_enumerator_add_match_sysattr(sd_device_enumerator *enumerator, const char *_sysattr, const char *_value, int match) {
134 _cleanup_free_ char *sysattr = NULL, *value = NULL;
138 assert_return(enumerator, -EINVAL);
139 assert_return(_sysattr, -EINVAL);
140 assert_return(_value, -EINVAL);
143 hashmap = &enumerator->match_sysattr;
145 hashmap = &enumerator->nomatch_sysattr;
147 r = hashmap_ensure_allocated(hashmap, NULL);
151 sysattr = strdup(_sysattr);
155 value = strdup(_value);
159 r = hashmap_put(*hashmap, sysattr, value);
166 enumerator->scan_uptodate = false;
171 _public_ int sd_device_enumerator_add_match_property(sd_device_enumerator *enumerator, const char *_property, const char *_value) {
172 _cleanup_free_ char *property = NULL, *value = NULL;
175 assert_return(enumerator, -EINVAL);
176 assert_return(_property, -EINVAL);
177 assert_return(_value, -EINVAL);
179 r = hashmap_ensure_allocated(&enumerator->match_property, NULL);
183 property = strdup(_property);
187 value = strdup(_value);
191 r = hashmap_put(enumerator->match_property, property, value);
198 enumerator->scan_uptodate = false;
203 _public_ int sd_device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
206 assert_return(enumerator, -EINVAL);
207 assert_return(sysname, -EINVAL);
209 r = set_ensure_allocated(&enumerator->match_sysname, NULL);
213 r = set_put_strdup(enumerator->match_sysname, sysname);
217 enumerator->scan_uptodate = false;
222 _public_ int sd_device_enumerator_add_match_tag(sd_device_enumerator *enumerator, const char *tag) {
225 assert_return(enumerator, -EINVAL);
226 assert_return(tag, -EINVAL);
228 r = set_ensure_allocated(&enumerator->match_tag, NULL);
232 r = set_put_strdup(enumerator->match_tag, tag);
236 enumerator->scan_uptodate = false;
241 _public_ int sd_device_enumerator_add_match_parent(sd_device_enumerator *enumerator, sd_device *parent) {
242 assert_return(enumerator, -EINVAL);
243 assert_return(parent, -EINVAL);
245 sd_device_unref(enumerator->match_parent);
246 enumerator->match_parent = sd_device_ref(parent);
248 enumerator->scan_uptodate = false;
253 _public_ int sd_device_enumerator_allow_uninitialized(sd_device_enumerator *enumerator) {
254 assert_return(enumerator, -EINVAL);
256 enumerator->match_allow_uninitialized = true;
258 enumerator->scan_uptodate = false;
263 int device_enumerator_add_match_is_initialized(sd_device_enumerator *enumerator) {
264 assert_return(enumerator, -EINVAL);
266 enumerator->match_allow_uninitialized = false;
268 enumerator->scan_uptodate = false;
273 static int device_compare(const void *_a, const void *_b) {
274 sd_device *a = (sd_device *)_a, *b = (sd_device *)_b;
275 const char *devpath_a, *devpath_b, *sound_a;
276 bool delay_a = false, delay_b = false;
278 assert_se(sd_device_get_devpath(a, &devpath_a) >= 0);
279 assert_se(sd_device_get_devpath(b, &devpath_b) >= 0);
281 sound_a = strstr(devpath_a, "/sound/card");
283 /* For sound cards the control device must be enumerated last to
284 * make sure it's the final device node that gets ACLs applied.
285 * Applications rely on this fact and use ACL changes on the
286 * control node as an indicator that the ACL change of the
287 * entire sound card completed. The kernel makes this guarantee
288 * when creating those devices, and hence we should too when
289 * enumerating them. */
290 sound_a += strlen("/sound/card");
291 sound_a = strchr(sound_a, '/');
296 prefix_len = sound_a - devpath_a;
298 if (strncmp(devpath_a, devpath_b, prefix_len) == 0) {
301 sound_b = devpath_b + prefix_len;
303 if (startswith(sound_a, "/controlC") &&
304 !startswith(sound_b, "/contolC"))
307 if (!startswith(sound_a, "/controlC") &&
308 startswith(sound_b, "/controlC"))
314 /* md and dm devices are enumerated after all other devices */
315 if (strstr(devpath_a, "/block/md") || strstr(devpath_a, "/block/dm-"))
318 if (strstr(devpath_b, "/block/md") || strstr(devpath_b, "/block/dm-"))
321 if (delay_a && !delay_b)
324 if (!delay_a && delay_b)
327 return strcmp(devpath_a, devpath_b);
330 int device_enumerator_add_device(sd_device_enumerator *enumerator, sd_device *device) {
333 assert_return(enumerator, -EINVAL);
334 assert_return(device, -EINVAL);
336 r = prioq_ensure_allocated(&enumerator->devices, device_compare);
340 r = prioq_put(enumerator->devices, device, NULL);
344 sd_device_ref(device);
349 static bool match_sysattr_value(sd_device *device, const char *sysattr, const char *match_value) {
356 r = sd_device_get_sysattr_value(device, sysattr, &value);
363 if (fnmatch(match_value, value, 0) == 0)
369 static bool match_sysattr(sd_device_enumerator *enumerator, sd_device *device) {
377 HASHMAP_FOREACH_KEY(value, sysattr, enumerator->nomatch_sysattr, i)
378 if (match_sysattr_value(device, sysattr, value))
381 HASHMAP_FOREACH_KEY(value, sysattr, enumerator->match_sysattr, i)
382 if (!match_sysattr_value(device, sysattr, value))
388 static bool match_property(sd_device_enumerator *enumerator, sd_device *device) {
389 const char *property;
396 if (hashmap_isempty(enumerator->match_property))
399 HASHMAP_FOREACH_KEY(value, property, enumerator->match_property, i) {
400 const char *property_dev, *value_dev;
402 FOREACH_DEVICE_PROPERTY(device, property_dev, value_dev) {
403 if (fnmatch(property, property_dev, 0) != 0)
406 if (!value && !value_dev)
409 if (!value || !value_dev)
412 if (fnmatch(value, value_dev, 0) == 0)
420 static bool match_tag(sd_device_enumerator *enumerator, sd_device *device) {
427 SET_FOREACH(tag, enumerator->match_tag, i)
428 if (!sd_device_has_tag(device, tag))
434 static bool match_parent(sd_device_enumerator *enumerator, sd_device *device) {
435 const char *devpath, *devpath_dev;
441 if (!enumerator->match_parent)
444 r = sd_device_get_devpath(enumerator->match_parent, &devpath);
447 r = sd_device_get_devpath(device, &devpath_dev);
450 return startswith(devpath_dev, devpath);
453 static bool match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
454 const char *sysname_match;
460 if (set_isempty(enumerator->match_sysname))
463 SET_FOREACH(sysname_match, enumerator->match_sysname, i)
464 if (fnmatch(sysname_match, sysname, 0) == 0)
470 static int enumerator_scan_dir_and_add_devices(sd_device_enumerator *enumerator, const char *basedir, const char *subdir1, const char *subdir2) {
471 _cleanup_closedir_ DIR *dir = NULL;
479 path = strjoina("/sys/", basedir, "/");
482 path = strjoina(path, subdir1, "/");
485 path = strjoina(path, subdir2, "/");
491 FOREACH_DIRENT_ALL(dent, dir, return -errno) {
492 _cleanup_device_unref_ sd_device *device = NULL;
493 char syspath[strlen(path) + 1 + strlen(dent->d_name) + 1];
495 int ifindex, initialized, k;
497 if (dent->d_name[0] == '.')
500 if (!match_sysname(enumerator, dent->d_name))
503 (void)sprintf(syspath, "%s%s", path, dent->d_name);
505 k = sd_device_new_from_syspath(&device, syspath);
508 /* this is necessarily racey, so ignore missing devices */
514 k = sd_device_get_devnum(device, &devnum);
520 k = sd_device_get_ifindex(device, &ifindex);
526 k = sd_device_get_is_initialized(device, &initialized);
533 * All devices with a device node or network interfaces
534 * possibly need udev to adjust the device node permission
535 * or context, or rename the interface before it can be
536 * reliably used from other processes.
538 * For now, we can only check these types of devices, we
539 * might not store a database, and have no way to find out
540 * for all other types of devices.
542 if (!enumerator->match_allow_uninitialized &&
544 (major(devnum) > 0 || ifindex > 0))
547 if (!match_parent(enumerator, device))
550 if (!match_tag(enumerator, device))
553 if (!match_property(enumerator, device))
556 if (!match_sysattr(enumerator, device))
559 k = device_enumerator_add_device(enumerator, device);
567 static bool match_subsystem(sd_device_enumerator *enumerator, const char *subsystem) {
568 const char *subsystem_match;
576 SET_FOREACH(subsystem_match, enumerator->nomatch_subsystem, i)
577 if (fnmatch(subsystem_match, subsystem, 0) == 0)
580 if (set_isempty(enumerator->match_subsystem))
583 SET_FOREACH(subsystem_match, enumerator->match_subsystem, i)
584 if (fnmatch(subsystem_match, subsystem, 0) == 0)
590 static int enumerator_scan_dir(sd_device_enumerator *enumerator, const char *basedir, const char *subdir, const char *subsystem) {
591 _cleanup_closedir_ DIR *dir = NULL;
596 path = strjoina("/sys/", basedir);
602 log_debug(" device-enumerator: scanning %s", path);
604 FOREACH_DIRENT_ALL(dent, dir, return -errno) {
607 if (dent->d_name[0] == '.')
610 if (!match_subsystem(enumerator, subsystem ? : dent->d_name))
613 k = enumerator_scan_dir_and_add_devices(enumerator, basedir, dent->d_name, subdir);
621 static int enumerator_scan_devices_tag(sd_device_enumerator *enumerator, const char *tag) {
622 _cleanup_closedir_ DIR *dir = NULL;
630 path = strjoina("/run/udev/tags/", tag);
637 log_error("sd-device-enumerator: could not open tags directory %s: %m", path);
642 /* TODO: filter away subsystems? */
644 FOREACH_DIRENT_ALL(dent, dir, return -errno) {
645 _cleanup_device_unref_ sd_device *device = NULL;
646 const char *subsystem, *sysname;
649 if (dent->d_name[0] == '.')
652 k = sd_device_new_from_device_id(&device, dent->d_name);
655 /* this is necessarily racy, so ignore missing devices */
661 k = sd_device_get_subsystem(device, &subsystem);
667 if (!match_subsystem(enumerator, subsystem))
670 k = sd_device_get_sysname(device, &sysname);
676 if (!match_sysname(enumerator, sysname))
679 if (!match_parent(enumerator, device))
682 if (!match_property(enumerator, device))
685 if (!match_sysattr(enumerator, device))
688 k = device_enumerator_add_device(enumerator, device);
698 static int enumerator_scan_devices_tags(sd_device_enumerator *enumerator) {
705 SET_FOREACH(tag, enumerator->match_tag, i) {
706 r = enumerator_scan_devices_tag(enumerator, tag);
714 static int parent_add_child(sd_device_enumerator *enumerator, const char *path) {
715 _cleanup_device_unref_ sd_device *device = NULL;
716 const char *subsystem, *sysname;
719 r = sd_device_new_from_syspath(&device, path);
721 /* this is necessarily racy, so ignore missing devices */
726 r = sd_device_get_subsystem(device, &subsystem);
730 if (!match_subsystem(enumerator, subsystem))
733 r = sd_device_get_sysname(device, &sysname);
737 if (!match_sysname(enumerator, sysname))
740 if (!match_property(enumerator, device))
743 if (!match_sysattr(enumerator, device))
746 r = device_enumerator_add_device(enumerator, device);
753 static int parent_crawl_children(sd_device_enumerator *enumerator, const char *path, unsigned maxdepth) {
754 _cleanup_closedir_ DIR *dir = NULL;
760 log_debug("sd-device-enumerate: could not open parent directory %s: %m", path);
764 FOREACH_DIRENT_ALL(dent, dir, return -errno) {
765 _cleanup_free_ char *child = NULL;
768 if (dent->d_name[0] == '.')
771 if (dent->d_type != DT_DIR)
774 child = strjoin(path, "/", dent->d_name, NULL);
778 k = parent_add_child(enumerator, child);
783 parent_crawl_children(enumerator, child, maxdepth - 1);
785 log_debug("device-enumerate: max depth reached, %s: ignoring devices", child);
791 static int enumerator_scan_devices_children(sd_device_enumerator *enumerator) {
795 r = sd_device_get_syspath(enumerator->match_parent, &path);
799 k = parent_add_child(enumerator, path);
803 k = parent_crawl_children(enumerator, path, DEVICE_ENUMERATE_MAX_DEPTH);
810 static int enumerator_scan_devices_all(sd_device_enumerator *enumerator) {
813 log_debug("device-enumerator: scan all dirs");
815 if (access("/sys/subsystem", F_OK) >= 0) {
816 /* we have /subsystem/, forget all the old stuff */
817 r = enumerator_scan_dir(enumerator, "subsystem", "devices", NULL);
819 log_debug("device-enumerator: failed to scan /sys/subsystem: %s", strerror(-r));
825 k = enumerator_scan_dir(enumerator, "bus", "devices", NULL);
827 log_debug_errno(k, "device-enumerator: failed to scan /sys/bus: %m");
831 k = enumerator_scan_dir(enumerator, "class", NULL, NULL);
833 log_debug_errno(k, "device-enumerator: failed to scan /sys/class: %m");
841 int device_enumerator_scan_devices(sd_device_enumerator *enumerator) {
847 if (enumerator->scan_uptodate &&
848 enumerator->type == DEVICE_ENUMERATION_TYPE_DEVICES)
851 while ((device = prioq_pop(enumerator->devices)))
852 sd_device_unref(device);
854 if (!set_isempty(enumerator->match_tag)) {
855 r = enumerator_scan_devices_tags(enumerator);
858 } else if (enumerator->match_parent) {
859 r = enumerator_scan_devices_children(enumerator);
863 r = enumerator_scan_devices_all(enumerator);
868 enumerator->scan_uptodate = true;
873 _public_ sd_device *sd_device_enumerator_get_device_first(sd_device_enumerator *enumerator) {
876 assert_return(enumerator, NULL);
878 r = device_enumerator_scan_devices(enumerator);
882 enumerator->type = DEVICE_ENUMERATION_TYPE_DEVICES;
884 return prioq_peek(enumerator->devices);
887 _public_ sd_device *sd_device_enumerator_get_device_next(sd_device_enumerator *enumerator) {
888 assert_return(enumerator, NULL);
890 if (!enumerator->scan_uptodate ||
891 enumerator->type != DEVICE_ENUMERATION_TYPE_DEVICES)
894 sd_device_unref(prioq_pop(enumerator->devices));
896 return prioq_peek(enumerator->devices);
899 int device_enumerator_scan_subsystems(sd_device_enumerator *enumerator) {
901 const char *subsysdir;
906 if (enumerator->scan_uptodate &&
907 enumerator->type == DEVICE_ENUMERATION_TYPE_SUBSYSTEMS)
910 while ((device = prioq_pop(enumerator->devices)))
911 sd_device_unref(device);
914 if (match_subsystem(enumerator, "module")) {
915 k = enumerator_scan_dir_and_add_devices(enumerator, "module", NULL, NULL);
917 log_debug_errno(k, "device-enumerator: failed to scan modules: %m");
922 if (access("/sys/subsystem", F_OK) >= 0)
923 subsysdir = "subsystem";
927 /* subsystems (only buses support coldplug) */
928 if (match_subsystem(enumerator, "subsystem")) {
929 k = enumerator_scan_dir_and_add_devices(enumerator, subsysdir, NULL, NULL);
931 log_debug_errno(k, "device-enumerator: failed to scan subsystems: %m");
936 /* subsystem drivers */
937 if (match_subsystem(enumerator, "drivers")) {
938 k = enumerator_scan_dir(enumerator, subsysdir, "drivers", "drivers");
940 log_debug_errno(k, "device-enumerator: failed to scan drivers: %m");
945 enumerator->scan_uptodate = true;
950 _public_ sd_device *sd_device_enumerator_get_subsystem_first(sd_device_enumerator *enumerator) {
953 assert_return(enumerator, NULL);
955 r = device_enumerator_scan_subsystems(enumerator);
959 enumerator->type = DEVICE_ENUMERATION_TYPE_SUBSYSTEMS;
961 return prioq_peek(enumerator->devices);
964 _public_ sd_device *sd_device_enumerator_get_subsystem_next(sd_device_enumerator *enumerator) {
965 assert_return(enumerator, NULL);
967 if (enumerator->scan_uptodate ||
968 enumerator->type != DEVICE_ENUMERATION_TYPE_SUBSYSTEMS)
971 sd_device_unref(prioq_pop(enumerator->devices));
973 return prioq_peek(enumerator->devices);
976 sd_device *device_enumerator_get_first(sd_device_enumerator *enumerator) {
977 assert_return(enumerator, NULL);
979 return prioq_peek(enumerator->devices);
982 sd_device *device_enumerator_get_next(sd_device_enumerator *enumerator) {
983 assert_return(enumerator, NULL);
985 sd_device_unref(prioq_pop(enumerator->devices));
987 return prioq_peek(enumerator->devices);