#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
* and return a sorted list of devices.
*/
+struct syspath {
+ char *syspath;
+ size_t len;
+};
+
/**
* 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;
};
/**
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;
}
**/
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);
}
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
{
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);
}
{
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)
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:
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);
{
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)
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;
}
}
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)
{
if (subdir1 != NULL)
l = util_strpcpyl(&s, l, "/", subdir1, NULL);
if (subdir2 != NULL)
- l = util_strpcpyl(&s, l, "/", subdir2, NULL);
+ util_strpcpyl(&s, l, "/", subdir2, NULL);
dir = opendir(path);
if (dir == NULL)
return -1;
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;
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;
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
*/
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)
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;
}