chiark / gitweb /
Merge keymap building in the top-level Makefile.am.
[elogind.git] / libudev / libudev-enumerate.c
index 31e8e2e..e30a406 100644 (file)
 #include <string.h>
 #include <dirent.h>
 #include <fnmatch.h>
+#include <stdbool.h>
 #include <sys/stat.h>
+#include <sys/param.h>
 
 #include "libudev.h"
 #include "libudev-private.h"
 
-static int devices_sort(struct udev_enumerate *udev_enumerate);
-
 /**
  * SECTION:libudev-enumerate
  * @short_description: lookup and sort sys devices
@@ -32,6 +32,11 @@ static int devices_sort(struct udev_enumerate *udev_enumerate);
  * and return a sorted list of devices.
  */
 
+struct syspath {
+       char *syspath;
+       size_t len;
+};
+
 /**
  * udev_enumerate:
  *
@@ -44,9 +49,13 @@ struct udev_enumerate {
        struct udev_list_node sysattr_nomatch_list;
        struct udev_list_node subsystem_match_list;
        struct udev_list_node subsystem_nomatch_list;
+       struct udev_list_node sysname_match_list;
        struct udev_list_node properties_match_list;
        struct udev_list_node devices_list;
-       int devices_sorted;
+       struct syspath *devices;
+       unsigned int devices_cur;
+       unsigned int devices_max;
+       bool devices_uptodate:1;
 };
 
 /**
@@ -64,12 +73,13 @@ struct udev_enumerate *udev_enumerate_new(struct udev *udev)
                return NULL;
        udev_enumerate->refcount = 1;
        udev_enumerate->udev = udev;
-       udev_list_init(&udev_enumerate->devices_list);
        udev_list_init(&udev_enumerate->sysattr_match_list);
        udev_list_init(&udev_enumerate->sysattr_nomatch_list);
        udev_list_init(&udev_enumerate->subsystem_match_list);
        udev_list_init(&udev_enumerate->subsystem_nomatch_list);
+       udev_list_init(&udev_enumerate->sysname_match_list);
        udev_list_init(&udev_enumerate->properties_match_list);
+       udev_list_init(&udev_enumerate->devices_list);
        return udev_enumerate;
 }
 
@@ -98,17 +108,23 @@ struct udev_enumerate *udev_enumerate_ref(struct udev_enumerate *udev_enumerate)
  **/
 void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
 {
+       unsigned int i;
+
        if (udev_enumerate == NULL)
                return;
        udev_enumerate->refcount--;
        if (udev_enumerate->refcount > 0)
                return;
-       udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
        udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_match_list);
        udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysattr_nomatch_list);
        udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_match_list);
        udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
+       udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->sysname_match_list);
        udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->properties_match_list);
+       udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
+       for (i = 0; i < udev_enumerate->devices_cur; i++)
+               free(udev_enumerate->devices[i].syspath);
+       free(udev_enumerate->devices);
        free(udev_enumerate);
 }
 
@@ -125,6 +141,102 @@ struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate)
        return udev_enumerate->udev;
 }
 
