src/test/test-libudev.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   Copyright © 2008-2012 Kay Sievers <kay@vrfy.org>
   4 ***/
   5
   6 #include <getopt.h>
   7 #include <stdio.h>
   8 #include <sys/epoll.h>
   9 #include <unistd.h>
  10
  11 #include "libudev.h"
  12
  13 #include "fd-util.h"
  14 #include "log.h"
  15 #include "stdio-util.h"
  16 #include "string-util.h"
  17 #include "udev-util.h"
  18 #include "util.h"
  19
  20 static void print_device(struct udev_device *device) {
  21         const char *str;
  22         dev_t devnum;
  23         int count;
  24         struct udev_list_entry *list_entry;
  25
  26         log_info("*** device: %p ***", device);
  27         str = udev_device_get_action(device);
  28         if (str != NULL)
  29                 log_info("action:    '%s'", str);
  30
  31         str = udev_device_get_syspath(device);
  32         log_info("syspath:   '%s'", str);
  33
  34         str = udev_device_get_sysname(device);
  35         log_info("sysname:   '%s'", str);
  36
  37         str = udev_device_get_sysnum(device);
  38         if (str != NULL)
  39                 log_info("sysnum:    '%s'", str);
  40
  41         str = udev_device_get_devpath(device);
  42         log_info("devpath:   '%s'", str);
  43
  44         str = udev_device_get_subsystem(device);
  45         if (str != NULL)
  46                 log_info("subsystem: '%s'", str);
  47
  48         str = udev_device_get_devtype(device);
  49         if (str != NULL)
  50                 log_info("devtype:   '%s'", str);
  51
  52         str = udev_device_get_driver(device);
  53         if (str != NULL)
  54                 log_info("driver:    '%s'", str);
  55
  56         str = udev_device_get_devnode(device);
  57         if (str != NULL)
  58                 log_info("devname:   '%s'", str);
  59
  60         devnum = udev_device_get_devnum(device);
  61         if (major(devnum) > 0)
  62                 log_info("devnum:    %u:%u", major(devnum), minor(devnum));
  63
  64         count = 0;
  65         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device)) {
  66                 log_info("link:      '%s'", udev_list_entry_get_name(list_entry));
  67                 count++;
  68         }
  69         if (count > 0)
  70                 log_info("found %i links", count);
  71
  72         count = 0;
  73         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device)) {
  74                 log_info("property:  '%s=%s'",
  75                        udev_list_entry_get_name(list_entry),
  76                        udev_list_entry_get_value(list_entry));
  77                 count++;
  78         }
  79         if (count > 0)
  80                 log_info("found %i properties", count);
  81
  82         str = udev_device_get_property_value(device, "MAJOR");
  83         if (str != NULL)
  84                 log_info("MAJOR: '%s'", str);
  85
  86         str = udev_device_get_sysattr_value(device, "dev");
  87         if (str != NULL)
  88                 log_info("attr{dev}: '%s'", str);
  89 }
  90
  91 static void test_device(struct udev *udev, const char *syspath) {
  92         _cleanup_(udev_device_unrefp) struct udev_device *device;
  93
  94         log_info("looking at device: %s", syspath);
  95         device = udev_device_new_from_syspath(udev, syspath);
  96         if (device == NULL)
  97                 log_warning_errno(errno, "udev_device_new_from_syspath: %m");
  98         else
  99                 print_device(device);
 100 }
 101
 102 static void test_device_parents(struct udev *udev, const char *syspath) {
 103         _cleanup_(udev_device_unrefp) struct udev_device *device;
 104         struct udev_device *device_parent;
 105
 106         log_info("looking at device: %s", syspath);
 107         device = udev_device_new_from_syspath(udev, syspath);
 108         if (device == NULL)
 109                 return;
 110
 111         log_info("looking at parents");
 112         device_parent = device;
 113         do {
 114                 print_device(device_parent);
 115                 device_parent = udev_device_get_parent(device_parent);
 116         } while (device_parent != NULL);
 117
 118         log_info("looking at parents again");
 119         device_parent = device;
 120         do {
 121                 print_device(device_parent);
 122                 device_parent = udev_device_get_parent(device_parent);
 123         } while (device_parent != NULL);
 124 }
 125
 126 static void test_device_devnum(struct udev *udev) {
 127         dev_t devnum = makedev(1, 3);
 128         _cleanup_(udev_device_unrefp) struct udev_device *device;
 129
 130         log_info("looking up device: %u:%u", major(devnum), minor(devnum));
 131         device = udev_device_new_from_devnum(udev, 'c', devnum);
 132         if (device == NULL)
 133                 log_warning_errno(errno, "udev_device_new_from_devnum: %m");
 134         else
 135                 print_device(device);
 136 }
 137
 138 static void test_device_subsys_name(struct udev *udev, const char *subsys, const char *dev) {
 139         _cleanup_(udev_device_unrefp) struct udev_device *device;
 140
 141         log_info("looking up device: '%s:%s'", subsys, dev);
 142         device = udev_device_new_from_subsystem_sysname(udev, subsys, dev);
 143         if (device == NULL)
 144                 log_warning_errno(errno, "udev_device_new_from_subsystem_sysname: %m");
 145         else
 146                 print_device(device);
 147 }
 148
 149 static int test_enumerate_print_list(struct udev_enumerate *enumerate) {
 150         struct udev_list_entry *list_entry;
 151         int count = 0;
 152
 153         udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {
 154                 struct udev_device *device;
 155
 156                 device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
 157                                                       udev_list_entry_get_name(list_entry));
 158                 if (device != NULL) {
 159                         log_info("device: '%s' (%s)",
 160                                  udev_device_get_syspath(device),
 161                                  udev_device_get_subsystem(device));
 162                         udev_device_unref(device);
 163                         count++;
 164                 }
 165         }
 166         log_info("found %i devices", count);
 167         return count;
 168 }
 169
 170 static void test_monitor(struct udev *udev) {
 171         _cleanup_(udev_monitor_unrefp) struct udev_monitor *udev_monitor;
 172         _cleanup_close_ int fd_ep;
 173         int fd_udev;
 174         struct epoll_event ep_udev = {
 175                 .events = EPOLLIN,
 176         }, ep_stdin = {
 177                 .events = EPOLLIN,
 178                 .data.fd = STDIN_FILENO,
 179         };
 180
 181         fd_ep = epoll_create1(EPOLL_CLOEXEC);
 182         assert_se(fd_ep >= 0);
 183
 184         udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
 185         assert_se(udev_monitor != NULL);
 186
 187         fd_udev = udev_monitor_get_fd(udev_monitor);
 188         ep_udev.data.fd = fd_udev;
 189
 190         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) >= 0);
 191         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL) >= 0);
 192         assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device") >= 0);
 193
 194         assert_se(udev_monitor_enable_receiving(udev_monitor) >= 0);
 195
 196         assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) >= 0);
 197         assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) >= 0);
 198
 199         for (;;) {
 200                 int fdcount;
 201                 struct epoll_event ev[4];
 202                 struct udev_device *device;
 203                 int i;
 204
 205                 printf("waiting for events from udev, press ENTER to exit\n");
 206                 fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
 207                 printf("epoll fd count: %i\n", fdcount);
 208
 209                 for (i = 0; i < fdcount; i++) {
 210                         if (ev[i].data.fd == fd_udev && ev[i].events & EPOLLIN) {
 211                                 device = udev_monitor_receive_device(udev_monitor);
 212                                 if (device == NULL) {
 213                                         printf("no device from socket\n");
 214                                         continue;
 215                                 }
 216                                 print_device(device);
 217                                 udev_device_unref(device);
 218                         } else if (ev[i].data.fd == STDIN_FILENO && ev[i].events & EPOLLIN) {
 219                                 printf("exiting loop\n");
 220                                 return;
 221                         }
 222                 }
 223         }
 224 }
 225
 226 static void test_queue(struct udev *udev) {
 227         struct udev_queue *udev_queue;
 228         bool empty;
 229
 230         udev_queue = udev_queue_new(udev);
 231         assert_se(udev_queue);
 232
 233         empty = udev_queue_get_queue_is_empty(udev_queue);
 234         log_info("queue is %s", empty ? "empty" : "not empty");
 235         udev_queue_unref(udev_queue);
 236 }
 237
 238 static int test_enumerate(struct udev *udev, const char *subsystem) {
 239         struct udev_enumerate *udev_enumerate;
 240         int r;
 241
 242         log_info("enumerate '%s'", subsystem == NULL ? "<all>" : subsystem);
 243         udev_enumerate = udev_enumerate_new(udev);
 244         if (udev_enumerate == NULL)
 245                 return -1;
 246         udev_enumerate_add_match_subsystem(udev_enumerate, subsystem);
 247         udev_enumerate_scan_devices(udev_enumerate);
 248         test_enumerate_print_list(udev_enumerate);
 249         udev_enumerate_unref(udev_enumerate);
 250
 251         log_info("enumerate 'net' + duplicated scan + null + zero");
 252         udev_enumerate = udev_enumerate_new(udev);
 253         if (udev_enumerate == NULL)
 254                 return -1;
 255         udev_enumerate_add_match_subsystem(udev_enumerate, "net");
 256         udev_enumerate_scan_devices(udev_enumerate);
 257         udev_enumerate_scan_devices(udev_enumerate);
 258         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
 259         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
 260         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
 261         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
 262         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
 263         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
 264         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
 265         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
 266         udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
 267         udev_enumerate_scan_devices(udev_enumerate);
 268         test_enumerate_print_list(udev_enumerate);
 269         udev_enumerate_unref(udev_enumerate);
 270
 271         log_info("enumerate 'block'");
 272         udev_enumerate = udev_enumerate_new(udev);
 273         if (udev_enumerate == NULL)
 274                 return -1;
 275         udev_enumerate_add_match_subsystem(udev_enumerate,"block");
 276         r = udev_enumerate_add_match_is_initialized(udev_enumerate);
 277         if (r < 0) {
 278                 udev_enumerate_unref(udev_enumerate);
 279                 return r;
 280         }
 281         udev_enumerate_scan_devices(udev_enumerate);
 282         test_enumerate_print_list(udev_enumerate);
 283         udev_enumerate_unref(udev_enumerate);
 284
 285         log_info("enumerate 'not block'");
 286         udev_enumerate = udev_enumerate_new(udev);
 287         if (udev_enumerate == NULL)
 288                 return -1;
 289         udev_enumerate_add_nomatch_subsystem(udev_enumerate, "block");
 290         udev_enumerate_scan_devices(udev_enumerate);
 291         test_enumerate_print_list(udev_enumerate);
 292         udev_enumerate_unref(udev_enumerate);
 293
 294         log_info("enumerate 'pci, mem, vc'");
 295         udev_enumerate = udev_enumerate_new(udev);
 296         if (udev_enumerate == NULL)
 297                 return -1;
 298         udev_enumerate_add_match_subsystem(udev_enumerate, "pci");
 299         udev_enumerate_add_match_subsystem(udev_enumerate, "mem");
 300         udev_enumerate_add_match_subsystem(udev_enumerate, "vc");
 301         udev_enumerate_scan_devices(udev_enumerate);
 302         test_enumerate_print_list(udev_enumerate);
 303         udev_enumerate_unref(udev_enumerate);
 304
 305         log_info("enumerate 'subsystem'");
 306         udev_enumerate = udev_enumerate_new(udev);
 307         if (udev_enumerate == NULL)
 308                 return -1;
 309         udev_enumerate_scan_subsystems(udev_enumerate);
 310         test_enumerate_print_list(udev_enumerate);
 311         udev_enumerate_unref(udev_enumerate);
 312
 313         log_info("enumerate 'property IF_FS_*=filesystem'");
 314         udev_enumerate = udev_enumerate_new(udev);
 315         if (udev_enumerate == NULL)
 316                 return -1;
 317         udev_enumerate_add_match_property(udev_enumerate, "ID_FS*", "filesystem");
 318         udev_enumerate_scan_devices(udev_enumerate);
 319         test_enumerate_print_list(udev_enumerate);
 320         udev_enumerate_unref(udev_enumerate);
 321         return 0;
 322 }
 323
 324 static void test_hwdb(struct udev *udev, const char *modalias) {
 325         struct udev_hwdb *hwdb;
 326         struct udev_list_entry *entry;
 327
 328         hwdb = udev_hwdb_new(udev);
 329
 330         udev_list_entry_foreach(entry, udev_hwdb_get_properties_list_entry(hwdb, modalias, 0))
 331                 log_info("'%s'='%s'", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry));
 332
 333         hwdb = udev_hwdb_unref(hwdb);
 334         assert_se(hwdb == NULL);
 335 }
 336
 337 int main(int argc, char *argv[]) {
 338         _cleanup_(udev_unrefp) struct udev *udev = NULL;
 339         bool arg_monitor = false;
 340         static const struct option options[] = {
 341                 { "syspath",   required_argument, NULL, 'p' },
 342                 { "subsystem", required_argument, NULL, 's' },
 343                 { "debug",     no_argument,       NULL, 'd' },
 344                 { "help",      no_argument,       NULL, 'h' },
 345                 { "version",   no_argument,       NULL, 'V' },
 346                 { "monitor",   no_argument,       NULL, 'm' },
 347                 {}
 348         };
 349         const char *syspath = "/devices/virtual/mem/null";
 350         const char *subsystem = NULL;
 351         int c;
 352
 353         udev = udev_new();
 354         log_info("context: %p", udev);
 355         if (udev == NULL) {
 356                 log_info("no context");
 357                 return 1;
 358         }
 359
 360         while ((c = getopt_long(argc, argv, "p:s:dhVm", options, NULL)) >= 0)
 361                 switch (c) {
 362
 363                 case 'p':
 364                         syspath = optarg;
 365                         break;
 366
 367                 case 's':
 368                         subsystem = optarg;
 369                         break;
 370
 371                 case 'd':
 372                         if (log_get_max_level() < LOG_INFO)
 373                                 log_set_max_level(LOG_INFO);
 374                         break;
 375
 376                 case 'h':
 377                         printf("--debug --syspath= --subsystem= --help\n");
 378                         return EXIT_SUCCESS;
 379
 380                 case 'V':
 381                         printf("%s\n", PACKAGE_VERSION);
 382                         return EXIT_SUCCESS;
 383
 384                 case 'm':
 385                         arg_monitor = true;
 386                         break;
 387
 388                 case '?':
 389                         return EXIT_FAILURE;
 390
 391                 default:
 392                         assert_not_reached("Unhandled option code.");
 393                 }
 394
 395         /* add sys path if needed */
 396         if (!startswith(syspath, "/sys"))
 397                 syspath = strjoina("/sys/", syspath);
 398
 399         test_device(udev, syspath);
 400         test_device_devnum(udev);
 401         test_device_subsys_name(udev, "block", "sda");
 402         test_device_subsys_name(udev, "subsystem", "pci");
 403         test_device_subsys_name(udev, "drivers", "scsi:sd");
 404         test_device_subsys_name(udev, "module", "printk");
 405
 406         test_device_parents(udev, syspath);
 407
 408         test_enumerate(udev, subsystem);
 409
 410         test_queue(udev);
 411
 412         test_hwdb(udev, "usb:v0D50p0011*");
 413
 414         if (arg_monitor)
 415                 test_monitor(udev);
 416
 417         return EXIT_SUCCESS;
 418 }