]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/libsystemd/sd-device/device-enumerator.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
man: improve Description= documentation (#38101)
[thirdparty/systemd.git] / src / libsystemd / sd-device / device-enumerator.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include <fnmatch.h>
4
5#include "sd-device.h"
6
7#include "alloc-util.h"
8#include "device-enumerator-private.h"
9#include "device-filter.h"
10#include "device-util.h"
11#include "dirent-util.h"
12#include "fd-util.h"
13#include "log.h"
14#include "path-util.h"
15#include "set.h"
16#include "sort-util.h"
17#include "string-util.h"
18#include "strv.h"
19
20typedef enum DeviceEnumerationType {
21 DEVICE_ENUMERATION_TYPE_DEVICES,
22 DEVICE_ENUMERATION_TYPE_SUBSYSTEMS,
23 DEVICE_ENUMERATION_TYPE_ALL,
24 _DEVICE_ENUMERATION_TYPE_MAX,
25 _DEVICE_ENUMERATION_TYPE_INVALID = -EINVAL,
26} DeviceEnumerationType;
27
28typedef enum MatchFlag {
29 MATCH_NONE = 0,
30 MATCH_BASIC = 1u << 0,
31 MATCH_SYSNAME = 1u << 1,
32 MATCH_SUBSYSTEM = 1u << 2,
33 MATCH_PARENT = 1u << 3,
34 MATCH_TAG = 1u << 4,
35
36 MATCH_ALL = (1u << 5) - 1,
37} MatchFlag;
38
39struct sd_device_enumerator {
40 unsigned n_ref;
41
42 DeviceEnumerationType type;
43 Hashmap *devices_by_syspath;
44 sd_device **devices;
45 size_t n_devices, current_device_index;
46 bool scan_uptodate;
47 bool sorted;
48
49 char **prioritized_subsystems;
50 Set *match_subsystem;
51 Set *nomatch_subsystem;
52 Hashmap *match_sysattr;
53 Hashmap *nomatch_sysattr;
54 Hashmap *match_property;
55 Hashmap *match_property_required;
56 Set *match_sysname;
57 Set *nomatch_sysname;
58 Set *match_tag;
59 Set *match_parent;
60 MatchInitializedType match_initialized;
61 MatchFlag parent_match_flags;
62};
63
64_public_ int sd_device_enumerator_new(sd_device_enumerator **ret) {
65 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *enumerator = NULL;
66
67 assert(ret);
68
69 enumerator = new(sd_device_enumerator, 1);
70 if (!enumerator)
71 return -ENOMEM;
72
73 *enumerator = (sd_device_enumerator) {
74 .n_ref = 1,
75 .type = _DEVICE_ENUMERATION_TYPE_INVALID,
76 .match_initialized = MATCH_INITIALIZED_COMPAT,
77 .parent_match_flags = MATCH_ALL,
78 };
79
80 *ret = TAKE_PTR(enumerator);
81
82 return 0;
83}
84
85static void device_unref_many(sd_device **devices, size_t n) {
86 assert(devices || n == 0);
87
88 for (size_t i = 0; i < n; i++)
89 sd_device_unref(devices[i]);
90}
91
92static void device_enumerator_unref_devices(sd_device_enumerator *enumerator) {
93 assert(enumerator);
94
95 hashmap_clear(enumerator->devices_by_syspath);
96 device_unref_many(enumerator->devices, enumerator->n_devices);
97 enumerator->devices = mfree(enumerator->devices);
98 enumerator->n_devices = 0;
99}
100
101static sd_device_enumerator *device_enumerator_free(sd_device_enumerator *enumerator) {
102 assert(enumerator);
103
104 device_enumerator_unref_devices(enumerator);
105
106 hashmap_free(enumerator->devices_by_syspath);
107 strv_free(enumerator->prioritized_subsystems);
108 set_free(enumerator->match_subsystem);
109 set_free(enumerator->nomatch_subsystem);
110 hashmap_free(enumerator->match_sysattr);
111 hashmap_free(enumerator->nomatch_sysattr);
112 hashmap_free(enumerator->match_property);
113 hashmap_free(enumerator->match_property_required);
114 set_free(enumerator->match_sysname);
115 set_free(enumerator->nomatch_sysname);
116 set_free(enumerator->match_tag);
117 set_free(enumerator->match_parent);
118
119 return mfree(enumerator);
120}
121
122DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_device_enumerator, sd_device_enumerator, device_enumerator_free);
123
124int device_enumerator_add_prioritized_subsystem(sd_device_enumerator *enumerator, const char *subsystem) {
125 int r;
126
127 assert(enumerator);
128 assert(subsystem);
129
130 if (strv_contains(enumerator->prioritized_subsystems, subsystem))
131 return 0;
132
133 r = strv_extend(&enumerator->prioritized_subsystems, subsystem);
134 if (r < 0)
135 return r;
136
137 enumerator->scan_uptodate = false;
138
139 return 1;
140}
141
142_public_ int sd_device_enumerator_add_match_subsystem(sd_device_enumerator *enumerator, const char *subsystem, int match) {
143 Set **set;
144 int r;
145
146 assert_return(enumerator, -EINVAL);
147 assert_return(subsystem, -EINVAL);
148
149 if (match)
150 set = &enumerator->match_subsystem;
151 else
152 set = &enumerator->nomatch_subsystem;
153
154 r = set_put_strdup(set, subsystem);
155 if (r <= 0)
156 return r;
157
158 enumerator->scan_uptodate = false;
159
160 return 1;
161}
162
163_public_ int sd_device_enumerator_add_match_sysattr(sd_device_enumerator *enumerator, const char *sysattr, const char *value, int match) {
164 Hashmap **hashmap;
165 int r;
166
167 assert_return(enumerator, -EINVAL);
168 assert_return(sysattr, -EINVAL);
169
170 if (match)
171 hashmap = &enumerator->match_sysattr;
172 else
173 hashmap = &enumerator->nomatch_sysattr;
174
175 r = update_match_strv(hashmap, sysattr, value, /* clear_on_null = */ true);
176 if (r <= 0)
177 return r;
178
179 enumerator->scan_uptodate = false;
180
181 return 1;
182}
183
184_public_ int sd_device_enumerator_add_match_property(sd_device_enumerator *enumerator, const char *property, const char *value) {
185 int r;
186
187 assert_return(enumerator, -EINVAL);
188 assert_return(property, -EINVAL);
189
190 r = update_match_strv(&enumerator->match_property, property, value, /* clear_on_null = */ false);
191 if (r <= 0)
192 return r;
193
194 enumerator->scan_uptodate = false;
195
196 return 1;
197}
198
199_public_ int sd_device_enumerator_add_match_property_required(sd_device_enumerator *enumerator, const char *property, const char *value) {
200 int r;
201
202 assert_return(enumerator, -EINVAL);
203 assert_return(property, -EINVAL);
204
205 r = update_match_strv(&enumerator->match_property_required, property, value, /* clear_on_null = */ false);
206 if (r <= 0)
207 return r;
208
209 enumerator->scan_uptodate = false;
210
211 return 1;
212}
213
214static int device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname, bool match) {
215 int r;
216
217 assert_return(enumerator, -EINVAL);
218 assert_return(sysname, -EINVAL);
219
220 r = set_put_strdup(match ? &enumerator->match_sysname : &enumerator->nomatch_sysname, sysname);
221 if (r <= 0)
222 return r;
223
224 enumerator->scan_uptodate = false;
225
226 return 1;
227}
228
229_public_ int sd_device_enumerator_add_match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
230 return device_enumerator_add_match_sysname(enumerator, sysname, true);
231}
232
233_public_ int sd_device_enumerator_add_nomatch_sysname(sd_device_enumerator *enumerator, const char *sysname) {
234 return device_enumerator_add_match_sysname(enumerator, sysname, false);
235}
236
237_public_ int sd_device_enumerator_add_match_tag(sd_device_enumerator *enumerator, const char *tag) {
238 int r;
239
240 assert_return(enumerator, -EINVAL);
241 assert_return(tag, -EINVAL);
242
243 r = set_put_strdup(&enumerator->match_tag, tag);
244 if (r <= 0)
245 return r;
246
247 enumerator->scan_uptodate = false;
248
249 return 1;
250}
251
252int device_enumerator_add_match_parent_incremental(sd_device_enumerator *enumerator, sd_device *parent) {
253 const char *path;
254 int r;
255
256 assert(enumerator);
257 assert(parent);
258
259 r = sd_device_get_syspath(parent, &path);
260 if (r < 0)
261 return r;
262
263 r = set_put_strdup(&enumerator->match_parent, path);
264 if (r <= 0)
265 return r;
266
267 enumerator->scan_uptodate = false;
268
269 return 1;
270}
271
272_public_ int sd_device_enumerator_add_match_parent(sd_device_enumerator *enumerator, sd_device *parent) {
273 assert_return(enumerator, -EINVAL);
274 assert_return(parent, -EINVAL);
275
276 set_clear(enumerator->match_parent);
277
278 return device_enumerator_add_match_parent_incremental(enumerator, parent);
279}
280
281_public_ int sd_device_enumerator_allow_uninitialized(sd_device_enumerator *enumerator) {
282 assert_return(enumerator, -EINVAL);
283
284 enumerator->match_initialized = MATCH_INITIALIZED_ALL;
285
286 enumerator->scan_uptodate = false;
287
288 return 1;
289}
290_public_ int sd_device_enumerator_add_all_parents(sd_device_enumerator *enumerator) {
291 assert_return(enumerator, -EINVAL);
292
293 enumerator->parent_match_flags = MATCH_NONE;
294
295 enumerator->scan_uptodate = false;
296
297 return 1;
298}
299
300int device_enumerator_add_match_is_initialized(sd_device_enumerator *enumerator, MatchInitializedType type) {
301 assert_return(enumerator, -EINVAL);
302 assert_return(type >= 0 && type < _MATCH_INITIALIZED_MAX, -EINVAL);
303
304 enumerator->match_initialized = type;
305
306 enumerator->scan_uptodate = false;
307
308 return 1;
309}
310
311static int sound_device_compare(const char *devpath_a, const char *devpath_b) {
312 const char *sound_a, *sound_b;
313 size_t prefix_len;
314
315 assert(devpath_a);
316 assert(devpath_b);
317
318 /* For sound cards the control device must be enumerated last to make sure it's the final
319 * device node that gets ACLs applied. Applications rely on this fact and use ACL changes on
320 * the control node as an indicator that the ACL change of the entire sound card completed. The
321 * kernel makes this guarantee when creating those devices, and hence we should too when
322 * enumerating them. */
323
324 sound_a = strstrafter(devpath_a, "/sound/card");
325 if (!sound_a)
326 return 0;
327
328 sound_a = strchr(devpath_a, '/');
329 if (!sound_a)
330 return 0;
331
332 prefix_len = sound_a - devpath_a;
333
334 if (!strneq(devpath_a, devpath_b, prefix_len))
335 return 0;
336
337 sound_b = devpath_b + prefix_len;
338
339 return CMP(!!startswith(sound_a, "/controlC"),
340 !!startswith(sound_b, "/controlC"));
341}
342
343static bool devpath_is_late_block(const char *devpath) {
344 assert(devpath);
345
346 return strstr(devpath, "/block/md") || strstr(devpath, "/block/dm-");
347}
348
349static int device_compare(sd_device * const *a, sd_device * const *b) {
350 const char *devpath_a, *devpath_b;
351 int r;
352
353 assert(a);
354 assert(b);
355 assert(*a);
356 assert(*b);
357
358 assert_se(sd_device_get_devpath(*(sd_device**) a, &devpath_a) >= 0);
359 assert_se(sd_device_get_devpath(*(sd_device**) b, &devpath_b) >= 0);
360
361 r = sound_device_compare(devpath_a, devpath_b);
362 if (r != 0)
363 return r;
364
365 /* md and dm devices are enumerated after all other devices */
366 r = CMP(devpath_is_late_block(devpath_a), devpath_is_late_block(devpath_b));
367 if (r != 0)
368 return r;
369
370 return path_compare(devpath_a, devpath_b);
371}
372
373static int enumerator_sort_devices(sd_device_enumerator *enumerator) {
374 size_t n_sorted = 0, n = 0;
375 sd_device **devices;
376 sd_device *device;
377 int r;
378
379 assert(enumerator);
380
381 if (enumerator->sorted)
382 return 0;
383
384 devices = new(sd_device*, hashmap_size(enumerator->devices_by_syspath));
385 if (!devices)
386 return -ENOMEM;
387
388 STRV_FOREACH(prioritized_subsystem, enumerator->prioritized_subsystems) {
389
390 for (;;) {
391 const char *syspath;
392 size_t m = n;
393
394 HASHMAP_FOREACH_KEY(device, syspath, enumerator->devices_by_syspath) {
395 _cleanup_free_ char *p = NULL;
396
397 r = device_in_subsystem(device, *prioritized_subsystem);
398 if (r < 0)
399 return r;
400 if (r == 0)
401 continue;
402
403 devices[n++] = sd_device_ref(device);
404
405 for (;;) {
406 _cleanup_free_ char *q = NULL;
407
408 r = path_extract_directory(p ?: syspath, &q);
409 if (r == -EADDRNOTAVAIL)
410 break;
411 if (r < 0)
412 goto failed;
413
414 device = hashmap_get(enumerator->devices_by_syspath, q);
415 if (device)
416 devices[n++] = sd_device_ref(device);
417
418 free_and_replace(p, q);
419 }
420
421 break;
422 }
423
424 /* We cannot remove multiple entries in the loop HASHMAP_FOREACH_KEY() above. */
425 for (size_t i = m; i < n; i++) {
426 r = sd_device_get_syspath(devices[i], &syspath);
427 if (r < 0)
428 goto failed;
429
430 assert_se(hashmap_remove(enumerator->devices_by_syspath, syspath) == devices[i]);
431 sd_device_unref(devices[i]);
432 }
433
434 if (m == n)
435 break;
436 }
437
438 typesafe_qsort(devices + n_sorted, n - n_sorted, device_compare);
439 n_sorted = n;
440 }
441
442 HASHMAP_FOREACH(device, enumerator->devices_by_syspath)
443 devices[n++] = sd_device_ref(device);
444
445 /* Move all devices back to the hashmap. Otherwise, devices added by
446 * udev_enumerate_add_syspath() -> device_enumerator_add_device() may not be listed. */
447 for (size_t i = 0; i < n_sorted; i++) {
448 const char *syspath;
449
450 r = sd_device_get_syspath(devices[i], &syspath);
451 if (r < 0)
452 goto failed;
453
454 r = hashmap_put(enumerator->devices_by_syspath, syspath, devices[i]);
455 if (r < 0)
456 goto failed;
457 assert(r > 0);
458
459 sd_device_ref(devices[i]);
460 }
461
462 typesafe_qsort(devices + n_sorted, n - n_sorted, device_compare);
463
464 device_unref_many(enumerator->devices, enumerator->n_devices);
465
466 enumerator->n_devices = n;
467 free_and_replace(enumerator->devices, devices);
468
469 enumerator->sorted = true;
470 return 0;
471
472failed:
473 device_unref_many(devices, n);
474 free(devices);
475 return r;
476}
477
478DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
479 device_hash_ops_by_syspath,
480 char, path_hash_func, path_compare,
481 sd_device, sd_device_unref);
482
483int device_enumerator_add_device(sd_device_enumerator *enumerator, sd_device *device) {
484 const char *syspath;
485 int r;
486
487 assert_return(enumerator, -EINVAL);
488 assert_return(device, -EINVAL);
489
490 r = sd_device_get_syspath(device, &syspath);
491 if (r < 0)
492 return r;
493
494 r = hashmap_ensure_put(&enumerator->devices_by_syspath, &device_hash_ops_by_syspath, syspath, device);
495 if (IN_SET(r, -EEXIST, 0))
496 return 0;
497 if (r < 0)
498 return r;
499
500 sd_device_ref(device);
501
502 enumerator->sorted = false;
503 return 1;
504}
505
506static bool match_property(Hashmap *properties, sd_device *device, bool match_all) {
507 const char *property_pattern;
508 char * const *value_patterns;
509
510 assert(device);
511
512 /* Unlike device_match_sysattr(), this accepts device that has at least one matching property. */
513
514 if (hashmap_isempty(properties))
515 return true;
516
517 HASHMAP_FOREACH_KEY(value_patterns, property_pattern, properties) {
518 bool match = false;
519
520 FOREACH_DEVICE_PROPERTY(device, property, value) {
521 if (fnmatch(property_pattern, property, 0) != 0)
522 continue;
523
524 match = strv_fnmatch(value_patterns, value);
525 if (match) {
526 if (!match_all)
527 return true;
528
529 break;
530 }
531 }
532
533 if (!match && match_all)
534 return false;
535 }
536
537 return match_all;
538}
539
540static bool match_tag(sd_device_enumerator *enumerator, sd_device *device) {
541 const char *tag;
542
543 assert(enumerator);
544 assert(device);
545
546 SET_FOREACH(tag, enumerator->match_tag)
547 if (!sd_device_has_tag(device, tag))
548 return false;
549
550 return true;
551}
552
553static bool match_sysname(sd_device_enumerator *enumerator, const char *sysname) {
554 assert(enumerator);
555 assert(sysname);
556
557 return set_fnmatch(enumerator->match_sysname, enumerator->nomatch_sysname, sysname);
558}
559
560static int match_initialized(sd_device_enumerator *enumerator, sd_device *device) {
561 int r;
562
563 assert(enumerator);
564 assert(device);
565
566 if (enumerator->match_initialized == MATCH_INITIALIZED_ALL)
567 return true;
568
569 r = sd_device_get_is_initialized(device);
570 if (r == -ENOENT) /* this is necessarily racey, so ignore missing devices */
571 return false;
572 if (r < 0)
573 return r;
574
575 if (enumerator->match_initialized == MATCH_INITIALIZED_COMPAT) {
576 /* only devices that have no devnode/ifindex or have a db entry are accepted. */
577 if (r > 0)
578 return true;
579
580 if (sd_device_get_devnum(device, NULL) >= 0)
581 return false;
582
583 if (sd_device_get_ifindex(device, NULL) >= 0)
584 return false;
585
586 return true;
587 }
588
589 return (enumerator->match_initialized == MATCH_INITIALIZED_NO) == (r == 0);
590}
591
592static bool match_subsystem(sd_device_enumerator *enumerator, const char *subsystem) {
593 assert(enumerator);
594
595 if (!subsystem)
596 return false;
597
598 return set_fnmatch(enumerator->match_subsystem, enumerator->nomatch_subsystem, subsystem);
599}
600
601static int test_matches(
602 sd_device_enumerator *enumerator,
603 sd_device *device,
604 MatchFlag flags) {
605
606 int r;
607
608 assert(enumerator);
609 assert(device);
610
611 if (FLAGS_SET(flags, MATCH_SYSNAME)) {
612 const char *sysname;
613
614 r = sd_device_get_sysname(device, &sysname);
615 if (r < 0)
616 return r;
617
618 if (!match_sysname(enumerator, sysname))
619 return false;
620 }
621
622 if (FLAGS_SET(flags, MATCH_SUBSYSTEM)) {
623 const char *subsystem;
624
625 r = sd_device_get_subsystem(device, &subsystem);
626 if (r == -ENOENT)
627 return false;
628 if (r < 0)
629 return r;
630
631 if (!match_subsystem(enumerator, subsystem))
632 return false;
633 }
634
635 if (FLAGS_SET(flags, MATCH_PARENT) &&
636 !device_match_parent(device, enumerator->match_parent, NULL))
637 return false;
638
639 if (FLAGS_SET(flags, MATCH_TAG) &&
640 !match_tag(enumerator, device))
641 return false;
642
643 if (FLAGS_SET(flags, MATCH_BASIC)) {
644 r = match_initialized(enumerator, device);
645 if (r <= 0)
646 return r;
647
648 if (!match_property(enumerator->match_property, device, /* match_all = */ false))
649 return false;
650
651 if (!match_property(enumerator->match_property_required, device, /* match_all = */ true))
652 return false;
653
654 if (!device_match_sysattr(device, enumerator->match_sysattr, enumerator->nomatch_sysattr))
655 return false;
656 }
657
658 return true;
659}
660
661static int enumerator_add_parent_devices(
662 sd_device_enumerator *enumerator,
663 sd_device *device,
664 MatchFlag flags) {
665
666 int r;
667
668 assert(enumerator);
669 assert(device);
670
671 for (;;) {
672 r = sd_device_get_parent(device, &device);
673 if (r == -ENOENT) /* Reached the top? */
674 return 0;
675 if (r < 0)
676 return r;
677
678 r = test_matches(enumerator, device, flags);
679 if (r < 0)
680 return r;
681 if (r == 0)
682 continue;
683
684 r = device_enumerator_add_device(enumerator, device);
685 if (r <= 0) /* r == 0 means the device already exists, then no need to go further up. */
686 return r;
687 }
688}
689
690int device_enumerator_add_parent_devices(sd_device_enumerator *enumerator, sd_device *device) {
691 return enumerator_add_parent_devices(enumerator, device, MATCH_ALL & (~MATCH_PARENT));
692}
693
694static bool relevant_sysfs_subdir(const struct dirent *de) {
695 assert(de);
696
697 if (de->d_name[0] == '.')
698 return false;
699
700 /* Also filter out regular files and such, i.e. stuff that definitely isn't a kobject path. (Note
701 * that we rely on the fact that sysfs fills in d_type here, i.e. doesn't do DT_UNKNOWN) */
702 return IN_SET(de->d_type, DT_DIR, DT_LNK);
703}
704
705static int enumerator_scan_dir_and_add_devices(
706 sd_device_enumerator *enumerator,
707 const char *basedir,
708 const char *subdir1,
709 const char *subdir2) {
710
711 _cleanup_closedir_ DIR *dir = NULL;
712 char *path;
713 int k, r = 0;
714
715 assert(enumerator);
716 assert(basedir);
717
718 path = strjoina("/sys/", basedir, "/");
719
720 if (subdir1)
721 path = strjoina(path, subdir1, "/");
722
723 if (subdir2)
724 path = strjoina(path, subdir2, "/");
725
726 dir = opendir(path);
727 if (!dir) {
728 /* This is necessarily racey, so ignore missing directories */
729 if (errno == ENOENT)
730 return 0;
731
732 return log_debug_errno(errno, "sd-device-enumerator: Failed to open directory '%s': %m", path);
733 }
734
735 FOREACH_DIRENT_ALL(de, dir, return -errno) {
736 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
737 char syspath[strlen(path) + 1 + strlen(de->d_name) + 1];
738
739 if (!relevant_sysfs_subdir(de))
740 continue;
741
742 if (!match_sysname(enumerator, de->d_name))
743 continue;
744
745 (void) sprintf(syspath, "%s%s", path, de->d_name);
746
747 k = sd_device_new_from_syspath(&device, syspath);
748 if (k < 0) {
749 if (k != -ENODEV)
750 /* this is necessarily racey, so ignore missing devices */
751 r = k;
752
753 continue;
754 }
755
756 k = test_matches(enumerator, device, MATCH_ALL & (~MATCH_SYSNAME)); /* sysname is already tested. */
757 if (k <= 0) {
758 if (k < 0)
759 r = k;
760 continue;
761 }
762
763 k = device_enumerator_add_device(enumerator, device);
764 if (k < 0)
765 r = k;
766
767 /* Also include all potentially matching parent devices in the enumeration. These are things
768 * like root busses — e.g. /sys/devices/pci0000:00/ or /sys/devices/pnp0/, which ar not
769 * linked from /sys/class/ or /sys/bus/, hence pick them up explicitly here. */
770 k = enumerator_add_parent_devices(enumerator, device, enumerator->parent_match_flags);
771 if (k < 0)
772 r = k;
773 }
774
775 return r;
776}
777
778static int enumerator_scan_dir(
779 sd_device_enumerator *enumerator,
780 const char *basedir,
781 const char *subdir,
782 const char *subsystem) {
783
784 _cleanup_closedir_ DIR *dir = NULL;
785 char *path;
786 int r = 0;
787
788 path = strjoina("/sys/", basedir);
789
790 dir = opendir(path);
791 if (!dir) {
792 if (errno == ENOENT)
793 return 0;
794
795 return log_debug_errno(errno, "sd-device-enumerator: Failed to open directory '%s': %m", path);
796 }
797
798 FOREACH_DIRENT_ALL(de, dir, return -errno) {
799 int k;
800
801 if (!relevant_sysfs_subdir(de))
802 continue;
803
804 if (!match_subsystem(enumerator, subsystem ?: de->d_name))
805 continue;
806
807 k = enumerator_scan_dir_and_add_devices(enumerator, basedir, de->d_name, subdir);
808 if (k < 0)
809 r = k;
810 }
811
812 return r;
813}
814
815static int enumerator_scan_devices_tag(sd_device_enumerator *enumerator, const char *tag) {
816 _cleanup_closedir_ DIR *dir = NULL;
817 char *path;
818 int r = 0;
819
820 assert(enumerator);
821 assert(tag);
822
823 path = strjoina("/run/udev/tags/", tag);
824
825 dir = opendir(path);
826 if (!dir) {
827 if (errno == ENOENT)
828 return 0;
829
830 return log_debug_errno(errno, "sd-device-enumerator: Failed to open directory '%s': %m", path);
831 }
832
833 /* TODO: filter away subsystems? */
834
835 FOREACH_DIRENT_ALL(de, dir, return -errno) {
836 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
837 int k;
838
839 if (de->d_name[0] == '.')
840 continue;
841
842 k = sd_device_new_from_device_id(&device, de->d_name);
843 if (k < 0) {
844 if (k != -ENODEV)
845 /* this is necessarily racy, so ignore missing devices */
846 r = k;
847
848 continue;
849 }
850
851 /* Generated from tag, hence not necessary to check tag again. */
852 k = test_matches(enumerator, device, MATCH_ALL & (~MATCH_TAG));
853 if (k < 0)
854 r = k;
855 if (k <= 0)
856 continue;
857
858 k = device_enumerator_add_device(enumerator, device);
859 if (k < 0) {
860 r = k;
861 continue;
862 }
863 }
864
865 return r;
866}
867
868static int enumerator_scan_devices_tags(sd_device_enumerator *enumerator) {
869 const char *tag;
870 int r = 0;
871
872 assert(enumerator);
873
874 SET_FOREACH(tag, enumerator->match_tag) {
875 int k;
876
877 k = enumerator_scan_devices_tag(enumerator, tag);
878 if (k < 0)
879 r = k;
880 }
881
882 return r;
883}
884
885static int parent_add_child(sd_device_enumerator *enumerator, const char *path, MatchFlag flags) {
886 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
887 int r;
888
889 r = sd_device_new_from_syspath(&device, path);
890 if (r == -ENODEV)
891 /* this is necessarily racy, so ignore missing devices */
892 return 0;
893 else if (r < 0)
894 return r;
895
896 r = test_matches(enumerator, device, flags);
897 if (r <= 0)
898 return r;
899
900 return device_enumerator_add_device(enumerator, device);
901}
902
903static int parent_crawl_children(sd_device_enumerator *enumerator, const char *path, Set **stack) {
904 _cleanup_closedir_ DIR *dir = NULL;
905 int r = 0;
906
907 assert(enumerator);
908 assert(path);
909 assert(stack);
910
911 dir = opendir(path);
912 if (!dir) {
913 if (errno == ENOENT)
914 return 0;
915
916 return log_debug_errno(errno, "sd-device-enumerator: Failed to open directory '%s': %m", path);
917 }
918
919 FOREACH_DIRENT_ALL(de, dir, return -errno) {
920 _cleanup_free_ char *child = NULL;
921 int k;
922
923 if (de->d_name[0] == '.')
924 continue;
925
926 if (de->d_type != DT_DIR)
927 continue;
928
929 child = path_join(path, de->d_name);
930 if (!child)
931 return -ENOMEM;
932
933 /* Let's check sysname filter earlier. The other tests require the sd-device object created
934 * from the path, thus much costly. */
935 if (match_sysname(enumerator, de->d_name)) {
936 k = parent_add_child(enumerator, child, MATCH_ALL & (~(MATCH_SYSNAME|MATCH_PARENT)));
937 if (k < 0)
938 r = k;
939 }
940
941 k = set_ensure_consume(stack, &path_hash_ops_free, TAKE_PTR(child));
942 if (k < 0)
943 r = k;
944 }
945
946 return r;
947}
948
949static int enumerator_scan_devices_children(sd_device_enumerator *enumerator) {
950 _cleanup_set_free_ Set *stack = NULL;
951 const char *path;
952 int r = 0, k;
953
954 assert(enumerator);
955
956 SET_FOREACH(path, enumerator->match_parent) {
957 k = parent_add_child(enumerator, path, MATCH_ALL & (~MATCH_PARENT));
958 if (k < 0)
959 r = k;
960
961 k = parent_crawl_children(enumerator, path, &stack);
962 if (k < 0)
963 r = k;
964 }
965
966 for (;;) {
967 _cleanup_free_ char *p = NULL;
968
969 p = set_steal_first(stack);
970 if (!p)
971 return r;
972
973 k = parent_crawl_children(enumerator, p, &stack);
974 if (k < 0)
975 r = k;
976 }
977}
978
979static int enumerator_scan_devices_all(sd_device_enumerator *enumerator) {
980 int k, r = 0;
981
982 k = enumerator_scan_dir(enumerator, "bus", "devices", NULL);
983 if (k < 0)
984 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan /sys/bus: %m");
985
986 k = enumerator_scan_dir(enumerator, "class", NULL, NULL);
987 if (k < 0)
988 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan /sys/class: %m");
989
990 return r;
991}
992
993int device_enumerator_scan_devices(sd_device_enumerator *enumerator) {
994 int r = 0, k;
995
996 assert(enumerator);
997
998 if (enumerator->scan_uptodate &&
999 enumerator->type == DEVICE_ENUMERATION_TYPE_DEVICES)
1000 return 0;
1001
1002 device_enumerator_unref_devices(enumerator);
1003
1004 if (!set_isempty(enumerator->match_tag)) {
1005 k = enumerator_scan_devices_tags(enumerator);
1006 if (k < 0)
1007 r = k;
1008 } else if (enumerator->match_parent) {
1009 k = enumerator_scan_devices_children(enumerator);
1010 if (k < 0)
1011 r = k;
1012 } else {
1013 k = enumerator_scan_devices_all(enumerator);
1014 if (k < 0)
1015 r = k;
1016 }
1017
1018 enumerator->scan_uptodate = true;
1019 enumerator->type = DEVICE_ENUMERATION_TYPE_DEVICES;
1020
1021 return r;
1022}
1023
1024_public_ sd_device *sd_device_enumerator_get_device_first(sd_device_enumerator *enumerator) {
1025 assert_return(enumerator, NULL);
1026
1027 if (device_enumerator_scan_devices(enumerator) < 0)
1028 return NULL;
1029
1030 if (enumerator_sort_devices(enumerator) < 0)
1031 return NULL;
1032
1033 enumerator->current_device_index = 0;
1034
1035 if (enumerator->n_devices == 0)
1036 return NULL;
1037
1038 return enumerator->devices[0];
1039}
1040
1041_public_ sd_device *sd_device_enumerator_get_device_next(sd_device_enumerator *enumerator) {
1042 assert_return(enumerator, NULL);
1043
1044 if (!enumerator->scan_uptodate ||
1045 !enumerator->sorted ||
1046 enumerator->type != DEVICE_ENUMERATION_TYPE_DEVICES ||
1047 enumerator->current_device_index + 1 >= enumerator->n_devices)
1048 return NULL;
1049
1050 return enumerator->devices[++enumerator->current_device_index];
1051}
1052
1053int device_enumerator_scan_subsystems(sd_device_enumerator *enumerator) {
1054 int r = 0, k;
1055
1056 assert(enumerator);
1057
1058 if (enumerator->scan_uptodate &&
1059 enumerator->type == DEVICE_ENUMERATION_TYPE_SUBSYSTEMS)
1060 return 0;
1061
1062 device_enumerator_unref_devices(enumerator);
1063
1064 /* modules */
1065 if (match_subsystem(enumerator, "module")) {
1066 k = enumerator_scan_dir_and_add_devices(enumerator, "module", NULL, NULL);
1067 if (k < 0)
1068 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan modules: %m");
1069 }
1070
1071 /* subsystems (only buses support coldplug) */
1072 if (match_subsystem(enumerator, "subsystem")) {
1073 k = enumerator_scan_dir_and_add_devices(enumerator, "bus", NULL, NULL);
1074 if (k < 0)
1075 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan subsystems: %m");
1076 }
1077
1078 /* subsystem drivers */
1079 if (match_subsystem(enumerator, "drivers")) {
1080 k = enumerator_scan_dir(enumerator, "bus", "drivers", "drivers");
1081 if (k < 0)
1082 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan drivers: %m");
1083 }
1084
1085 enumerator->scan_uptodate = true;
1086 enumerator->type = DEVICE_ENUMERATION_TYPE_SUBSYSTEMS;
1087
1088 return r;
1089}
1090
1091_public_ sd_device *sd_device_enumerator_get_subsystem_first(sd_device_enumerator *enumerator) {
1092 assert_return(enumerator, NULL);
1093
1094 if (device_enumerator_scan_subsystems(enumerator) < 0)
1095 return NULL;
1096
1097 if (enumerator_sort_devices(enumerator) < 0)
1098 return NULL;
1099
1100 enumerator->current_device_index = 0;
1101
1102 if (enumerator->n_devices == 0)
1103 return NULL;
1104
1105 return enumerator->devices[0];
1106}
1107
1108_public_ sd_device *sd_device_enumerator_get_subsystem_next(sd_device_enumerator *enumerator) {
1109 assert_return(enumerator, NULL);
1110
1111 if (!enumerator->scan_uptodate ||
1112 !enumerator->sorted ||
1113 enumerator->type != DEVICE_ENUMERATION_TYPE_SUBSYSTEMS ||
1114 enumerator->current_device_index + 1 >= enumerator->n_devices)
1115 return NULL;
1116
1117 return enumerator->devices[++enumerator->current_device_index];
1118}
1119
1120int device_enumerator_scan_devices_and_subsystems(sd_device_enumerator *enumerator) {
1121 int r;
1122
1123 assert(enumerator);
1124
1125 if (enumerator->scan_uptodate &&
1126 enumerator->type == DEVICE_ENUMERATION_TYPE_ALL)
1127 return 0;
1128
1129 device_enumerator_unref_devices(enumerator);
1130
1131 if (!set_isempty(enumerator->match_tag))
1132 r = enumerator_scan_devices_tags(enumerator);
1133 else if (enumerator->match_parent)
1134 r = enumerator_scan_devices_children(enumerator);
1135 else {
1136 int k;
1137
1138 r = enumerator_scan_devices_all(enumerator);
1139
1140 if (match_subsystem(enumerator, "module")) {
1141 k = enumerator_scan_dir_and_add_devices(enumerator, "module", NULL, NULL);
1142 if (k < 0)
1143 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan modules: %m");
1144 }
1145 if (match_subsystem(enumerator, "subsystem")) {
1146 k = enumerator_scan_dir_and_add_devices(enumerator, "bus", NULL, NULL);
1147 if (k < 0)
1148 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan subsystems: %m");
1149 }
1150
1151 if (match_subsystem(enumerator, "drivers")) {
1152 k = enumerator_scan_dir(enumerator, "bus", "drivers", "drivers");
1153 if (k < 0)
1154 r = log_debug_errno(k, "sd-device-enumerator: Failed to scan drivers: %m");
1155 }
1156 }
1157
1158 enumerator->scan_uptodate = true;
1159 enumerator->type = DEVICE_ENUMERATION_TYPE_ALL;
1160
1161 return r;
1162}
1163
1164sd_device *device_enumerator_get_first(sd_device_enumerator *enumerator) {
1165 assert_return(enumerator, NULL);
1166
1167 if (!enumerator->scan_uptodate)
1168 return NULL;
1169
1170 if (enumerator_sort_devices(enumerator) < 0)
1171 return NULL;
1172
1173 enumerator->current_device_index = 0;
1174
1175 if (enumerator->n_devices == 0)
1176 return NULL;
1177
1178 return enumerator->devices[0];
1179}
1180
1181sd_device *device_enumerator_get_next(sd_device_enumerator *enumerator) {
1182 assert_return(enumerator, NULL);
1183
1184 if (!enumerator->scan_uptodate ||
1185 !enumerator->sorted ||
1186 enumerator->current_device_index + 1 >= enumerator->n_devices)
1187 return NULL;
1188
1189 return enumerator->devices[++enumerator->current_device_index];
1190}
1191
1192sd_device **device_enumerator_get_devices(sd_device_enumerator *enumerator, size_t *ret_n_devices) {
1193 assert(enumerator);
1194 assert(ret_n_devices);
1195
1196 if (!enumerator->scan_uptodate)
1197 return NULL;
1198
1199 if (enumerator_sort_devices(enumerator) < 0)
1200 return NULL;
1201
1202 *ret_n_devices = enumerator->n_devices;
1203 return enumerator->devices;
1204}
Unnamed repository; edit this file 'description' to name the repository.