Merge branch 'parabola' into lukeshu/premove

# Conflicts:
#	Makefile.am

1 files changed, 109 insertions, 158 deletions

diff --git a/src/test/test-libudev.c b/src/test/test-libudev.c
index a7eb60e8cf..e28de9b37b 100644
--- a/src/test/test-libudev.c
+++ b/src/test/test-libudev.c
@@ -24,170 +24,140 @@
 
 #include "libudev.h"
 
+#include "fd-util.h"
+#include "log.h"
 #include "stdio-util.h"
 #include "string-util.h"
 #include "udev-util.h"
 #include "util.h"
 
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-
 static void print_device(struct udev_device *device) {
         const char *str;
         dev_t devnum;
         int count;
         struct udev_list_entry *list_entry;
 
-        printf("*** device: %p ***\n", device);
+        log_info("*** device: %p ***", device);
         str = udev_device_get_action(device);
         if (str != NULL)
-                printf("action:    '%s'\n", str);
+                log_info("action:    '%s'", str);
 
         str = udev_device_get_syspath(device);
-        printf("syspath:   '%s'\n", str);
+        log_info("syspath:   '%s'", str);
 
         str = udev_device_get_sysname(device);
-        printf("sysname:   '%s'\n", str);
+        log_info("sysname:   '%s'", str);
 
         str = udev_device_get_sysnum(device);
         if (str != NULL)
-                printf("sysnum:    '%s'\n", str);
+                log_info("sysnum:    '%s'", str);
 
         str = udev_device_get_devpath(device);
-        printf("devpath:   '%s'\n", str);
+        log_info("devpath:   '%s'", str);
 
         str = udev_device_get_subsystem(device);
         if (str != NULL)
-                printf("subsystem: '%s'\n", str);
+                log_info("subsystem: '%s'", str);
 
         str = udev_device_get_devtype(device);
         if (str != NULL)
-                printf("devtype:   '%s'\n", str);
+                log_info("devtype:   '%s'", str);
 
         str = udev_device_get_driver(device);
         if (str != NULL)
-                printf("driver:    '%s'\n", str);
+                log_info("driver:    '%s'", str);
 
         str = udev_device_get_devnode(device);
         if (str != NULL)
-                printf("devname:   '%s'\n", str);
+                log_info("devname:   '%s'", str);
 
         devnum = udev_device_get_devnum(device);
         if (major(devnum) > 0)
-                printf("devnum:    %u:%u\n", major(devnum), minor(devnum));
+                log_info("devnum:    %u:%u", major(devnum), minor(devnum));
 
         count = 0;
         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device)) {
-                printf("link:      '%s'\n", udev_list_entry_get_name(list_entry));
+                log_info("link:      '%s'", udev_list_entry_get_name(list_entry));
                 count++;
         }
         if (count > 0)
-                printf("found %i links\n", count);
+                log_info("found %i links", count);
 
         count = 0;
         udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device)) {
-                printf("property:  '%s=%s'\n",
+                log_info("property:  '%s=%s'",
                        udev_list_entry_get_name(list_entry),
                        udev_list_entry_get_value(list_entry));
                 count++;
         }
         if (count > 0)
-                printf("found %i properties\n", count);
+                log_info("found %i properties", count);
 
         str = udev_device_get_property_value(device, "MAJOR");
         if (str != NULL)
-                printf("MAJOR: '%s'\n", str);
+                log_info("MAJOR: '%s'", str);
 
         str = udev_device_get_sysattr_value(device, "dev");
         if (str != NULL)
-                printf("attr{dev}: '%s'\n", str);
-
-        printf("\n");
+                log_info("attr{dev}: '%s'", str);
 }
 
