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;
struct syspath *devices;
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;
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++)
return ret;
}
-static int devices_delay(struct udev *udev, const char *syspath)
+/* 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",
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->devices_uptodate) {
unsigned int i;
unsigned int max;
- struct syspath *prev = NULL;
+ struct syspath *prev = NULL, *move_later = NULL;
+ size_t move_later_prefix = 0;
udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->devices_list);
qsort(udev_enumerate->devices, udev_enumerate->devices_cur, sizeof(struct syspath), syspath_cmp);
prev = entry;
/* skip to be delayed devices, and add them to the end of the list */
- if (devices_delay(udev_enumerate->udev, entry->syspath)) {
+ 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];
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);
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 (!match_property(udev_enumerate, syspath))
+ continue;
if (lstat(syspath, &statbuf) != 0)
continue;
if (S_ISREG(statbuf.st_mode))
continue;
if (!match_sysattr(udev_enumerate, syspath))
continue;
- if (!match_property(udev_enumerate, syspath))
- continue;
syspath_add(udev_enumerate, syspath);
}
closedir(dir);
scan_dir(udev_enumerate, "bus", "devices", NULL);
dbg(udev, "searching '/class/*' dir\n");
scan_dir(udev_enumerate, "class", NULL, NULL);
- /* if block isn't a class, scan /block/ */
- util_strscpyl(base, sizeof(base), udev_get_sys_path(udev), "/class/block", NULL);
- if (stat(base, &statbuf) != 0) {
- if (match_subsystem(udev_enumerate, "block")) {
- dbg(udev, "searching '/block/*' dir\n");
- /* scan disks */
- scan_dir_and_add_devices(udev_enumerate, "block", NULL, NULL);
- /* scan partitions */
- dbg(udev, "searching '/block/*/*' dir\n");
- scan_dir(udev_enumerate, "block", NULL, "block");
- }
- }
}
return 0;
}