#include "nulstr-util.h"
#include "path-util.h"
#include "rm-rf.h"
+#include "stat-util.h"
#include "string-util.h"
#include "tests.h"
#include "time-util.h"
#include "tmpfile-util.h"
+#include "udev-util.h"
static void test_sd_device_one(sd_device *d) {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
} else
assert_se(r == -ENOENT);
- r = sd_device_get_sysattr_value(d, "name_assign_type", &val);
- assert_se(r >= 0 || ERRNO_IS_PRIVILEGE(r) || IN_SET(r, -ENOENT, -EINVAL));
-
- if (r > 0) {
+ r = sd_device_get_sysattr_value(d, "nsid", NULL);
+ if (r >= 0) {
unsigned x;
- assert_se(device_get_sysattr_unsigned(d, "name_assign_type", NULL) >= 0);
- assert_se(device_get_sysattr_unsigned(d, "name_assign_type", &x) >= 0);
- }
+ assert_se(device_get_sysattr_unsigned(d, "nsid", NULL) >= 0);
+ r = device_get_sysattr_unsigned(d, "nsid", &x);
+ assert_se(r >= 0);
+ assert_se((x > 0) == (r > 0));
+ } else
+ assert_se(ERRNO_IS_PRIVILEGE(r) || IN_SET(r, -ENOENT, -EINVAL));
}
TEST(sd_device_enumerator_devices) {
*ret_n_removed_dev = n_removed_dev;
}
-TEST(sd_device_enumerator_filter_subsystem) {
+static bool test_sd_device_enumerator_filter_subsystem_trial(void) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
_cleanup_(hashmap_freep) Hashmap *subsystems;
unsigned n_new_dev = 0, n_removed_dev = 0;
if (n_removed_dev > 0)
log_warning("%u devices removed in re-scan", n_removed_dev);
- /* Assume that not so many devices are plugged or unplugged. */
- assert_se(n_new_dev + n_removed_dev <= 10);
+ return n_new_dev + n_removed_dev == 0;
+}
+
+static bool test_sd_device_enumerator_filter_subsystem_trial_many(void) {
+ for (unsigned i = 0; i < 20; i++) {
+ log_debug("%s(): trial %u", __func__, i);
+ if (test_sd_device_enumerator_filter_subsystem_trial())
+ return true;
+ }
+
+ return false;
+}
+
+static int on_inotify(sd_event_source *s, const struct inotify_event *event, void *userdata) {
+ if (test_sd_device_enumerator_filter_subsystem_trial_many())
+ return sd_event_exit(sd_event_source_get_event(s), 0);
+
+ return sd_event_exit(sd_event_source_get_event(s), -EBUSY);
+}
+
+TEST(sd_device_enumerator_filter_subsystem) {
+ /* The test test_sd_device_enumerator_filter_subsystem_trial() is quite racy. Let's run the function
+ * several times after the udev queue becomes empty. */
+
+ if (!udev_available() || (access("/run/udev", F_OK) < 0 && errno == ENOENT)) {
+ assert_se(test_sd_device_enumerator_filter_subsystem_trial_many());
+ return;
+ }
+
+ _cleanup_(sd_event_unrefp) sd_event *event = NULL;
+ assert_se(sd_event_default(&event) >= 0);
+ assert_se(sd_event_add_inotify(event, NULL, "/run/udev" , IN_DELETE, on_inotify, NULL) >= 0);
+
+ if (udev_queue_is_empty() == 0) {
+ log_debug("udev queue is not empty, waiting for all queued events to be processed.");
+ assert_se(sd_event_loop(event) >= 0);
+ } else
+ assert_se(test_sd_device_enumerator_filter_subsystem_trial_many());
}
TEST(sd_device_enumerator_add_match_sysattr) {
assert_se(ifindex == 1);
}
+static void check_parent_match(sd_device_enumerator *e, sd_device *dev) {
+ const char *syspath;
+ bool found = false;
+ sd_device *d;
+
+ assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
+
+ FOREACH_DEVICE(e, d) {
+ const char *s;
+
+ assert_se(sd_device_get_syspath(d, &s) >= 0);
+ if (streq(s, syspath)) {
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ log_device_debug(dev, "not enumerated, already removed??");
+ /* If the original device not found, then the device should be already removed. */
+ assert_se(access(syspath, F_OK) < 0);
+ assert_se(errno == ENOENT);
+ }
+}
+
+TEST(sd_device_enumerator_add_match_parent) {
+ _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
+ sd_device *dev;
+ int r;
+
+ assert_se(sd_device_enumerator_new(&e) >= 0);
+ assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
+ /* See comments in TEST(sd_device_enumerator_devices). */
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
+ assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
+
+ if (!slow_tests_enabled())
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "block", true) >= 0);
+
+ FOREACH_DEVICE(e, dev) {
+ _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *p = NULL;
+ const char *syspath;
+ sd_device *parent;
+
+ assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
+
+ r = sd_device_get_parent(dev, &parent);
+ if (r < 0) {
+ assert_se(ERRNO_IS_DEVICE_ABSENT(r));
+ continue;
+ }
+
+ log_debug("> %s", syspath);
+
+ assert_se(sd_device_enumerator_new(&p) >= 0);
+ assert_se(sd_device_enumerator_allow_uninitialized(p) >= 0);
+ assert_se(sd_device_enumerator_add_match_parent(p, parent) >= 0);
+
+ check_parent_match(p, dev);
+
+ /* If the device does not have subsystem, then it is not enumerated. */
+ r = sd_device_get_subsystem(parent, NULL);
+ if (r < 0) {
+ assert_se(r == -ENOENT);
+ continue;
+ }
+ check_parent_match(p, parent);
+ }
+}
+
+TEST(sd_device_get_child) {
+ _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
+ sd_device *dev;
+ int r;
+
+ assert_se(sd_device_enumerator_new(&e) >= 0);
+ assert_se(sd_device_enumerator_allow_uninitialized(e) >= 0);
+ /* See comments in TEST(sd_device_enumerator_devices). */
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "bdi", false) >= 0);
+ assert_se(sd_device_enumerator_add_nomatch_sysname(e, "loop*") >= 0);
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "net", false) >= 0);
+
+ if (!slow_tests_enabled())
+ assert_se(sd_device_enumerator_add_match_subsystem(e, "block", true) >= 0);
+
+ FOREACH_DEVICE(e, dev) {
+ const char *syspath, *parent_syspath, *expected_suffix, *suffix;
+ sd_device *parent, *child;
+ bool found = false;
+
+ assert_se(sd_device_get_syspath(dev, &syspath) >= 0);
+
+ r = sd_device_get_parent(dev, &parent);
+ if (r < 0) {
+ assert_se(ERRNO_IS_DEVICE_ABSENT(r));
+ continue;
+ }
+
+ assert_se(sd_device_get_syspath(parent, &parent_syspath) >= 0);
+ assert_se(expected_suffix = path_startswith(syspath, parent_syspath));
+
+ log_debug("> %s", syspath);
+
+ FOREACH_DEVICE_CHILD_WITH_SUFFIX(parent, child, suffix) {
+ const char *s;
+
+ assert_se(child);
+ assert_se(suffix);
+
+ if (!streq(suffix, expected_suffix))
+ continue;
+
+ assert_se(sd_device_get_syspath(child, &s) >= 0);
+ assert_se(streq(s, syspath));
+ found = true;
+ break;
+ }
+ assert_se(found);
+ }
+}
+
TEST(sd_device_new_from_nulstr) {
const char *devlinks =
"/dev/disk/by-partuuid/1290d63a-42cc-4c71-b87c-xxxxxxxxxxxx\0"
_cleanup_(sd_device_unrefp) sd_device *device = NULL, *from_nulstr = NULL;
_cleanup_free_ char *nulstr_copy = NULL;
- const char *devlink, *nulstr;
+ const char *nulstr;
size_t len;
assert_se(sd_device_new_from_syspath(&device, "/sys/class/net/lo") >= 0);
}
}
+static void test_devname_from_devnum_one(const char *path) {
+ _cleanup_free_ char *resolved = NULL;
+ struct stat st;
+
+ log_debug("> %s", path);
+
+ if (stat(path, &st) < 0) {
+ assert_se(errno == ENOENT);
+ log_notice("Path %s not found, skipping test", path);
+ return;
+ }
+
+ assert_se(devname_from_devnum(st.st_mode, st.st_rdev, &resolved) >= 0);
+ assert_se(path_equal(path, resolved));
+ resolved = mfree(resolved);
+ assert_se(devname_from_stat_rdev(&st, &resolved) >= 0);
+ assert_se(path_equal(path, resolved));
+}
+
+TEST(devname_from_devnum) {
+ test_devname_from_devnum_one("/dev/null");
+ test_devname_from_devnum_one("/dev/zero");
+ test_devname_from_devnum_one("/dev/full");
+ test_devname_from_devnum_one("/dev/random");
+ test_devname_from_devnum_one("/dev/urandom");
+ test_devname_from_devnum_one("/dev/tty");
+
+ if (is_device_node("/run/systemd/inaccessible/blk") > 0) {
+ test_devname_from_devnum_one("/run/systemd/inaccessible/chr");
+ test_devname_from_devnum_one("/run/systemd/inaccessible/blk");
+ }
+}
+
DEFINE_TEST_MAIN(LOG_INFO);
projects / thirdparty / systemd.git / blobdiff