-static int test_device(struct udev *udev, const char *syspath) {
+static void test_device(struct udev *udev, const char *syspath) {
         _cleanup_udev_device_unref_ struct udev_device *device;
 
-        printf("looking at device: %s\n", syspath);
+        log_info("looking at device: %s", syspath);
         device = udev_device_new_from_syspath(udev, syspath);
-        if (device == NULL) {
-                printf("no device found\n");
-                return -1;
-        }
-        print_device(device);
-
-        return 0;
+        if (device == NULL)
+                log_warning_errno(errno, "udev_device_new_from_syspath: %m");
+        else
+                print_device(device);
 }
 
-static int test_device_parents(struct udev *udev, const char *syspath) {
+static void test_device_parents(struct udev *udev, const char *syspath) {
         _cleanup_udev_device_unref_ struct udev_device *device;
         struct udev_device *device_parent;
 
-        printf("looking at device: %s\n", syspath);
+        log_info("looking at device: %s", syspath);
         device = udev_device_new_from_syspath(udev, syspath);
         if (device == NULL)
-                return -1;
+                return;
 
-        printf("looking at parents\n");
+        log_info("looking at parents");
         device_parent = device;
         do {
                 print_device(device_parent);
                 device_parent = udev_device_get_parent(device_parent);
         } while (device_parent != NULL);
 
-        printf("looking at parents again\n");
+        log_info("looking at parents again");
         device_parent = device;
         do {
                 print_device(device_parent);
                 device_parent = udev_device_get_parent(device_parent);
         } while (device_parent != NULL);
-
-        return 0;
 }
 
-static int test_device_devnum(struct udev *udev) {
+static void test_device_devnum(struct udev *udev) {
         dev_t devnum = makedev(1, 3);
-        struct udev_device *device;
+        _cleanup_udev_device_unref_ struct udev_device *device;
 
-        printf("looking up device: %u:%u\n", major(devnum), minor(devnum));
+        log_info("looking up device: %u:%u", major(devnum), minor(devnum));
         device = udev_device_new_from_devnum(udev, 'c', devnum);
         if (device == NULL)
-                return -1;
-        print_device(device);
-        udev_device_unref(device);
-        return 0;
+                log_warning_errno(errno, "udev_device_new_from_devnum: %m");
+        else
+                print_device(device);
 }
 
-static int test_device_subsys_name(struct udev *udev) {
-        struct udev_device *device;
-
-        printf("looking up device: 'block':'sda'\n");
-        device = udev_device_new_from_subsystem_sysname(udev, "block", "sda");
-        if (device == NULL)
-                return -1;
-        print_device(device);
-        udev_device_unref(device);
-
-        printf("looking up device: 'subsystem':'pci'\n");
-        device = udev_device_new_from_subsystem_sysname(udev, "subsystem", "pci");
-        if (device == NULL)
-                return -1;
-        print_device(device);
-        udev_device_unref(device);
-
-        printf("looking up device: 'drivers':'scsi:sd'\n");
-        device = udev_device_new_from_subsystem_sysname(udev, "drivers", "scsi:sd");
-        if (device == NULL)
-                return -1;
-        print_device(device);
-        udev_device_unref(device);
+static void test_device_subsys_name(struct udev *udev, const char *subsys, const char *dev) {
+        _cleanup_udev_device_unref_ struct udev_device *device;
 
-        printf("looking up device: 'module':'printk'\n");
-        device = udev_device_new_from_subsystem_sysname(udev, "module", "printk");
+        log_info("looking up device: '%s:%s'", subsys, dev);
+        device = udev_device_new_from_subsystem_sysname(udev, subsys, dev);
         if (device == NULL)
-                return -1;
-        print_device(device);
-        udev_device_unref(device);
-        return 0;
+                log_warning_errno(errno, "udev_device_new_from_subsystem_sysname: %m");
+        else
+                print_device(device);
 }
 
 static int test_enumerate_print_list(struct udev_enumerate *enumerate) {
@@ -200,63 +170,45 @@ static int test_enumerate_print_list(struct udev_enumerate *enumerate) {
                 device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
                                                       udev_list_entry_get_name(list_entry));
                 if (device != NULL) {
-                        printf("device: '%s' (%s)\n",
-                               udev_device_get_syspath(device),
-                               udev_device_get_subsystem(device));
+                        log_info("device: '%s' (%s)",
+                                 udev_device_get_syspath(device),
+                                 udev_device_get_subsystem(device));
                         udev_device_unref(device);
                         count++;
                 }
         }
-        printf("found %i devices\n\n", count);
+        log_info("found %i devices", count);
         return count;
 }
 
-static int test_monitor(struct udev *udev) {
-        struct udev_monitor *udev_monitor = NULL;
-        int fd_ep;
-        int fd_udev = -1;
-        struct epoll_event ep_udev, ep_stdin;
+static void test_monitor(struct udev *udev) {
+        _cleanup_udev_monitor_unref_ struct udev_monitor *udev_monitor;
+        _cleanup_close_ int fd_ep;
+        int fd_udev;
+        struct epoll_event ep_udev = {
+                .events = EPOLLIN,
+        }, ep_stdin = {
+                .events = EPOLLIN,
+                .data.fd = STDIN_FILENO,
+        };
 
         fd_ep = epoll_create1(EPOLL_CLOEXEC);
-        if (fd_ep < 0) {
-                printf("error creating epoll fd: %m\n");
-                goto out;
-        }
+        assert_se(fd_ep >= 0);
 
         udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
-        if (udev_monitor == NULL) {
-                printf("no socket\n");
-                goto out;
-        }
+        assert_se(udev_monitor != NULL);
+
         fd_udev = udev_monitor_get_fd(udev_monitor);
+        ep_udev.data.fd = fd_udev;
 
-        if (udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) < 0 ||
-            udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL) < 0 ||
-            udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device") < 0) {
-                printf("filter failed\n");
-                goto out;
-        }
+        assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) >= 0);
+        assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL) >= 0);
+        assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device") >= 0);
 
