src/libsystemd/sd-device/test-sd-device.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <ctype.h>
   4 #include <fcntl.h>
   5 #include <unistd.h>
   6
   7 #include "device-enumerator-private.h"
   8 #include "device-internal.h"
   9 #include "device-private.h"
  10 #include "device-util.h"
  11 #include "errno-util.h"
  12 #include "fd-util.h"
  13 #include "hashmap.h"
  14 #include "nulstr-util.h"
  15 #include "path-util.h"
  16 #include "rm-rf.h"
  17 #include "stat-util.h"
  18 #include "string-util.h"
  19 #include "tests.h"
  20 #include "time-util.h"
  21 #include "tmpfile-util.h"
  22 #include "udev-util.h"
  23
  24 static void test_sd_device_one(sd_device *d) {
  25         _cleanup_(sd_device_unrefp) sd_device *dev = NULL;
  26         const char *syspath, *sysname, *subsystem = NULL, *devname, *val;
  27         bool is_block = false;
  28         dev_t devnum;
  29         usec_t usec;
  30         int ifindex, r;
  31
  32         assert_se(sd_device_get_syspath(d, &syspath) >= 0);
  33         assert_se(path_startswith(syspath, "/sys"));
  34         assert_se(sd_device_get_sysname(d, &sysname) >= 0);
  35
  36         log_info("%s(%s)", __func__, syspath);
  37
  38         assert_se(sd_device_new_from_syspath(&dev, syspath) >= 0);
  39         assert_se(sd_device_get_syspath(dev, &val) >= 0);
  40         assert_se(streq(syspath, val));
  41         dev = sd_device_unref(dev);
  42
  43         assert_se(sd_device_new_from_path(&dev, syspath) >= 0);
  44         assert_se(sd_device_get_syspath(dev, &val) >= 0);
  45         assert_se(streq(syspath, val));
  46         dev = sd_device_unref(dev);
  47
  48         r = sd_device_get_ifindex(d, &ifindex);
  49         if (r >= 0) {
  50                 assert_se(ifindex > 0);
  51
  52                 r = sd_device_new_from_ifindex(&dev, ifindex);
  53                 if (r == -ENODEV)
  54                         log_device_warning_errno(d, r,
  55                                                  "Failed to create sd-device object from ifindex %i. "
  56                                                  "Maybe running on a non-host network namespace.", ifindex);
  57                 else {
  58                         assert_se(r >= 0);
  59                         assert_se(sd_device_get_syspath(dev, &val) >= 0);
  60                         assert_se(streq(syspath, val));
  61                         dev = sd_device_unref(dev);
  62                 }
  63
  64                 /* This does not require the interface really exists on the network namespace.
  65                  * Hence, this should always succeed. */
  66                 assert_se(sd_device_new_from_ifname(&dev, sysname) >= 0);
  67                 assert_se(sd_device_get_syspath(dev, &val) >= 0);
  68                 assert_se(streq(syspath, val));
  69                 dev = sd_device_unref(dev);
  70         } else
  71                 assert_se(r == -ENOENT);
  72
  73         r = sd_device_get_subsystem(d, &subsystem);
  74         if (r < 0)
  75                 assert_se(r == -ENOENT);
  76         else if (!streq(subsystem, "gpio")) { /* Unfortunately, there exist /sys/class/gpio and /sys/bus/gpio.
  77                                                * Hence, sd_device_new_from_subsystem_sysname() and
  78                                                * sd_device_new_from_device_id() may not work as expected. */
  79                 const char *name, *id;
  80
  81                 if (streq(subsystem, "drivers"))
  82                         name = strjoina(d->driver_subsystem, ":", sysname);
  83                 else
  84                         name = sysname;
  85                 assert_se(sd_device_new_from_subsystem_sysname(&dev, subsystem, name) >= 0);
  86                 assert_se(sd_device_get_syspath(dev, &val) >= 0);
  87                 assert_se(streq(syspath, val));
  88                 dev = sd_device_unref(dev);
  89
  90                 /* The device ID depends on subsystem. */
  91                 assert_se(device_get_device_id(d, &id) >= 0);
  92                 r = sd_device_new_from_device_id(&dev, id);
  93                 if (r == -ENODEV && ifindex > 0)
  94                         log_device_warning_errno(d, r,
  95                                                  "Failed to create sd-device object from device ID \"%s\". "
  96                                                  "Maybe running on a non-host network namespace.", id);
  97                 else {
  98                         assert_se(r >= 0);
  99                         assert_se(sd_device_get_syspath(dev, &val) >= 0);
 100                         assert_se(streq(syspath, val));
 101                         dev = sd_device_unref(dev);
 102                 }
 103
 104                 /* These require udev database, and reading database requires device ID. */
 105                 r = sd_device_get_is_initialized(d);
 106                 if (r > 0) {
 107                         r = sd_device_get_usec_since_initialized(d, &usec);
 108                         assert_se((r >= 0 && usec > 0) || r == -ENODATA);
 109                 } else
 110                         assert(r == 0);
 111
 112                 r = sd_device_get_property_value(d, "ID_NET_DRIVER", &val);
 113                 assert_se(r >= 0 || r == -ENOENT);
 114         }
 115
 116         is_block = streq_ptr(subsystem, "block");
 117
 118         r = sd_device_get_devname(d, &devname);
 119         if (r >= 0) {
 120                 r = sd_device_new_from_devname(&dev, devname);
 121                 if (r >= 0) {
 122                         assert_se(sd_device_get_syspath(dev, &val) >= 0);
 123                         assert_se(streq(syspath, val));
 124                         dev = sd_device_unref(dev);
 125                 } else
 126                         assert_se(r == -ENODEV || ERRNO_IS_PRIVILEGE(r));
 127
 128                 r = sd_device_new_from_path(&dev, devname);
 129                 if (r >= 0) {
 130                         assert_se(sd_device_get_syspath(dev, &val) >= 0);
 131                         assert_se(streq(syspath, val));
 132                         dev = sd_device_unref(dev);
 133
 134                         _cleanup_close_ int fd = -1;
 135                         fd = sd_device_open(d, O_CLOEXEC| O_NONBLOCK | (is_block ? O_RDONLY : O_NOCTTY | O_PATH));
 136                         assert_se(fd >= 0 || ERRNO_IS_PRIVILEGE(fd));
 137                 } else
 138                         assert_se(r == -ENODEV || ERRNO_IS_PRIVILEGE(r));
 139         } else
 140                 assert_se(r == -ENOENT);
 141
 142         r = sd_device_get_devnum(d, &devnum);
 143         if (r >= 0) {
 144                 _cleanup_free_ char *p = NULL;
 145
 146                 assert_se(major(devnum) > 0);
 147
 148                 assert_se(sd_device_new_from_devnum(&dev, is_block ? 'b' : 'c', devnum) >= 0);
 149                 assert_se(sd_device_get_syspath(dev, &val) >= 0);
 150                 assert_se(streq(syspath, val));
 151                 dev = sd_device_unref(dev);
 152
 153                 assert_se(asprintf(&p, "/dev/%s/%u:%u", is_block ? "block" : "char", major(devnum), minor(devnum)) >= 0);
 154                 assert_se(sd_device_new_from_devname(&dev, p) >= 0);
 155                 assert_se(sd_device_get_syspath(dev, &val) >= 0);
 156                 assert_se(streq(syspath, val));
 157                 dev = sd_device_unref(dev);
 158
 159                 assert_se(sd_device_new_from_path(&dev, p) >= 0);
 160                 assert_se(sd_device_get_syspath(dev, &val) >= 0);
 161                 assert_se(streq(syspath, val));
 162                 dev = sd_device_unref(dev);
 163         } else
 164                 assert_se(r == -ENOENT);
 165
 166         assert_se(sd_device_get_devpath(d, &val) >= 0);
 167
 168         r = sd_device_get_devtype(d, &val);
 169         assert_se(r >= 0 || r == -ENOENT);
 170
 171         r = sd_device_get_driver(d, &val);
 172         assert_se(r >= 0 || r == -ENOENT);
 173
 174         r = sd_device_get_sysnum(d, &val);
 175         if (r >= 0) {
 176                 assert_se(val > sysname);
 177                 assert_se(val < sysname + strlen(sysname));
 178                 assert_se(in_charset(val, DIGITS));
 179                 assert_se(!ascii_isdigit(val[-1]));
 180         } else
 181                 assert_se(r == -ENOENT);
 182
 183         r = sd_device_get_sysattr_value(d, "nsid", NULL);
 184         if (r >= 0) {
 185                 unsigned x;
 186
 187                 assert_se(device_get_sysattr_unsigned(d, "nsid", NULL) >= 0);
 188                 r = device_get_sysattr_unsigned(d, "nsid", &x);
 189                 assert_se(r >= 0);
 190                 assert_se((x > 0) == (r > 0));
 191         } else
 192                 assert_se(ERRNO_IS_PRIVILEGE(r) || IN_SET(r, -ENOENT, -EINVAL));
 193 }
 194
 195 TEST(sd_device_enumerator_devices) {
 196         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 197         sd_device *d;
 198
 199         assert_se(sd_device_enumerator_new(&e) >= 0);
 200         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 201         /* On some CI environments, it seems some loop block devices and corresponding bdi devices sometimes
 202          * disappear during running this test. Let's exclude them here for stability. */
 203         assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
 204         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 205         /* On CentOS CI, systemd-networkd-tests.py may be running when this test is invoked. The networkd
 206          * test creates and removes many network interfaces, and may interfere with this test. */
 207         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
 208         FOREACH_DEVICE(e, d)
 209                 test_sd_device_one(d);
 210 }
 211
 212 TEST(sd_device_enumerator_subsystems) {
 213         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 214         sd_device *d;
 215
 216         assert_se(sd_device_enumerator_new(&e) >= 0);
 217         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 218         FOREACH_SUBSYSTEM(e, d)
 219                 test_sd_device_one(d);
 220 }
 221
 222 static void test_sd_device_enumerator_filter_subsystem_one(
 223                 const char *subsystem,
 224                 Hashmap *h,
 225                 unsigned *ret_n_new_dev,
 226                 unsigned *ret_n_removed_dev) {
 227
 228         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 229         unsigned n_new_dev = 0, n_removed_dev = 0;
 230         sd_device *d;
 231
 232         assert_se(sd_device_enumerator_new(&e) >= 0);
 233         assert_se(sd_device_enumerator_add_match_subsystem(e, subsystem, true) >= 0);
 234         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 235
 236         FOREACH_DEVICE(e, d) {
 237                 const char *syspath;
 238                 sd_device *t;
 239
 240                 assert_se(sd_device_get_syspath(d, &syspath) >= 0);
 241                 t = hashmap_remove(h, syspath);
 242
 243                 if (!t) {
 244                         log_warning("New device found: subsystem:%s syspath:%s", subsystem, syspath);
 245                         n_new_dev++;
 246                 }
 247
 248                 assert_se(!sd_device_unref(t));
 249         }
 250
 251         HASHMAP_FOREACH(d, h) {
 252                 const char *syspath;
 253
 254                 assert_se(sd_device_get_syspath(d, &syspath) >= 0);
 255                 log_warning("Device removed: subsystem:%s syspath:%s", subsystem, syspath);
 256                 n_removed_dev++;
 257
 258                 assert_se(!sd_device_unref(d));
 259         }
 260
 261         hashmap_free(h);
 262
 263         *ret_n_new_dev = n_new_dev;
 264         *ret_n_removed_dev = n_removed_dev;
 265 }
 266
 267 static bool test_sd_device_enumerator_filter_subsystem_trial(void) {
 268         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 269         _cleanup_(hashmap_freep) Hashmap *subsystems;
 270         unsigned n_new_dev = 0, n_removed_dev = 0;
 271         sd_device *d;
 272         Hashmap *h;
 273         char *s;
 274
 275         assert_se(subsystems = hashmap_new(&string_hash_ops));
 276         assert_se(sd_device_enumerator_new(&e) >= 0);
 277         /* See comments in TEST(sd_device_enumerator_devices). */
 278         assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
 279         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 280         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
 281
 282         FOREACH_DEVICE(e, d) {
 283                 const char *syspath, *subsystem;
 284                 int r;
 285
 286                 assert_se(sd_device_get_syspath(d, &syspath) >= 0);
 287
 288                 r = sd_device_get_subsystem(d, &subsystem);
 289                 assert_se(r >= 0 || r == -ENOENT);
 290                 if (r < 0)
 291                         continue;
 292
 293                 h = hashmap_get(subsystems, subsystem);
 294                 if (!h) {
 295                         char *str;
 296                         assert_se(str = strdup(subsystem));
 297                         assert_se(h = hashmap_new(&string_hash_ops));
 298                         assert_se(hashmap_put(subsystems, str, h) >= 0);
 299                 }
 300
 301                 assert_se(hashmap_put(h, syspath, d) >= 0);
 302                 assert_se(sd_device_ref(d));
 303
 304                 log_debug("Added subsystem:%s syspath:%s", subsystem, syspath);
 305         }
 306
 307         while ((h = hashmap_steal_first_key_and_value(subsystems, (void**) &s))) {
 308                 unsigned n, m;
 309
 310                 test_sd_device_enumerator_filter_subsystem_one(s, TAKE_PTR(h), &n, &m);
 311                 free(s);
 312
 313                 n_new_dev += n;
 314                 n_removed_dev += m;
 315         }
 316
 317         if (n_new_dev > 0)
 318                 log_warning("%u new devices are found in re-scan", n_new_dev);
 319         if (n_removed_dev > 0)
 320                 log_warning("%u devices removed in re-scan", n_removed_dev);
 321
 322         return n_new_dev + n_removed_dev == 0;
 323 }
 324
 325 static bool test_sd_device_enumerator_filter_subsystem_trial_many(void) {
 326         for (unsigned i = 0; i < 20; i++) {
 327                 log_debug("%s(): trial %u", __func__, i);
 328                 if (test_sd_device_enumerator_filter_subsystem_trial())
 329                         return true;
 330         }
 331
 332         return false;
 333 }
 334
 335 static int on_inotify(sd_event_source *s, const struct inotify_event *event, void *userdata) {
 336         if (test_sd_device_enumerator_filter_subsystem_trial_many())
 337                 return sd_event_exit(sd_event_source_get_event(s), 0);
 338
 339         return sd_event_exit(sd_event_source_get_event(s), -EBUSY);
 340 }
 341
 342 TEST(sd_device_enumerator_filter_subsystem) {
 343         /* The test test_sd_device_enumerator_filter_subsystem_trial() is quite racy. Let's run the function
 344          * several times after the udev queue becomes empty. */
 345
 346         if (!udev_available() || (access("/run/udev", F_OK) < 0 && errno == ENOENT)) {
 347                 assert_se(test_sd_device_enumerator_filter_subsystem_trial_many());
 348                 return;
 349         }
 350
 351         _cleanup_(sd_event_unrefp) sd_event *event = NULL;
 352         assert_se(sd_event_default(&event) >= 0);
 353         assert_se(sd_event_add_inotify(event, NULL, "/run/udev" , IN_DELETE, on_inotify, NULL) >= 0);
 354
 355         if (udev_queue_is_empty() == 0) {
 356                 log_debug("udev queue is not empty, waiting for all queued events to be processed.");
 357                 assert_se(sd_event_loop(event) >= 0);
 358         } else
 359                 assert_se(test_sd_device_enumerator_filter_subsystem_trial_many());
 360 }
 361
 362 TEST(sd_device_enumerator_add_match_sysattr) {
 363         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 364         sd_device *dev;
 365         int ifindex;
 366
 367         assert_se(sd_device_enumerator_new(&e) >= 0);
 368         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 369         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", true) >= 0);
 370         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "1", true) >= 0);
 371         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "hoge", true) >= 0);
 372         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "foo", true) >= 0);
 373         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "bar", false) >= 0);
 374         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "baz", false) >= 0);
 375
 376         dev = sd_device_enumerator_get_device_first(e);
 377         assert_se(dev);
 378         assert_se(sd_device_get_ifindex(dev, &ifindex) >= 0);
 379         assert_se(ifindex == 1);
 380
 381         assert_se(!sd_device_enumerator_get_device_next(e));
 382 }
 383
 384 TEST(sd_device_enumerator_add_match_property) {
 385         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 386         sd_device *dev;
 387         int ifindex;
 388
 389         assert_se(sd_device_enumerator_new(&e) >= 0);
 390         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 391         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", true) >= 0);
 392         assert_se(sd_device_enumerator_add_match_sysattr(e, "ifindex", "1", true) >= 0);
 393         assert_se(sd_device_enumerator_add_match_property(e, "IFINDE*", "1*") >= 0);
 394         assert_se(sd_device_enumerator_add_match_property(e, "IFINDE*", "hoge") >= 0);
 395         assert_se(sd_device_enumerator_add_match_property(e, "IFINDE*", NULL) >= 0);
 396         assert_se(sd_device_enumerator_add_match_property(e, "AAAAA", "BBBB") >= 0);
 397         assert_se(sd_device_enumerator_add_match_property(e, "FOOOO", NULL) >= 0);
 398
 399         dev = sd_device_enumerator_get_device_first(e);
 400         assert_se(dev);
 401         assert_se(sd_device_get_ifindex(dev, &ifindex) >= 0);
 402         assert_se(ifindex == 1);
 403 }
 404
 405 static void check_parent_match(sd_device_enumerator *e, sd_device *dev) {
 406         const char *syspath;
 407         bool found = false;
 408         sd_device *d;
 409
 410         assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
 411
 412         FOREACH_DEVICE(e, d) {
 413                 const char *s;
 414
 415                 assert_se(sd_device_get_syspath(d, &s) >= 0);
 416                 if (streq(s, syspath)) {
 417                         found = true;
 418                         break;
 419                 }
 420         }
 421
 422         if (!found) {
 423                 log_device_debug(dev, "not enumerated, already removed??");
 424                 /* If the original device not found, then the device should be already removed. */
 425                 assert_se(access(syspath, F_OK) < 0);
 426                 assert_se(errno == ENOENT);
 427         }
 428 }
 429
 430 TEST(sd_device_enumerator_add_match_parent) {
 431         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 432         sd_device *dev;
 433         int r;
 434
 435         assert_se(sd_device_enumerator_new(&e) >= 0);
 436         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 437         /* See comments in TEST(sd_device_enumerator_devices). */
 438         assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
 439         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 440         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
 441
 442         if (!slow_tests_enabled())
 443                 assert_se(sd_device_enumerator_add_match_subsystem(e, "block", true) >= 0);
 444
 445         FOREACH_DEVICE(e, dev) {
 446                 _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *p = NULL;
 447                 const char *syspath;
 448                 sd_device *parent;
 449
 450                 assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
 451
 452                 r = sd_device_get_parent(dev, &parent);
 453                 if (r < 0) {
 454                         assert_se(ERRNO_IS_DEVICE_ABSENT(r));
 455                         continue;
 456                 }
 457
 458                 log_debug("> %s", syspath);
 459
 460                 assert_se(sd_device_enumerator_new(&p) >= 0);
 461                 assert_se(sd_device_enumerator_allow_uninitialized(p) >= 0);
 462                 assert_se(sd_device_enumerator_add_match_parent(p, parent) >= 0);
 463
 464                 check_parent_match(p, dev);
 465
 466                 /* If the device does not have subsystem, then it is not enumerated. */
 467                 r = sd_device_get_subsystem(parent, NULL);
 468                 if (r < 0) {
 469                         assert_se(r == -ENOENT);
 470                         continue;
 471                 }
 472                 check_parent_match(p, parent);
 473         }
 474 }
 475
 476 TEST(sd_device_get_child) {
 477         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 478         sd_device *dev;
 479         int r;
 480
 481         assert_se(sd_device_enumerator_new(&e) >= 0);
 482         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 483         /* See comments in TEST(sd_device_enumerator_devices). */
 484         assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
 485         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 486         assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
 487
 488         if (!slow_tests_enabled())
 489                 assert_se(sd_device_enumerator_add_match_subsystem(e, "block", true) >= 0);
 490
 491         FOREACH_DEVICE(e, dev) {
 492                 const char *syspath, *parent_syspath, *expected_suffix, *suffix;
 493                 sd_device *parent, *child;
 494                 bool found = false;
 495
 496                 assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
 497
 498                 r = sd_device_get_parent(dev, &parent);
 499                 if (r < 0) {
 500                         assert_se(ERRNO_IS_DEVICE_ABSENT(r));
 501                         continue;
 502                 }
 503
 504                 assert_se(sd_device_get_syspath(parent, &parent_syspath) >= 0);
 505                 assert_se(expected_suffix = path_startswith(syspath, parent_syspath));
 506
 507                 log_debug("> %s", syspath);
 508
 509                 FOREACH_DEVICE_CHILD_WITH_SUFFIX(parent, child, suffix) {
 510                         const char *s;
 511
 512                         assert_se(child);
 513                         assert_se(suffix);
 514
 515                         if (!streq(suffix, expected_suffix))
 516                                 continue;
 517
 518                         assert_se(sd_device_get_syspath(child, &s) >= 0);
 519                         assert_se(streq(s, syspath));
 520                         found = true;
 521                         break;
 522                 }
 523                 assert_se(found);
 524         }
 525 }
 526
 527 TEST(sd_device_new_from_nulstr) {
 528         const char *devlinks =
 529                 "/dev/disk/by-partuuid/1290d63a-42cc-4c71-b87c-xxxxxxxxxxxx\0"
 530                 "/dev/disk/by-path/pci-0000:00:0f.0-scsi-0:0:0:0-part3\0"
 531                 "/dev/disk/by-label/Arch\\x20Linux\0"
 532                 "/dev/disk/by-uuid/a07b87e5-4af5-4a59-bde9-yyyyyyyyyyyy\0"
 533                 "/dev/disk/by-partlabel/Arch\\x20Linux\0"
 534                 "\0";
 535
 536         _cleanup_(sd_device_unrefp) sd_device *device = NULL, *from_nulstr = NULL;
 537         _cleanup_free_ char *nulstr_copy = NULL;
 538         const char *nulstr;
 539         size_t len;
 540
 541         assert_se(sd_device_new_from_syspath(&device, "/sys/class/net/lo") >= 0);
 542
 543         /* Yeah, of course, setting devlink to the loopback interface is nonsense. But this is just a
 544          * test for generating and parsing nulstr. For issue #17772. */
 545         NULSTR_FOREACH(devlink, devlinks) {
 546                 log_device_info(device, "setting devlink: %s", devlink);
 547                 assert_se(device_add_devlink(device, devlink) >= 0);
 548                 assert_se(set_contains(device->devlinks, devlink));
 549         }
 550
 551         /* For issue #23799 */
 552         assert_se(device_add_tag(device, "tag1", false) >= 0);
 553         assert_se(device_add_tag(device, "tag2", false) >= 0);
 554         assert_se(device_add_tag(device, "current-tag1", true) >= 0);
 555         assert_se(device_add_tag(device, "current-tag2", true) >= 0);
 556
 557         /* These properties are necessary for device_new_from_nulstr(). See device_verify(). */
 558         assert_se(device_add_property_internal(device, "SEQNUM", "1") >= 0);
 559         assert_se(device_add_property_internal(device, "ACTION", "change") >= 0);
 560
 561         assert_se(device_get_properties_nulstr(device, &nulstr, &len) >= 0);
 562         assert_se(nulstr_copy = newdup(char, nulstr, len));
 563         assert_se(device_new_from_nulstr(&from_nulstr, nulstr_copy, len) >= 0);
 564
 565         assert_se(sd_device_has_tag(from_nulstr, "tag1") == 1);
 566         assert_se(sd_device_has_tag(from_nulstr, "tag2") == 1);
 567         assert_se(sd_device_has_tag(from_nulstr, "current-tag1") == 1);
 568         assert_se(sd_device_has_tag(from_nulstr, "current-tag2") == 1);
 569         assert_se(sd_device_has_current_tag(from_nulstr, "tag1") == 0);
 570         assert_se(sd_device_has_current_tag(from_nulstr, "tag2") == 0);
 571         assert_se(sd_device_has_current_tag(from_nulstr, "current-tag1") == 1);
 572         assert_se(sd_device_has_current_tag(from_nulstr, "current-tag2") == 1);
 573
 574         NULSTR_FOREACH(devlink, devlinks) {
 575                 log_device_info(from_nulstr, "checking devlink: %s", devlink);
 576                 assert_se(set_contains(from_nulstr->devlinks, devlink));
 577         }
 578 }
 579
 580 TEST(sd_device_new_from_path) {
 581         _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
 582         _cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
 583         sd_device *dev;
 584         int r;
 585
 586         assert_se(mkdtemp_malloc("/tmp/test-sd-device.XXXXXXX", &tmpdir) >= 0);
 587
 588         assert_se(sd_device_enumerator_new(&e) >= 0);
 589         assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
 590         assert_se(sd_device_enumerator_add_match_subsystem(e, "block", true) >= 0);
 591         assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
 592         assert_se(sd_device_enumerator_add_match_property(e, "DEVNAME", "*") >= 0);
 593
 594         FOREACH_DEVICE(e, dev) {
 595                 _cleanup_(sd_device_unrefp) sd_device *d = NULL;
 596                 const char *syspath, *devpath, *sysname, *s;
 597                 _cleanup_free_ char *path = NULL;
 598
 599                 assert_se(sd_device_get_sysname(dev, &sysname) >= 0);
 600
 601                 log_debug("%s(%s)", __func__, sysname);
 602
 603                 assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
 604                 assert_se(sd_device_new_from_path(&d, syspath) >= 0);
 605                 assert_se(sd_device_get_syspath(d, &s) >= 0);
 606                 assert_se(streq(s, syspath));
 607                 d = sd_device_unref(d);
 608
 609                 assert_se(sd_device_get_devname(dev, &devpath) >= 0);
 610                 r = sd_device_new_from_path(&d, devpath);
 611                 if (r >= 0) {
 612                         assert_se(sd_device_get_syspath(d, &s) >= 0);
 613                         assert_se(streq(s, syspath));
 614                         d = sd_device_unref(d);
 615                 } else
 616                         assert_se(r == -ENODEV || ERRNO_IS_PRIVILEGE(r));
 617
 618                 assert_se(path = path_join(tmpdir, sysname));
 619                 assert_se(symlink(syspath, path) >= 0);
 620                 assert_se(sd_device_new_from_path(&d, path) >= 0);
 621                 assert_se(sd_device_get_syspath(d, &s) >= 0);
 622                 assert_se(streq(s, syspath));
 623         }
 624 }
 625
 626 static void test_devname_from_devnum_one(const char *path) {
 627         _cleanup_free_ char *resolved = NULL;
 628         struct stat st;
 629
 630         log_debug("> %s", path);
 631
 632         if (stat(path, &st) < 0) {
 633                 assert_se(errno == ENOENT);
 634                 log_notice("Path %s not found, skipping test", path);
 635                 return;
 636         }
 637
 638         assert_se(devname_from_devnum(st.st_mode, st.st_rdev, &resolved) >= 0);
 639         assert_se(path_equal(path, resolved));
 640         resolved = mfree(resolved);
 641         assert_se(devname_from_stat_rdev(&st, &resolved) >= 0);
 642         assert_se(path_equal(path, resolved));
 643 }
 644
 645 TEST(devname_from_devnum) {
 646         test_devname_from_devnum_one("/dev/null");
 647         test_devname_from_devnum_one("/dev/zero");
 648         test_devname_from_devnum_one("/dev/full");
 649         test_devname_from_devnum_one("/dev/random");
 650         test_devname_from_devnum_one("/dev/urandom");
 651         test_devname_from_devnum_one("/dev/tty");
 652
 653         if (is_device_node("/run/systemd/inaccessible/blk") > 0) {
 654                 test_devname_from_devnum_one("/run/systemd/inaccessible/chr");
 655                 test_devname_from_devnum_one("/run/systemd/inaccessible/blk");
 656         }
 657 }
 658
 659 DEFINE_TEST_MAIN(LOG_INFO);