+static int syspath_add(struct udev_enumerate *udev_enumerate, const char *syspath)
+{
+       char *path;
+       struct syspath *entry;
+
+       /* double array size if needed */
+       if (udev_enumerate->devices_cur >= udev_enumerate->devices_max) {
+               struct syspath *buf;
+               unsigned int add;
+
+               add = udev_enumerate->devices_max;
+               if (add < 1024)
+                       add = 1024;
+               buf = realloc(udev_enumerate->devices, (udev_enumerate->devices_max + add) * sizeof(struct syspath));
+               if (buf == NULL)
+                       return -ENOMEM;
+               udev_enumerate->devices = buf;
+               udev_enumerate->devices_max += add;
+       }
+
+       path = strdup(syspath);
+       if (path == NULL)
+               return -ENOMEM;
+       entry = &udev_enumerate->devices[udev_enumerate->devices_cur];
+       entry->syspath = path;
+       entry->len = strlen(path);
+       udev_enumerate->devices_cur++;
+       udev_enumerate->devices_uptodate = false;
+       return 0;
+}
+
+static int syspath_cmp(const void *p1, const void *p2)
+{
+       const struct syspath *path1 = p1;
+       const struct syspath *path2 = p2;
+       size_t len;
+       int ret;
+
+       len = MIN(path1->len, path2->len);
+       ret = memcmp(path1->syspath, path2->syspath, len);
+       if (ret == 0) {
+               if (path1->len < path2->len)
+                       ret = -1;
+               else if (path1->len > path2->len)
+                       ret = 1;
+       }
+       return ret;
+}
+
+/* For devices that should be moved to the absolute end of the list */
+static int devices_delay_end(struct udev *udev, const char *syspath)
+{
+       static const char *delay_device_list[] = {
+               "/block/md",
+               "/block/dm-",
+               NULL
+       };
+       size_t len;
+       int i;
+
+       len = strlen(udev_get_sys_path(udev));
+       for (i = 0; delay_device_list[i] != NULL; i++) {
+               if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
+                       dbg(udev, "delaying: %s\n", syspath);
+                       return 1;
+               }
+       }
+       return 0;
+}
+
+/* For devices that should just be moved a little bit later, just
+ * before the point where some common path prefix changes. Returns the
+ * number of characters that make up that common prefix */
+static size_t devices_delay_later(struct udev *udev, const char *syspath)
+{
+       const char *c;
+
+       /* For sound cards the control device must be enumerated last
+        * to make sure it's the final device node that gets ACLs
+        * applied. Applications rely on this fact and use ACL changes
+        * on the control node as an indicator that the ACL change of
+        * the entire sound card completed. The kernel makes this
+        * guarantee when creating those devices, and hence we should
+        * too when enumerating them. */
+
+       if ((c = strstr(syspath, "/sound/card"))) {
+               c += 11;
+               c += strcspn(c, "/");
+
+               if (strncmp(c, "/controlC", 9) == 0)
+                       return c - syspath + 1;
+       }
+
+       return 0;
+}
+
 /**
  * udev_enumerate_get_list_entry:
  * @udev_enumerate: context
@@ -135,8 +247,72 @@ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *ude
 {
        if (udev_enumerate == NULL)
                return NULL;
-       if (!udev_enumerate->devices_sorted)
-               devices_sort(udev_enumerate);
+       if (!udev_enumerate->devices_uptodate) {
+               unsigned int i;
+               unsigned int max;
+               struct syspath *prev = NULL, *move_later = NULL;
+
+               udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
+               qsort(udev_enumerate->devices, udev_enumerate->devices_cur, sizeof(struct syspath), syspath_cmp);
+
+               max = udev_enumerate->devices_cur;
+               for (i = 0; i < max; i++) {
+                       struct syspath *entry = &udev_enumerate->devices[i];
+                       size_t move_later_prefix = 0;
+
+                       /* skip duplicated entries */
+                       if (prev != NULL &&
+                           entry->len == prev->len &&
+                           memcmp(entry->syspath, prev->syspath, entry->len) == 0)
+                               continue;
+                       prev = entry;
+
+                       /* skip to be delayed devices, and add them to the end of the list */
+                       if (devices_delay_end(udev_enumerate->udev, entry->syspath)) {
+                               syspath_add(udev_enumerate, entry->syspath);
+                               continue;
+                       }
+
+                       /* skip to be delayed devices, and move the to
+                        * the point where the prefix changes. We can
+                        * only move one item at a time. */
+                       if (!move_later) {
+                               move_later_prefix = devices_delay_later(udev_enumerate->udev, entry->syspath);
+
+                               if (move_later_prefix > 0) {
+                                       move_later = entry;
+                                       continue;
+                               }
+                       }
+
+                       if (move_later &&
+                           strncmp(entry->syspath, move_later->syspath, move_later_prefix) != 0) {
+
+                               udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
+                                           move_later->syspath, NULL, 0, 0);
+                               move_later = NULL;
+                       }
+
+                       udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
+                                           entry->syspath, NULL, 0, 0);
+               }
+
+               if (move_later)
+                       udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
+                                           move_later->syspath, NULL, 0, 0);
+
+               /* add and cleanup delayed devices from end of list */
+               for (i = max; i < udev_enumerate->devices_cur; i++) {
+                       struct syspath *entry = &udev_enumerate->devices[i];
+
+                       udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
+                                           entry->syspath, NULL, 0, 0);
+                       free(entry->syspath);
+               }
+               udev_enumerate->devices_cur = max;
+
+               udev_enumerate->devices_uptodate = true;
+       }
        return udev_list_get_entry(&udev_enumerate->devices_list);
 }
 