-        if (udev_monitor_enable_receiving(udev_monitor) < 0) {
-                printf("bind failed\n");
-                goto out;
-        }
+        assert_se(udev_monitor_enable_receiving(udev_monitor) >= 0);
 
-        memzero(&ep_udev, sizeof(struct epoll_event));
-        ep_udev.events = EPOLLIN;
-        ep_udev.data.fd = fd_udev;
-        if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) {
-                printf("fail to add fd to epoll: %m\n");
-                goto out;
-        }
-
-        memzero(&ep_stdin, sizeof(struct epoll_event));
-        ep_stdin.events = EPOLLIN;
-        ep_stdin.data.fd = STDIN_FILENO;
-        if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) < 0) {
-                printf("fail to add fd to epoll: %m\n");
-                goto out;
-        }
+        assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) >= 0);
+        assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) >= 0);
 
         for (;;) {
                 int fdcount;
@@ -265,7 +217,7 @@ static int test_monitor(struct udev *udev) {
                 int i;
 
                 printf("waiting for events from udev, press ENTER to exit\n");
-                fdcount = epoll_wait(fd_ep, ev, ARRAY_SIZE(ev), -1);
+                fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
                 printf("epoll fd count: %i\n", fdcount);
 
                 for (i = 0; i < fdcount; i++) {
@@ -279,36 +231,29 @@ static int test_monitor(struct udev *udev) {
                                 udev_device_unref(device);
                         } else if (ev[i].data.fd == STDIN_FILENO && ev[i].events & EPOLLIN) {
                                 printf("exiting loop\n");
-                                goto out;
+                                return;
                         }
                 }
         }
-out:
-        if (fd_ep >= 0)
-                close(fd_ep);
-        udev_monitor_unref(udev_monitor);
-        return 0;
 }
 
