In the later commit, udev_list will be just a wrapper of hashmap or LIST.
So, allocating udev_list does not increase much cost.
struct udev_device *parent;
bool parent_set;
- struct udev_list properties;
+ struct udev_list *properties;
uint64_t properties_generation;
- struct udev_list tags;
+ struct udev_list *tags;
uint64_t tags_generation;
- struct udev_list devlinks;
+ struct udev_list *devlinks;
uint64_t devlinks_generation;
bool properties_read:1;
bool tags_read:1;
bool devlinks_read:1;
- struct udev_list sysattrs;
+ struct udev_list *sysattrs;
bool sysattrs_read;
};
}
struct udev_device *udev_device_new(struct udev *udev, sd_device *device) {
+ _cleanup_(udev_list_freep) struct udev_list *properties = NULL, *tags = NULL, *sysattrs = NULL, *devlinks = NULL;
struct udev_device *udev_device;
assert(device);
+ properties = udev_list_new(true);
+ if (!properties)
+ return_with_errno(NULL, ENOMEM);
+ tags = udev_list_new(true);
+ if (!tags)
+ return_with_errno(NULL, ENOMEM);
+ sysattrs = udev_list_new(true);
+ if (!sysattrs)
+ return_with_errno(NULL, ENOMEM);
+ devlinks = udev_list_new(true);
+ if (!devlinks)
+ return_with_errno(NULL, ENOMEM);
+
udev_device = new(struct udev_device, 1);
if (!udev_device)
return_with_errno(NULL, ENOMEM);
.n_ref = 1,
.udev = udev,
.device = sd_device_ref(device),
+ .properties = TAKE_PTR(properties),
+ .tags = TAKE_PTR(tags),
+ .sysattrs = TAKE_PTR(sysattrs),
+ .devlinks = TAKE_PTR(devlinks),
};
- udev_list_init(&udev_device->properties, true);
- udev_list_init(&udev_device->tags, true);
- udev_list_init(&udev_device->sysattrs, true);
- udev_list_init(&udev_device->devlinks, true);
-
return udev_device;
}
sd_device_unref(udev_device->device);
udev_device_unref(udev_device->parent);
- udev_list_cleanup(&udev_device->properties);
- udev_list_cleanup(&udev_device->sysattrs);
- udev_list_cleanup(&udev_device->tags);
- udev_list_cleanup(&udev_device->devlinks);
+ udev_list_free(udev_device->properties);
+ udev_list_free(udev_device->sysattrs);
+ udev_list_free(udev_device->tags);
+ udev_list_free(udev_device->devlinks);
return mfree(udev_device);
}
!udev_device->devlinks_read) {
const char *devlink;
- udev_list_cleanup(&udev_device->devlinks);
+ udev_list_cleanup(udev_device->devlinks);
FOREACH_DEVICE_DEVLINK(udev_device->device, devlink)
- if (!udev_list_entry_add(&udev_device->devlinks, devlink, NULL))
+ if (!udev_list_entry_add(udev_device->devlinks, devlink, NULL))
return_with_errno(NULL, ENOMEM);
udev_device->devlinks_read = true;
udev_device->devlinks_generation = device_get_devlinks_generation(udev_device->device);
}
- return udev_list_get_entry(&udev_device->devlinks);
+ return udev_list_get_entry(udev_device->devlinks);
}
/**
!udev_device->properties_read) {
const char *key, *value;
- udev_list_cleanup(&udev_device->properties);
+ udev_list_cleanup(udev_device->properties);
FOREACH_DEVICE_PROPERTY(udev_device->device, key, value)
- if (!udev_list_entry_add(&udev_device->properties, key, value))
+ if (!udev_list_entry_add(udev_device->properties, key, value))
return_with_errno(NULL, ENOMEM);
udev_device->properties_read = true;
udev_device->properties_generation = device_get_properties_generation(udev_device->device);
}
- return udev_list_get_entry(&udev_device->properties);
+ return udev_list_get_entry(udev_device->properties);
}
/**
if (!udev_device->sysattrs_read) {
const char *sysattr;
- udev_list_cleanup(&udev_device->sysattrs);
+ udev_list_cleanup(udev_device->sysattrs);
FOREACH_DEVICE_SYSATTR(udev_device->device, sysattr)
- if (!udev_list_entry_add(&udev_device->sysattrs, sysattr, NULL))
+ if (!udev_list_entry_add(udev_device->sysattrs, sysattr, NULL))
return_with_errno(NULL, ENOMEM);
udev_device->sysattrs_read = true;
}
- return udev_list_get_entry(&udev_device->sysattrs);
+ return udev_list_get_entry(udev_device->sysattrs);
}
/**
!udev_device->tags_read) {
const char *tag;
- udev_list_cleanup(&udev_device->tags);
+ udev_list_cleanup(udev_device->tags);
FOREACH_DEVICE_TAG(udev_device->device, tag)
- if (!udev_list_entry_add(&udev_device->tags, tag, NULL))
+ if (!udev_list_entry_add(udev_device->tags, tag, NULL))
return_with_errno(NULL, ENOMEM);
udev_device->tags_read = true;
udev_device->tags_generation = device_get_tags_generation(udev_device->device);
}
- return udev_list_get_entry(&udev_device->tags);
+ return udev_list_get_entry(udev_device->tags);
}
/**
struct udev_enumerate {
struct udev *udev;
unsigned n_ref;
- struct udev_list devices_list;
+ struct udev_list *devices_list;
bool devices_uptodate:1;
sd_device_enumerator *enumerator;
**/
_public_ struct udev_enumerate *udev_enumerate_new(struct udev *udev) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
+ _cleanup_(udev_list_freep) struct udev_list *list = NULL;
struct udev_enumerate *udev_enumerate;
int r;
if (r < 0)
return_with_errno(NULL, r);
+ list = udev_list_new(false);
+ if (!list)
+ return_with_errno(NULL, ENOMEM);
+
udev_enumerate = new(struct udev_enumerate, 1);
if (!udev_enumerate)
return_with_errno(NULL, ENOMEM);
.udev = udev,
.n_ref = 1,
.enumerator = TAKE_PTR(e),
+ .devices_list = TAKE_PTR(list),
};
- udev_list_init(&udev_enumerate->devices_list, false);
-
return udev_enumerate;
}
static struct udev_enumerate *udev_enumerate_free(struct udev_enumerate *udev_enumerate) {
assert(udev_enumerate);
- udev_list_cleanup(&udev_enumerate->devices_list);
+ udev_list_free(udev_enumerate->devices_list);
sd_device_enumerator_unref(udev_enumerate->enumerator);
return mfree(udev_enumerate);
}
if (!udev_enumerate->devices_uptodate) {
sd_device *device;
- udev_list_cleanup(&udev_enumerate->devices_list);
+ udev_list_cleanup(udev_enumerate->devices_list);
FOREACH_DEVICE_AND_SUBSYSTEM(udev_enumerate->enumerator, device) {
const char *syspath;
if (r < 0)
return_with_errno(NULL, r);
- if (!udev_list_entry_add(&udev_enumerate->devices_list, syspath, NULL))
+ if (!udev_list_entry_add(udev_enumerate->devices_list, syspath, NULL))
return_with_errno(NULL, ENOMEM);
}
udev_enumerate->devices_uptodate = true;
}
- e = udev_list_get_entry(&udev_enumerate->devices_list);
+ e = udev_list_get_entry(udev_enumerate->devices_list);
if (!e)
return_with_errno(NULL, ENODATA);
struct udev_hwdb {
unsigned n_ref;
sd_hwdb *hwdb;
- struct udev_list properties_list;
+ struct udev_list *properties_list;
};
/**
* Returns: a hwdb context.
**/
_public_ struct udev_hwdb *udev_hwdb_new(struct udev *udev) {
+ _cleanup_(udev_list_freep) struct udev_list *list = NULL;
_cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb_internal = NULL;
struct udev_hwdb *hwdb;
int r;
if (r < 0)
return_with_errno(NULL, r);
+ list = udev_list_new(true);
+ if (!list)
+ return_with_errno(NULL, ENOMEM);
+
hwdb = new(struct udev_hwdb, 1);
if (!hwdb)
return_with_errno(NULL, ENOMEM);
*hwdb = (struct udev_hwdb) {
.n_ref = 1,
.hwdb = TAKE_PTR(hwdb_internal),
+ .properties_list = TAKE_PTR(list),
};
- udev_list_init(&hwdb->properties_list, true);
-
return hwdb;
}
assert(hwdb);
sd_hwdb_unref(hwdb->hwdb);
- udev_list_cleanup(&hwdb->properties_list);
+ udev_list_free(hwdb->properties_list);
return mfree(hwdb);
}
assert_return_errno(hwdb, NULL, EINVAL);
assert_return_errno(modalias, NULL, EINVAL);
- udev_list_cleanup(&hwdb->properties_list);
+ udev_list_cleanup(hwdb->properties_list);
SD_HWDB_FOREACH_PROPERTY(hwdb->hwdb, modalias, key, value)
- if (!udev_list_entry_add(&hwdb->properties_list, key, value))
+ if (!udev_list_entry_add(hwdb->properties_list, key, value))
return_with_errno(NULL, ENOMEM);
- e = udev_list_get_entry(&hwdb->properties_list);
+ e = udev_list_get_entry(hwdb->properties_list);
if (!e)
return_with_errno(NULL, ENODATA);
#include "libudev.h"
-struct udev_list_node {
- struct udev_list_node *next, *prev;
-};
+#include "macro.h"
-struct udev_list {
- struct udev_list_node node;
- struct udev_list_entry **entries;
- unsigned entries_cur;
- unsigned entries_max;
- bool unique;
-};
+struct udev_list;
-void udev_list_init(struct udev_list *list, bool unique);
+struct udev_list *udev_list_new(bool unique);
void udev_list_cleanup(struct udev_list *list);
+struct udev_list *udev_list_free(struct udev_list *list);
+DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_list *, udev_list_free);
+
struct udev_list_entry *udev_list_get_entry(struct udev_list *list);
struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *name, const char *value);
* Libudev list operations.
*/
+struct udev_list_node {
+ struct udev_list_node *next, *prev;
+};
+
/**
* udev_list_entry:
*
char *value;
};
+struct udev_list {
+ struct udev_list_node node;
+ struct udev_list_entry **entries;
+ unsigned entries_cur;
+ unsigned entries_max;
+ bool unique;
+};
+
/* the list's head points to itself if empty */
static void udev_list_node_init(struct udev_list_node *list) {
list->next = list;
return container_of(node, struct udev_list_entry, node);
}
-void udev_list_init(struct udev_list *list, bool unique) {
- memzero(list, sizeof(struct udev_list));
- list->unique = unique;
+struct udev_list *udev_list_new(bool unique) {
+ struct udev_list *list;
+
+ list = new(struct udev_list, 1);
+ if (!list)
+ return NULL;
+
+ *list = (struct udev_list) {
+ .unique = unique,
+ };
+
udev_list_node_init(&list->node);
+
+ return list;
}
/* insert entry into a list as the last element */
entry = tmp, tmp = udev_list_entry_get_next(tmp))
void udev_list_cleanup(struct udev_list *list) {
- struct udev_list_entry *entry_loop;
- struct udev_list_entry *entry_tmp;
+ struct udev_list_entry *entry_loop, *entry_tmp;
list->entries = mfree(list->entries);
list->entries_cur = 0;
udev_list_entry_delete(entry_loop);
}
+struct udev_list *udev_list_free(struct udev_list *list) {
+ if (!list)
+ return NULL;
+
+ udev_list_cleanup(list);
+
+ return mfree(list);
+}
+
struct udev_list_entry *udev_list_get_entry(struct udev_list *list) {
if (udev_list_node_is_empty(&list->node))
return NULL;
}
static void test_list(void) {
- struct udev_list list = {};
+ _cleanup_(udev_list_freep) struct udev_list *list = NULL;
struct udev_list_entry *e;
/* empty list */
- udev_list_init(&list, false);
- assert_se(!udev_list_get_entry(&list));
+ assert_se(list = udev_list_new(false));
+ assert_se(!udev_list_get_entry(list));
+ list = udev_list_free(list);
/* unique == false */
- udev_list_init(&list, false);
- assert_se(udev_list_entry_add(&list, "aaa", "hoge"));
- assert_se(udev_list_entry_add(&list, "aaa", "hogehoge"));
- assert_se(udev_list_entry_add(&list, "bbb", "foo"));
- e = udev_list_get_entry(&list);
+ assert_se(list = udev_list_new(false));
+ assert_se(udev_list_entry_add(list, "aaa", "hoge"));
+ assert_se(udev_list_entry_add(list, "aaa", "hogehoge"));
+ assert_se(udev_list_entry_add(list, "bbb", "foo"));
+ e = udev_list_get_entry(list);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hoge"));
assert_se(!udev_list_entry_get_by_name(e, "aaa"));
assert_se(!udev_list_entry_get_by_name(e, "bbb"));
assert_se(!udev_list_entry_get_by_name(e, "ccc"));
- udev_list_cleanup(&list);
+ list = udev_list_free(list);
/* unique == true */
- udev_list_init(&list, true);
- assert_se(udev_list_entry_add(&list, "aaa", "hoge"));
- assert_se(udev_list_entry_add(&list, "aaa", "hogehoge"));
- assert_se(udev_list_entry_add(&list, "bbb", "foo"));
- e = udev_list_get_entry(&list);
+ assert_se(list = udev_list_new(true));
+ assert_se(udev_list_entry_add(list, "aaa", "hoge"));
+ assert_se(udev_list_entry_add(list, "aaa", "hogehoge"));
+ assert_se(udev_list_entry_add(list, "bbb", "foo"));
+ e = udev_list_get_entry(list);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
assert_se(!udev_list_entry_get_by_name(e, "ccc"));
- udev_list_cleanup(&list);
}
static int parse_args(int argc, char *argv[], const char **syspath, const char **subsystem) {