@@ -222,7 +398,7 @@ static int match_sysattr_value(struct udev *udev, const char *syspath, const cha
 {
        struct udev_device *device;
        const char *val = NULL;
-       int match = 0;
+       bool match = false;
 
        device = udev_device_new_from_syspath(udev, syspath);
        if (device == NULL)
@@ -231,11 +407,11 @@ static int match_sysattr_value(struct udev *udev, const char *syspath, const cha
        if (val == NULL)
                goto exit;
        if (match_val == NULL) {
-               match = 1;
+               match = true;
                goto exit;
        }
        if (fnmatch(match_val, val, 0) == 0) {
-               match = 1;
+               match = true;
                goto exit;
        }
 exit:
@@ -263,6 +439,25 @@ int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, con
        return 0;
 }
 
+/**
+ * udev_enumerate_add_match_sysname:
+ * @udev_enumerate: context
+ * @sysname: filter for the name of the device to include in the list
+ *
+ * Returns: 0 on success, otherwise a negative error value.
+ */
+int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
+{
+       if (udev_enumerate == NULL)
+               return -EINVAL;
+       if (sysname == NULL)
+               return 0;
+       if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
+                               &udev_enumerate->sysname_match_list, sysname, NULL, 1, 0) == NULL)
+               return -ENOMEM;
+       return 0;
+}
+
 static int match_sysattr(struct udev_enumerate *udev_enumerate, const char *syspath)
 {
        struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
@@ -293,7 +488,7 @@ static int match_property(struct udev_enumerate *udev_enumerate, const char *sys
 {
        struct udev_device *dev;
        struct udev_list_entry *list_entry;
-       int match = 0;
+       int match = false;
 
        /* no match always matches */
        if (udev_list_get_entry(&udev_enumerate->properties_match_list) == NULL)
@@ -318,13 +513,13 @@ static int match_property(struct udev_enumerate *udev_enumerate, const char *sys
                        if (fnmatch(match_key, dev_key, 0) != 0)
                                continue;
                        if (match_value == NULL && dev_value == NULL) {
-                               match = 1;
+                               match = true;
                                goto out;
                        }
                        if (match_value == NULL || dev_value == NULL)
                                continue;
                        if (fnmatch(match_value, dev_value, 0) == 0) {
-                               match = 1;
+                               match = true;
                                goto out;
                        }
                }
@@ -334,6 +529,21 @@ out:
        return match;
 }
 
+static int match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname)
+{
+       struct udev_list_entry *list_entry;
+
+       if (udev_list_get_entry(&udev_enumerate->sysname_match_list) == NULL)
+               return 1;
+
+       udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysname_match_list)) {
+               if (fnmatch(udev_list_entry_get_name(list_entry), sysname, 0) != 0)
+                       continue;
+               return 1;
+       }
+       return 0;
+}
+
 static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
                                    const char *basedir, const char *subdir1, const char *subdir2)
 {
@@ -360,6 +570,9 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
 
                if (dent->d_name[0] == '.')
                        continue;
+               if (!match_sysname(udev_enumerate, dent->d_name))
+                       continue;
+
                util_strscpyl(syspath, sizeof(syspath), path, "/", dent->d_name, NULL);
                if (lstat(syspath, &statbuf) != 0)
                        continue;
@@ -375,7 +588,7 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
                        continue;
                if (!match_property(udev_enumerate, syspath))
                        continue;
-               udev_list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1);
+               syspath_add(udev_enumerate, syspath);
        }
        closedir(dir);
        return 0;
@@ -422,50 +635,6 @@ static int scan_dir(struct udev_enumerate *udev_enumerate, const char *basedir,
        return 0;
 }
 
-static int devices_delay(struct udev *udev, const char *syspath)
-{
-       static const char *delay_device_list[] = {
-               "/block/md",
-               "/block/dm-",
-               NULL
-       };
-       size_t len;
-       int i;
-
-       len = strlen(udev_get_sys_path(udev));
-       for (i = 0; delay_device_list[i] != NULL; i++) {
-               if (strstr(&syspath[len], delay_device_list[i]) != NULL) {
-                       dbg(udev, "delaying: %s\n", syspath);
-                       return 1;
-               }
-       }
-       return 0;
-}
-
-/* sort delayed devices to the end of the list */
-static int devices_sort(struct udev_enumerate *udev_enumerate)
-{
-       struct udev_list_entry *entry_loop;
-       struct udev_list_entry *entry_tmp;
-       struct udev_list_node devices_list;
-
-       udev_list_init(&devices_list);
-       /* move delayed to delay list */
-       udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&udev_enumerate->devices_list)) {
-               if (devices_delay(udev_enumerate->udev, udev_list_entry_get_name(entry_loop))) {
-                       udev_list_entry_remove(entry_loop);
-                       udev_list_entry_append(entry_loop, &devices_list);
-               }
-       }
-       /* move delayed back to end of list */
-       udev_list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(&devices_list)) {
-               udev_list_entry_remove(entry_loop);
-               udev_list_entry_append(entry_loop, &udev_enumerate->devices_list);
-       }
-       udev_enumerate->devices_sorted = 1;
-       return 0;
-}
-
 /**
  * udev_enumerate_add_syspath:
  * @udev_enumerate: context
@@ -477,7 +646,6 @@ static int devices_sort(struct udev_enumerate *udev_enumerate)
  */
 int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath)
 {
-       struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
        struct udev_device *udev_device;
 
        if (udev_enumerate == NULL)
@@ -488,8 +656,7 @@ int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char
        udev_device = udev_device_new_from_syspath(udev_enumerate->udev, syspath);
        if (udev_device == NULL)
                return -EINVAL;
-       udev_list_entry_add(udev, &udev_enumerate->devices_list,
-                           udev_device_get_syspath(udev_device), NULL, 1, 1);
+       syspath_add(udev_enumerate, udev_device_get_syspath(udev_device));
        udev_device_unref(udev_device);
        return 0;
 }