-static int test_queue(struct udev *udev) {
+static void test_queue(struct udev *udev) {
         struct udev_queue *udev_queue;
+        bool empty;
 
         udev_queue = udev_queue_new(udev);
-        if (udev_queue == NULL)
-                return -1;
-
-        if (udev_queue_get_queue_is_empty(udev_queue))
-                printf("queue is empty\n");
+        assert_se(udev_queue);
 
+        empty = udev_queue_get_queue_is_empty(udev_queue);
+        log_info("queue is %s", empty ? "empty" : "not empty");
         udev_queue_unref(udev_queue);
-        return 0;
 }
 
 static int test_enumerate(struct udev *udev, const char *subsystem) {
         struct udev_enumerate *udev_enumerate;
         int r;
 
-        printf("enumerate '%s'\n", subsystem == NULL ? "<all>" : subsystem);
+        log_info("enumerate '%s'", subsystem == NULL ? "<all>" : subsystem);
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -317,7 +262,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'net' + duplicated scan + null + zero\n");
+        log_info("enumerate 'net' + duplicated scan + null + zero");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -337,7 +282,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'block'\n");
+        log_info("enumerate 'block'");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -351,7 +296,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'not block'\n");
+        log_info("enumerate 'not block'");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -360,7 +305,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'pci, mem, vc'\n");
+        log_info("enumerate 'pci, mem, vc'");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -371,7 +316,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'subsystem'\n");
+        log_info("enumerate 'subsystem'");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -379,7 +324,7 @@ static int test_enumerate(struct udev *udev, const char *subsystem) {
         test_enumerate_print_list(udev_enumerate);
         udev_enumerate_unref(udev_enumerate);
 
-        printf("enumerate 'property IF_FS_*=filesystem'\n");
+        log_info("enumerate 'property IF_FS_*=filesystem'");
         udev_enumerate = udev_enumerate_new(udev);
         if (udev_enumerate == NULL)
                 return -1;
@@ -397,32 +342,32 @@ static void test_hwdb(struct udev *udev, const char *modalias) {
         hwdb = udev_hwdb_new(udev);
 
         udev_list_entry_foreach(entry, udev_hwdb_get_properties_list_entry(hwdb, modalias, 0))
-                printf("'%s'='%s'\n", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry));
-        printf("\n");
+                log_info("'%s'='%s'", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry));
 
         hwdb = udev_hwdb_unref(hwdb);
         assert_se(hwdb == NULL);
 }
 
 int main(int argc, char *argv[]) {
-        struct udev *udev = NULL;
+        _cleanup_udev_unref_ struct udev *udev = NULL;
+        bool arg_monitor = false;
         static const struct option options[] = {
-                { "syspath", required_argument, NULL, 'p' },
+                { "syspath",   required_argument, NULL, 'p' },
                 { "subsystem", required_argument, NULL, 's' },
-                { "debug", no_argument, NULL, 'd' },
-                { "help", no_argument, NULL, 'h' },
-                { "version", no_argument, NULL, 'V' },
+                { "debug",     no_argument,       NULL, 'd' },
+                { "help",      no_argument,       NULL, 'h' },
+                { "version",   no_argument,       NULL, 'V' },
+                { "monitor",   no_argument,       NULL, 'm' },
                 {}
         };
         const char *syspath = "/devices/virtual/mem/null";
         const char *subsystem = NULL;
-        char path[1024];
         int c;
 
         udev = udev_new();
-        printf("context: %p\n", udev);
+        log_info("context: %p", udev);
         if (udev == NULL) {
-                printf("no context\n");
+                log_info("no context");
                 return 1;
         }
 
@@ -444,14 +389,18 @@ int main(int argc, char *argv[]) {
 
                 case 'h':
                         printf("--debug --syspath= --subsystem= --help\n");
-                        goto out;
+                        return EXIT_SUCCESS;
 
                 case 'V':
                         printf("%s\n", VERSION);
-                        goto out;
+                        return EXIT_SUCCESS;
+
+                case 'm':
+                        arg_monitor = true;
+                        break;
 
                 case '?':
-                        goto out;
+                        return EXIT_FAILURE;
 
                 default:
                         assert_not_reached("Unhandled option code.");
@@ -459,14 +408,16 @@ int main(int argc, char *argv[]) {
 
 
         /* add sys path if needed */
-        if (!startswith(syspath, "/sys")) {
-                xsprintf(path, "/sys/%s", syspath);
-                syspath = path;
-        }
+        if (!startswith(syspath, "/sys"))
+                syspath = strjoina("/sys/", syspath);
 
         test_device(udev, syspath);
         test_device_devnum(udev);
-        test_device_subsys_name(udev);
+        test_device_subsys_name(udev, "block", "sda");
+        test_device_subsys_name(udev, "subsystem", "pci");
+        test_device_subsys_name(udev, "drivers", "scsi:sd");
+        test_device_subsys_name(udev, "module", "printk");
+
         test_device_parents(udev, syspath);
 
         test_enumerate(udev, subsystem);
@@ -475,8 +426,8 @@ int main(int argc, char *argv[]) {
 
         test_hwdb(udev, "usb:v0D50p0011*");
 
-        test_monitor(udev);
-out:
-        udev_unref(udev);
-        return 0;
+        if (arg_monitor)
+                test_monitor(udev);
+
+        return EXIT_SUCCESS;
 }