7878512465ed0650d4ddb94bece7e50657d29563
[thirdparty/systemd.git] / src / test / test-libudev.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <getopt.h>
5 #include <stdio.h>
6 #include <sys/epoll.h>
7 #include <unistd.h>
8
9 #include "alloc-util.h"
10 #include "build.h"
11 #include "fd-util.h"
12 #include "libudev-list-internal.h"
13 #include "libudev-util.h"
14 #include "log.h"
15 #include "main-func.h"
16 #include "stdio-util.h"
17 #include "string-util.h"
18 #include "tests.h"
19
20 static bool arg_monitor = false;
21
22 static void print_device(struct udev_device *device) {
23         const char *str;
24         dev_t devnum;
25         int count;
26         struct udev_list_entry *list_entry;
27
28         log_info("*** device: %p ***", device);
29         str = udev_device_get_action(device);
30         if (str)
31                 log_info("action:    '%s'", str);
32
33         str = udev_device_get_syspath(device);
34         log_info("syspath:   '%s'", str);
35
36         str = udev_device_get_sysname(device);
37         log_info("sysname:   '%s'", str);
38
39         str = udev_device_get_sysnum(device);
40         if (str)
41                 log_info("sysnum:    '%s'", str);
42
43         str = udev_device_get_devpath(device);
44         log_info("devpath:   '%s'", str);
45
46         str = udev_device_get_subsystem(device);
47         if (str)
48                 log_info("subsystem: '%s'", str);
49
50         str = udev_device_get_devtype(device);
51         if (str)
52                 log_info("devtype:   '%s'", str);
53
54         str = udev_device_get_driver(device);
55         if (str)
56                 log_info("driver:    '%s'", str);
57
58         str = udev_device_get_devnode(device);
59         if (str)
60                 log_info("devname:   '%s'", str);
61
62         devnum = udev_device_get_devnum(device);
63         if (major(devnum) > 0)
64                 log_info("devnum:    %u:%u", major(devnum), minor(devnum));
65
66         count = 0;
67         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device)) {
68                 log_info("link:      '%s'", udev_list_entry_get_name(list_entry));
69                 count++;
70         }
71         if (count > 0)
72                 log_info("found %i links", count);
73
74         count = 0;
75         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device)) {
76                 log_info("property:  '%s=%s'",
77                        udev_list_entry_get_name(list_entry),
78                        udev_list_entry_get_value(list_entry));
79                 count++;
80         }
81         if (count > 0)
82                 log_info("found %i properties", count);
83
84         str = udev_device_get_property_value(device, "MAJOR");
85         if (str)
86                 log_info("MAJOR: '%s'", str);
87
88         str = udev_device_get_sysattr_value(device, "dev");
89         if (str)
90                 log_info("attr{dev}: '%s'", str);
91 }
92
93 static void test_device(struct udev *udev, const char *syspath) {
94         _cleanup_(udev_device_unrefp) struct udev_device *device;
95
96         log_info("/* %s, device %s */", __func__, syspath);
97         device = udev_device_new_from_syspath(udev, syspath);
98         if (device)
99                 print_device(device);
100         else
101                 log_warning_errno(errno, "udev_device_new_from_syspath: %m");
102 }
103
104 static void test_device_parents(struct udev *udev, const char *syspath) {
105         _cleanup_(udev_device_unrefp) struct udev_device *device;
106         struct udev_device *device_parent;
107
108         log_info("/* %s, device %s */", __func__, syspath);
109         device = udev_device_new_from_syspath(udev, syspath);
110         if (device == NULL)
111                 return;
112
113         log_info("looking at parents");
114         device_parent = device;
115         do {
116                 print_device(device_parent);
117                 device_parent = udev_device_get_parent(device_parent);
118         } while (device_parent != NULL);
119
120         log_info("looking at parents again");
121         device_parent = device;
122         do {
123                 print_device(device_parent);
124                 device_parent = udev_device_get_parent(device_parent);
125         } while (device_parent != NULL);
126 }
127
128 static void test_device_devnum(struct udev *udev) {
129         dev_t devnum = makedev(1, 3);
130         _cleanup_(udev_device_unrefp) struct udev_device *device;
131
132         log_info("/* %s, device %d:%d */", __func__, major(devnum), minor(devnum));
133
134         device = udev_device_new_from_devnum(udev, 'c', devnum);
135         if (device)
136                 print_device(device);
137         else
138                 log_warning_errno(errno, "udev_device_new_from_devnum: %m");
139 }
140
141 static void test_device_subsys_name(struct udev *udev, const char *subsys, const char *dev) {
142         _cleanup_(udev_device_unrefp) struct udev_device *device;
143
144         log_info("looking up device: '%s:%s'", subsys, dev);
145         device = udev_device_new_from_subsystem_sysname(udev, subsys, dev);
146         if (device == NULL)
147                 log_warning_errno(errno, "udev_device_new_from_subsystem_sysname: %m");
148         else
149                 print_device(device);
150 }
151
152 static int enumerate_print_list(struct udev_enumerate *enumerate) {
153         struct udev_list_entry *list_entry;
154         int count = 0;
155
156         udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {
157                 struct udev_device *device;
158
159                 device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
160                                                       udev_list_entry_get_name(list_entry));
161                 if (device) {
162                         log_info("device: '%s' (%s)",
163                                  udev_device_get_syspath(device),
164                                  udev_device_get_subsystem(device));
165                         udev_device_unref(device);
166                         count++;
167                 }
168         }
169         log_info("found %i devices", count);
170         return count;
171 }
172
173 static void test_monitor(struct udev *udev) {
174         _cleanup_(udev_monitor_unrefp) struct udev_monitor *udev_monitor;
175         _cleanup_close_ int fd_ep;
176         int fd_udev;
177         struct epoll_event ep_udev = {
178                 .events = EPOLLIN,
179         }, ep_stdin = {
180                 .events = EPOLLIN,
181                 .data.fd = STDIN_FILENO,
182         };
183
184         log_info("/* %s */", __func__);
185
186         fd_ep = epoll_create1(EPOLL_CLOEXEC);
187         assert_se(fd_ep >= 0);
188
189         udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
190         assert_se(udev_monitor != NULL);
191
192         fd_udev = udev_monitor_get_fd(udev_monitor);
193         ep_udev.data.fd = fd_udev;
194
195         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) >= 0);
196         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL) >= 0);
197         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device") >= 0);
198
199         assert_se(udev_monitor_enable_receiving(udev_monitor) >= 0);
200
201         assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) >= 0);
202         assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) >= 0);
203
204         for (;;) {
205                 int fdcount;
206                 struct epoll_event ev[4];
207                 struct udev_device *device;
208                 int i;
209
210                 printf("waiting for events from udev, press ENTER to exit\n");
211                 fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
212                 printf("epoll fd count: %i\n", fdcount);
213
214                 for (i = 0; i < fdcount; i++) {
215                         if (ev[i].data.fd == fd_udev && ev[i].events & EPOLLIN) {
216                                 device = udev_monitor_receive_device(udev_monitor);
217                                 if (device == NULL) {
218                                         printf("no device from socket\n");
219                                         continue;
220                                 }
221                                 print_device(device);
222                                 udev_device_unref(device);
223                         } else if (ev[i].data.fd == STDIN_FILENO && ev[i].events & EPOLLIN) {
224                                 printf("exiting loop\n");
225                                 return;
226                         }
227                 }
228         }
229 }
230
231 static void test_queue(struct udev *udev) {
232         struct udev_queue *udev_queue;
233         bool empty;
234
235         log_info("/* %s */", __func__);
236
237         assert_se(udev_queue = udev_queue_new(udev));
238
239         empty = udev_queue_get_queue_is_empty(udev_queue);
240         log_info("queue is %s", empty ? "empty" : "not empty");
241         udev_queue_unref(udev_queue);
242 }
243
244 static int test_enumerate(struct udev *udev, const char *subsystem) {
245         struct udev_enumerate *udev_enumerate;
246         int r;
247
248         log_info("/* %s */", __func__);
249
250         log_info("enumerate '%s'", subsystem == NULL ? "<all>" : subsystem);
251         udev_enumerate = udev_enumerate_new(udev);
252         if (!udev_enumerate)
253                 return -1;
254         udev_enumerate_add_match_subsystem(udev_enumerate, subsystem);
255         udev_enumerate_scan_devices(udev_enumerate);
256         enumerate_print_list(udev_enumerate);
257         udev_enumerate_unref(udev_enumerate);
258
259         log_info("enumerate 'net' + duplicated scan + null + zero");
260         udev_enumerate = udev_enumerate_new(udev);
261         if (!udev_enumerate)
262                 return -1;
263         udev_enumerate_add_match_subsystem(udev_enumerate, "net");
264         udev_enumerate_scan_devices(udev_enumerate);
265         udev_enumerate_scan_devices(udev_enumerate);
266         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
267         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
268         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
269         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
270         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
271         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
272         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
273         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
274         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
275         udev_enumerate_scan_devices(udev_enumerate);
276         enumerate_print_list(udev_enumerate);
277         udev_enumerate_unref(udev_enumerate);
278
279         log_info("enumerate 'block'");
280         udev_enumerate = udev_enumerate_new(udev);
281         if (!udev_enumerate)
282                 return -1;
283         udev_enumerate_add_match_subsystem(udev_enumerate,"block");
284         r = udev_enumerate_add_match_is_initialized(udev_enumerate);
285         if (r < 0) {
286                 udev_enumerate_unref(udev_enumerate);
287                 return r;
288         }
289         udev_enumerate_scan_devices(udev_enumerate);
290         enumerate_print_list(udev_enumerate);
291         udev_enumerate_unref(udev_enumerate);
292
293         log_info("enumerate 'not block'");
294         udev_enumerate = udev_enumerate_new(udev);
295         if (!udev_enumerate)
296                 return -1;
297         udev_enumerate_add_nomatch_subsystem(udev_enumerate, "block");
298         udev_enumerate_scan_devices(udev_enumerate);
299         enumerate_print_list(udev_enumerate);
300         udev_enumerate_unref(udev_enumerate);
301
302         log_info("enumerate 'pci, mem, vc'");
303         udev_enumerate = udev_enumerate_new(udev);
304         if (!udev_enumerate)
305                 return -1;
306         udev_enumerate_add_match_subsystem(udev_enumerate, "pci");
307         udev_enumerate_add_match_subsystem(udev_enumerate, "mem");
308         udev_enumerate_add_match_subsystem(udev_enumerate, "vc");
309         udev_enumerate_scan_devices(udev_enumerate);
310         enumerate_print_list(udev_enumerate);
311         udev_enumerate_unref(udev_enumerate);
312
313         log_info("enumerate 'subsystem'");
314         udev_enumerate = udev_enumerate_new(udev);
315         if (!udev_enumerate)
316                 return -1;
317         udev_enumerate_scan_subsystems(udev_enumerate);
318         enumerate_print_list(udev_enumerate);
319         udev_enumerate_unref(udev_enumerate);
320
321         log_info("enumerate 'property IF_FS_*=filesystem'");
322         udev_enumerate = udev_enumerate_new(udev);
323         if (!udev_enumerate)
324                 return -1;
325         udev_enumerate_add_match_property(udev_enumerate, "ID_FS*", "filesystem");
326         udev_enumerate_scan_devices(udev_enumerate);
327         enumerate_print_list(udev_enumerate);
328         udev_enumerate_unref(udev_enumerate);
329         return 0;
330 }
331
332 static void test_hwdb(struct udev *udev, const char *modalias) {
333         struct udev_hwdb *hwdb;
334         struct udev_list_entry *entry;
335
336         log_info("/* %s */", __func__);
337
338         hwdb = udev_hwdb_new(udev);
339         if (!hwdb)
340                 log_warning_errno(errno, "Failed to open hwdb: %m");
341
342         udev_list_entry_foreach(entry, udev_hwdb_get_properties_list_entry(hwdb, modalias, 0))
343                 log_info("'%s'='%s'", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry));
344
345         hwdb = udev_hwdb_unref(hwdb);
346         assert_se(hwdb == NULL);
347 }
348
349 static void test_util_replace_whitespace_one_len(const char *str, size_t len, const char *expected) {
350         _cleanup_free_ char *result = NULL;
351         int r;
352
353         result = new(char, len + 1);
354         assert_se(result);
355         r = util_replace_whitespace(str, result, len);
356         assert_se((size_t) r == strlen(expected));
357         assert_se(streq(result, expected));
358 }
359
360 static void test_util_replace_whitespace_one(const char *str, const char *expected) {
361         test_util_replace_whitespace_one_len(str, strlen(str), expected);
362 }
363
364 static void test_util_replace_whitespace(void) {
365         log_info("/* %s */", __func__);
366
367         test_util_replace_whitespace_one("hogehoge", "hogehoge");
368         test_util_replace_whitespace_one("hoge  hoge", "hoge_hoge");
369         test_util_replace_whitespace_one("  hoge  hoge  ", "hoge_hoge");
370         test_util_replace_whitespace_one("     ", "");
371         test_util_replace_whitespace_one("hoge ", "hoge");
372
373         test_util_replace_whitespace_one_len("hoge hoge    ", 9, "hoge_hoge");
374         test_util_replace_whitespace_one_len("hoge hoge    ", 8, "hoge_hog");
375         test_util_replace_whitespace_one_len("hoge hoge    ", 7, "hoge_ho");
376         test_util_replace_whitespace_one_len("hoge hoge    ", 6, "hoge_h");
377         test_util_replace_whitespace_one_len("hoge hoge    ", 5, "hoge");
378         test_util_replace_whitespace_one_len("hoge hoge    ", 4, "hoge");
379         test_util_replace_whitespace_one_len("hoge hoge    ", 3, "hog");
380         test_util_replace_whitespace_one_len("hoge hoge    ", 2, "ho");
381         test_util_replace_whitespace_one_len("hoge hoge    ", 1, "h");
382         test_util_replace_whitespace_one_len("hoge hoge    ", 0, "");
383
384         test_util_replace_whitespace_one_len("    hoge   hoge    ", 16, "hoge_hoge");
385         test_util_replace_whitespace_one_len("    hoge   hoge    ", 15, "hoge_hoge");
386         test_util_replace_whitespace_one_len("    hoge   hoge    ", 14, "hoge_hog");
387         test_util_replace_whitespace_one_len("    hoge   hoge    ", 13, "hoge_ho");
388         test_util_replace_whitespace_one_len("    hoge   hoge    ", 12, "hoge_h");
389         test_util_replace_whitespace_one_len("    hoge   hoge    ", 11, "hoge");
390         test_util_replace_whitespace_one_len("    hoge   hoge    ", 10, "hoge");
391         test_util_replace_whitespace_one_len("    hoge   hoge    ", 9, "hoge");
392         test_util_replace_whitespace_one_len("    hoge   hoge    ", 8, "hoge");
393         test_util_replace_whitespace_one_len("    hoge   hoge    ", 7, "hog");
394         test_util_replace_whitespace_one_len("    hoge   hoge    ", 6, "ho");
395         test_util_replace_whitespace_one_len("    hoge   hoge    ", 5, "h");
396         test_util_replace_whitespace_one_len("    hoge   hoge    ", 4, "");
397         test_util_replace_whitespace_one_len("    hoge   hoge    ", 3, "");
398         test_util_replace_whitespace_one_len("    hoge   hoge    ", 2, "");
399         test_util_replace_whitespace_one_len("    hoge   hoge    ", 1, "");
400         test_util_replace_whitespace_one_len("    hoge   hoge    ", 0, "");
401 }
402
403 static void test_util_resolve_subsys_kernel_one(const char *str, bool read_value, int retval, const char *expected) {
404         char result[UTIL_PATH_SIZE] = "";
405         int r;
406
407         r = util_resolve_subsys_kernel(str, result, sizeof(result), read_value);
408         log_info("\"%s\" → expect: \"%s\", %d, actual: \"%s\", %d", str, strnull(expected), retval, result, r);
409         assert_se(r == retval);
410         if (r >= 0)
411                 assert_se(streq(result, expected));
412 }
413
414 static void test_util_resolve_subsys_kernel(void) {
415         log_info("/* %s */", __func__);
416
417         test_util_resolve_subsys_kernel_one("hoge", false, -EINVAL, NULL);
418         test_util_resolve_subsys_kernel_one("[hoge", false, -EINVAL, NULL);
419         test_util_resolve_subsys_kernel_one("[hoge/foo", false, -EINVAL, NULL);
420         test_util_resolve_subsys_kernel_one("[hoge/]", false, -ENODEV, NULL);
421
422         test_util_resolve_subsys_kernel_one("[net/lo]", false, 0, "/sys/devices/virtual/net/lo");
423         test_util_resolve_subsys_kernel_one("[net/lo]/", false, 0, "/sys/devices/virtual/net/lo");
424         test_util_resolve_subsys_kernel_one("[net/lo]hoge", false, 0, "/sys/devices/virtual/net/lo/hoge");
425         test_util_resolve_subsys_kernel_one("[net/lo]/hoge", false, 0, "/sys/devices/virtual/net/lo/hoge");
426
427         test_util_resolve_subsys_kernel_one("[net/lo]", true, -EINVAL, NULL);
428         test_util_resolve_subsys_kernel_one("[net/lo]/", true, -EINVAL, NULL);
429         test_util_resolve_subsys_kernel_one("[net/lo]hoge", true, 0, "");
430         test_util_resolve_subsys_kernel_one("[net/lo]/hoge", true, 0, "");
431         test_util_resolve_subsys_kernel_one("[net/lo]address", true, 0, "00:00:00:00:00:00");
432         test_util_resolve_subsys_kernel_one("[net/lo]/address", true, 0, "00:00:00:00:00:00");
433 }
434
435 static void test_list(void) {
436         struct udev_list list = {};
437         struct udev_list_entry *e;
438
439         /* empty list */
440         udev_list_init(&list, false);
441         assert_se(!udev_list_get_entry(&list));
442
443         /* unique == false */
444         udev_list_init(&list, false);
445         assert_se(udev_list_entry_add(&list, "aaa", "hoge"));
446         assert_se(udev_list_entry_add(&list, "aaa", "hogehoge"));
447         assert_se(udev_list_entry_add(&list, "bbb", "foo"));
448         e = udev_list_get_entry(&list);
449         assert_se(e);
450         assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
451         assert_se(streq_ptr(udev_list_entry_get_value(e), "hoge"));
452         e = udev_list_entry_get_next(e);
453         assert_se(e);
454         assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
455         assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
456         e = udev_list_entry_get_next(e);
457         assert_se(e);
458         assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
459         assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
460         assert_se(!udev_list_entry_get_next(e));
461
462         assert_se(!udev_list_entry_get_by_name(e, "aaa"));
463         assert_se(!udev_list_entry_get_by_name(e, "bbb"));
464         assert_se(!udev_list_entry_get_by_name(e, "ccc"));
465         udev_list_cleanup(&list);
466
467         /* unique == true */
468         udev_list_init(&list, true);
469         assert_se(udev_list_entry_add(&list, "aaa", "hoge"));
470         assert_se(udev_list_entry_add(&list, "aaa", "hogehoge"));
471         assert_se(udev_list_entry_add(&list, "bbb", "foo"));
472         e = udev_list_get_entry(&list);
473         assert_se(e);
474         assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
475         assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
476         e = udev_list_entry_get_next(e);
477         assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
478         assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
479         assert_se(!udev_list_entry_get_next(e));
480
481         e = udev_list_entry_get_by_name(e, "bbb");
482         assert_se(e);
483         assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
484         assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
485         e = udev_list_entry_get_by_name(e, "aaa");
486         assert_se(e);
487         assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
488         assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
489         assert_se(!udev_list_entry_get_by_name(e, "ccc"));
490         udev_list_cleanup(&list);
491 }
492
493 static int parse_args(int argc, char *argv[], const char **syspath, const char **subsystem) {
494         static const struct option options[] = {
495                 { "syspath",   required_argument, NULL, 'p' },
496                 { "subsystem", required_argument, NULL, 's' },
497                 { "debug",     no_argument,       NULL, 'd' },
498                 { "help",      no_argument,       NULL, 'h' },
499                 { "version",   no_argument,       NULL, 'V' },
500                 { "monitor",   no_argument,       NULL, 'm' },
501                 {}
502         };
503         int c;
504
505         while ((c = getopt_long(argc, argv, "p:s:dhVm", options, NULL)) >= 0)
506                 switch (c) {
507                 case 'p':
508                         *syspath = optarg;
509                         break;
510
511                 case 's':
512                         *subsystem = optarg;
513                         break;
514
515                 case 'd':
516                         log_set_max_level(LOG_DEBUG);
517                         break;
518
519                 case 'h':
520                         printf("--debug --syspath= --subsystem= --help\n");
521                         return 0;
522
523                 case 'V':
524                         printf("%s\n", GIT_VERSION);
525                         return 0;
526
527                 case 'm':
528                         arg_monitor = true;
529                         break;
530
531                 case '?':
532                         return -EINVAL;
533
534                 default:
535                         assert_not_reached("Unhandled option code.");
536                 }
537
538         return 1;
539 }
540
541 static int run(int argc, char *argv[]) {
542         _cleanup_(udev_unrefp) struct udev *udev = NULL;
543
544         const char *syspath = "/devices/virtual/mem/null";
545         const char *subsystem = NULL;
546         int r;
547
548         test_setup_logging(LOG_INFO);
549
550         r = parse_args(argc, argv, &syspath, &subsystem);
551         if (r <= 0)
552                 return r;
553
554         assert_se(udev = udev_new());
555
556         /* add sys path if needed */
557         if (!startswith(syspath, "/sys"))
558                 syspath = strjoina("/sys/", syspath);
559
560         test_device(udev, syspath);
561         test_device_devnum(udev);
562         test_device_subsys_name(udev, "block", "sda");
563         test_device_subsys_name(udev, "subsystem", "pci");
564         test_device_subsys_name(udev, "drivers", "scsi:sd");
565         test_device_subsys_name(udev, "module", "printk");
566         test_device_parents(udev, syspath);
567
568         test_enumerate(udev, subsystem);
569
570         test_queue(udev);
571
572         test_hwdb(udev, "usb:v0D50p0011*");
573
574         if (arg_monitor)
575                 test_monitor(udev);
576
577         test_util_replace_whitespace();
578         test_util_resolve_subsys_kernel();
579
580         test_list();
581
582         return 0;
583 }
584
585 DEFINE_MAIN_FUNCTION(run);