src/test/test-libudev.c

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