mirror of
https://github.com/systemd/systemd.git
synced 2024-12-23 21:35:11 +03:00
libudev: also prefix non-exported functions with udev_*
This commit is contained in:
Kay Sievers
parent
90d80c2efc
commit
8cd2e972e5
@ -39,8 +39,8 @@ struct udev_device {
|
||||
const char *sysname;
|
||||
char *devnode;
|
||||
char *subsystem;
|
||||
struct list_node devlink_list;
|
||||
struct list_node properties_list;
|
||||
struct udev_list_node devlink_list;
|
||||
struct udev_list_node properties_list;
|
||||
char *action;
|
||||
int event_timeout;
|
||||
char *driver;
|
||||
@ -52,7 +52,7 @@ struct udev_device {
|
||||
int num_fake_partitions;
|
||||
int devlink_priority;
|
||||
int ignore_remove;
|
||||
struct list_node attr_list;
|
||||
struct udev_list_node attr_list;
|
||||
int info_loaded;
|
||||
};
|
||||
|
||||
@ -113,7 +113,7 @@ static int device_read_db(struct udev_device *udev_device)
|
||||
util_strlcpy(linkname, udev_get_dev_path(udev_device->udev), sizeof(linkname));
|
||||
util_strlcat(linkname, "/", sizeof(linkname));
|
||||
util_strlcat(linkname, lnk, sizeof(linkname));
|
||||
device_add_devlink(udev_device, linkname);
|
||||
udev_device_add_devlink(udev_device, linkname);
|
||||
}
|
||||
info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode);
|
||||
return 0;
|
||||
@ -142,22 +142,22 @@ static int device_read_db(struct udev_device *udev_device)
|
||||
util_strlcpy(filename, udev_get_dev_path(udev_device->udev), sizeof(filename));
|
||||
util_strlcat(filename, "/", sizeof(filename));
|
||||
util_strlcat(filename, val, sizeof(filename));
|
||||
device_add_devlink(udev_device, filename);
|
||||
udev_device_add_devlink(udev_device, filename);
|
||||
break;
|
||||
case 'L':
|
||||
device_set_devlink_priority(udev_device, atoi(val));
|
||||
udev_device_set_devlink_priority(udev_device, atoi(val));
|
||||
break;
|
||||
case 'T':
|
||||
device_set_event_timeout(udev_device, atoi(val));
|
||||
udev_device_set_event_timeout(udev_device, atoi(val));
|
||||
break;
|
||||
case 'A':
|
||||
device_set_num_fake_partitions(udev_device, atoi(val));
|
||||
udev_device_set_num_fake_partitions(udev_device, atoi(val));
|
||||
break;
|
||||
case 'R':
|
||||
device_set_ignore_remove(udev_device, atoi(val));
|
||||
udev_device_set_ignore_remove(udev_device, atoi(val));
|
||||
break;
|
||||
case 'E':
|
||||
device_add_property_from_string(udev_device, val);
|
||||
udev_device_add_property_from_string(udev_device, val);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -194,7 +194,7 @@ static int device_read_uevent_file(struct udev_device *udev_device)
|
||||
else if (strncmp(line, "MINOR=", 6) == 0)
|
||||
min = strtoull(&line[6], NULL, 10);
|
||||
|
||||
device_add_property_from_string(udev_device, line);
|
||||
udev_device_add_property_from_string(udev_device, line);
|
||||
}
|
||||
|
||||
udev_device->devnum = makedev(maj, min);
|
||||
@ -210,7 +210,7 @@ static void device_load_info(struct udev_device *device)
|
||||
device->info_loaded = 1;
|
||||
}
|
||||
|
||||
void device_set_info_loaded(struct udev_device *device)
|
||||
void udev_device_set_info_loaded(struct udev_device *device)
|
||||
{
|
||||
device->info_loaded = 1;
|
||||
}
|
||||
@ -228,9 +228,9 @@ struct udev_device *device_new(struct udev *udev)
|
||||
memset(udev_device, 0x00, sizeof(struct udev_device));
|
||||
udev_device->refcount = 1;
|
||||
udev_device->udev = udev;
|
||||
list_init(&udev_device->devlink_list);
|
||||
list_init(&udev_device->properties_list);
|
||||
list_init(&udev_device->attr_list);
|
||||
udev_list_init(&udev_device->devlink_list);
|
||||
udev_list_init(&udev_device->properties_list);
|
||||
udev_list_init(&udev_device->attr_list);
|
||||
info(udev_device->udev, "udev_device: %p created\n", udev_device);
|
||||
return udev_device;
|
||||
}
|
||||
@ -324,7 +324,7 @@ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *
|
||||
if (udev_device == NULL)
|
||||
return NULL;
|
||||
|
||||
device_set_syspath(udev_device, path);
|
||||
udev_device_set_syspath(udev_device, path);
|
||||
info(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
|
||||
|
||||
return udev_device;
|
||||
@ -581,13 +581,13 @@ void udev_device_unref(struct udev_device *udev_device)
|
||||
free(udev_device->syspath);
|
||||
free(udev_device->devnode);
|
||||
free(udev_device->subsystem);
|
||||
list_cleanup(udev_device->udev, &udev_device->devlink_list);
|
||||
list_cleanup(udev_device->udev, &udev_device->properties_list);
|
||||
udev_list_cleanup(udev_device->udev, &udev_device->devlink_list);
|
||||
udev_list_cleanup(udev_device->udev, &udev_device->properties_list);
|
||||
free(udev_device->action);
|
||||
free(udev_device->driver);
|
||||
free(udev_device->devpath_old);
|
||||
free(udev_device->physdevpath);
|
||||
list_cleanup(udev_device->udev, &udev_device->attr_list);
|
||||
udev_list_cleanup(udev_device->udev, &udev_device->attr_list);
|
||||
info(udev_device->udev, "udev_device: %p released\n", udev_device);
|
||||
free(udev_device);
|
||||
}
|
||||
@ -710,7 +710,7 @@ struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *
|
||||
return NULL;
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return list_get_entry(&udev_device->devlink_list);
|
||||
return udev_list_get_entry(&udev_device->devlink_list);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -731,7 +731,7 @@ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device
|
||||
return NULL;
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return list_get_entry(&udev_device->properties_list);
|
||||
return udev_list_get_entry(&udev_device->properties_list);
|
||||
}
|
||||
|
||||
const char *udev_device_get_driver(struct udev_device *udev_device)
|
||||
@ -782,7 +782,7 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch
|
||||
const char *val = NULL;
|
||||
|
||||
/* look for possibly already cached result */
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_device->attr_list)) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_device->attr_list)) {
|
||||
if (strcmp(udev_list_entry_get_name(list_entry), attr) == 0) {
|
||||
info(udev_device->udev, "got '%s' (%s) from cache\n", attr, udev_list_entry_get_value(list_entry));
|
||||
return udev_list_entry_get_value(list_entry);
|
||||
@ -811,7 +811,7 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch
|
||||
if (pos != NULL) {
|
||||
pos = &pos[1];
|
||||
info(udev_device->udev, "cache '%s' with link value '%s'\n", attr, pos);
|
||||
list_entry = list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0);
|
||||
list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0);
|
||||
val = udev_list_entry_get_value(list_entry);
|
||||
}
|
||||
}
|
||||
@ -843,15 +843,16 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch
|
||||
value[size] = '\0';
|
||||
util_remove_trailing_chars(value, '\n');
|
||||
info(udev_device->udev, "'%s' has attribute value '%s'\n", path, value);
|
||||
list_entry = list_entry_add(udev_device->udev, &udev_device->attr_list, attr, value, 0, 0);
|
||||
list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, value, 0, 0);
|
||||
val = udev_list_entry_get_value(list_entry);
|
||||
out:
|
||||
return val;
|
||||
}
|
||||
int device_set_syspath(struct udev_device *udev_device, const char *syspath)
|
||||
int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath)
|
||||
{
|
||||
const char *pos;
|
||||
|
||||
free(udev_device->syspath);
|
||||
udev_device->syspath = strdup(syspath);
|
||||
if (udev_device->syspath == NULL)
|
||||
return -ENOMEM;
|
||||
@ -863,7 +864,7 @@ int device_set_syspath(struct udev_device *udev_device, const char *syspath)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
|
||||
int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
|
||||
{
|
||||
udev_device->subsystem = strdup(subsystem);
|
||||
if (udev_device->subsystem == NULL)
|
||||
@ -871,7 +872,7 @@ int device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_devnode(struct udev_device *udev_device, const char *devnode)
|
||||
int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
|
||||
{
|
||||
udev_device->devnode = strdup(devnode);
|
||||
if (udev_device->devnode == NULL)
|
||||
@ -879,21 +880,21 @@ int device_set_devnode(struct udev_device *udev_device, const char *devnode)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_add_devlink(struct udev_device *udev_device, const char *devlink)
|
||||
int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink)
|
||||
{
|
||||
if (list_entry_add(udev_device->udev, &udev_device->devlink_list, devlink, NULL, 1, 0) == NULL)
|
||||
if (udev_list_entry_add(udev_device->udev, &udev_device->devlink_list, devlink, NULL, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_add_property(struct udev_device *udev_device, const char *key, const char *value)
|
||||
int udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
|
||||
{
|
||||
if (list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0) == NULL)
|
||||
if (udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_add_property_from_string(struct udev_device *udev_device, const char *property)
|
||||
int udev_device_add_property_from_string(struct udev_device *udev_device, const char *property)
|
||||
{
|
||||
char name[UTIL_PATH_SIZE];
|
||||
char *val;
|
||||
@ -906,11 +907,11 @@ int device_add_property_from_string(struct udev_device *udev_device, const char
|
||||
val = &val[1];
|
||||
if (val[0] == '\0')
|
||||
val = NULL;
|
||||
device_add_property(udev_device, name, val);
|
||||
udev_device_add_property(udev_device, name, val);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_action(struct udev_device *udev_device, const char *action)
|
||||
int udev_device_set_action(struct udev_device *udev_device, const char *action)
|
||||
{
|
||||
udev_device->action = strdup(action);
|
||||
if (udev_device->action == NULL)
|
||||
@ -918,7 +919,7 @@ int device_set_action(struct udev_device *udev_device, const char *action)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_driver(struct udev_device *udev_device, const char *driver)
|
||||
int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
|
||||
{
|
||||
udev_device->driver = strdup(driver);
|
||||
if (udev_device->driver == NULL)
|
||||
@ -926,12 +927,12 @@ int device_set_driver(struct udev_device *udev_device, const char *driver)
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *device_get_devpath_old(struct udev_device *udev_device)
|
||||
const char *udev_device_get_devpath_old(struct udev_device *udev_device)
|
||||
{
|
||||
return udev_device->devpath_old;
|
||||
}
|
||||
|
||||
int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
|
||||
int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
|
||||
{
|
||||
udev_device->devpath_old = strdup(devpath_old);
|
||||
if (udev_device->devpath_old == NULL)
|
||||
@ -939,12 +940,12 @@ int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *device_get_physdevpath(struct udev_device *udev_device)
|
||||
const char *udev_device_get_physdevpath(struct udev_device *udev_device)
|
||||
{
|
||||
return udev_device->physdevpath;
|
||||
}
|
||||
|
||||
int device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath)
|
||||
int udev_device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath)
|
||||
{
|
||||
udev_device->physdevpath = strdup(physdevpath);
|
||||
if (udev_device->physdevpath == NULL)
|
||||
@ -952,75 +953,75 @@ int device_set_physdevpath(struct udev_device *udev_device, const char *physdevp
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_get_timeout(struct udev_device *udev_device)
|
||||
int udev_device_get_timeout(struct udev_device *udev_device)
|
||||
{
|
||||
return udev_device->timeout;
|
||||
}
|
||||
|
||||
int device_set_timeout(struct udev_device *udev_device, int timeout)
|
||||
int udev_device_set_timeout(struct udev_device *udev_device, int timeout)
|
||||
{
|
||||
udev_device->timeout = timeout;
|
||||
return 0;
|
||||
}
|
||||
int device_get_event_timeout(struct udev_device *udev_device)
|
||||
int udev_device_get_event_timeout(struct udev_device *udev_device)
|
||||
{
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return udev_device->event_timeout;
|
||||
}
|
||||
|
||||
int device_set_event_timeout(struct udev_device *udev_device, int event_timeout)
|
||||
int udev_device_set_event_timeout(struct udev_device *udev_device, int event_timeout)
|
||||
{
|
||||
udev_device->event_timeout = event_timeout;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
|
||||
int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
|
||||
{
|
||||
udev_device->seqnum = seqnum;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_set_devnum(struct udev_device *udev_device, dev_t devnum)
|
||||
int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
|
||||
{
|
||||
udev_device->devnum = devnum;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_get_num_fake_partitions(struct udev_device *udev_device)
|
||||
int udev_device_get_num_fake_partitions(struct udev_device *udev_device)
|
||||
{
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return udev_device->num_fake_partitions;
|
||||
}
|
||||
|
||||
int device_set_num_fake_partitions(struct udev_device *udev_device, int num)
|
||||
int udev_device_set_num_fake_partitions(struct udev_device *udev_device, int num)
|
||||
{
|
||||
udev_device->num_fake_partitions = num;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_get_devlink_priority(struct udev_device *udev_device)
|
||||
int udev_device_get_devlink_priority(struct udev_device *udev_device)
|
||||
{
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return udev_device->devlink_priority;
|
||||
}
|
||||
|
||||
int device_set_devlink_priority(struct udev_device *udev_device, int prio)
|
||||
int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
|
||||
{
|
||||
udev_device->devlink_priority = prio;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int device_get_ignore_remove(struct udev_device *udev_device)
|
||||
int udev_device_get_ignore_remove(struct udev_device *udev_device)
|
||||
{
|
||||
if (!udev_device->info_loaded)
|
||||
device_load_info(udev_device);
|
||||
return udev_device->ignore_remove;
|
||||
}
|
||||
|
||||
int device_set_ignore_remove(struct udev_device *udev_device, int ignore)
|
||||
int udev_device_set_ignore_remove(struct udev_device *udev_device, int ignore)
|
||||
{
|
||||
udev_device->ignore_remove = ignore;
|
||||
return 0;
|
||||
|
||||
@ -35,11 +35,11 @@ static int devices_sort(struct udev_enumerate *udev_enumerate);
|
||||
struct udev_enumerate {
|
||||
struct udev *udev;
|
||||
int refcount;
|
||||
struct list_node attr_match_list;
|
||||
struct list_node attr_nomatch_list;
|
||||
struct list_node subsystem_match_list;
|
||||
struct list_node subsystem_nomatch_list;
|
||||
struct list_node devices_list;
|
||||
struct udev_list_node attr_match_list;
|
||||
struct udev_list_node attr_nomatch_list;
|
||||
struct udev_list_node subsystem_match_list;
|
||||
struct udev_list_node subsystem_nomatch_list;
|
||||
struct udev_list_node devices_list;
|
||||
int devices_sorted;
|
||||
};
|
||||
|
||||
@ -59,11 +59,11 @@ struct udev_enumerate *udev_enumerate_new(struct udev *udev)
|
||||
memset(udev_enumerate, 0x00, (sizeof(struct udev_enumerate)));
|
||||
udev_enumerate->refcount = 1;
|
||||
udev_enumerate->udev = udev;
|
||||
list_init(&udev_enumerate->devices_list);
|
||||
list_init(&udev_enumerate->attr_match_list);
|
||||
list_init(&udev_enumerate->attr_nomatch_list);
|
||||
list_init(&udev_enumerate->subsystem_match_list);
|
||||
list_init(&udev_enumerate->subsystem_nomatch_list);
|
||||
udev_list_init(&udev_enumerate->devices_list);
|
||||
udev_list_init(&udev_enumerate->attr_match_list);
|
||||
udev_list_init(&udev_enumerate->attr_nomatch_list);
|
||||
udev_list_init(&udev_enumerate->subsystem_match_list);
|
||||
udev_list_init(&udev_enumerate->subsystem_nomatch_list);
|
||||
return udev_enumerate;
|
||||
}
|
||||
|
||||
@ -82,11 +82,11 @@ void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
|
||||
udev_enumerate->refcount--;
|
||||
if (udev_enumerate->refcount > 0)
|
||||
return;
|
||||
list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
|
||||
list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_match_list);
|
||||
list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_nomatch_list);
|
||||
list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_match_list);
|
||||
list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
|
||||
udev_list_cleanup(udev_enumerate->udev, &udev_enumerate->devices_list);
|
||||
udev_list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_match_list);
|
||||
udev_list_cleanup(udev_enumerate->udev, &udev_enumerate->attr_nomatch_list);
|
||||
udev_list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_match_list);
|
||||
udev_list_cleanup(udev_enumerate->udev, &udev_enumerate->subsystem_nomatch_list);
|
||||
free(udev_enumerate);
|
||||
}
|
||||
|
||||
@ -103,7 +103,7 @@ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *ude
|
||||
return NULL;
|
||||
if (!udev_enumerate->devices_sorted)
|
||||
devices_sort(udev_enumerate);
|
||||
return list_get_entry(&udev_enumerate->devices_list);
|
||||
return udev_list_get_entry(&udev_enumerate->devices_list);
|
||||
}
|
||||
|
||||
int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem)
|
||||
@ -112,8 +112,8 @@ int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, co
|
||||
return -EINVAL;
|
||||
if (subsystem == NULL)
|
||||
return 0;
|
||||
if (list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL)
|
||||
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
@ -124,8 +124,8 @@ int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate,
|
||||
return -EINVAL;
|
||||
if (subsystem == NULL)
|
||||
return 0;
|
||||
if (list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL)
|
||||
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
}
|
||||
@ -136,7 +136,7 @@ int udev_enumerate_add_match_attr(struct udev_enumerate *udev_enumerate, const c
|
||||
return -EINVAL;
|
||||
if (attr == NULL)
|
||||
return 0;
|
||||
if (list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->attr_match_list, attr, value, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
@ -148,7 +148,7 @@ int udev_enumerate_add_nomatch_attr(struct udev_enumerate *udev_enumerate, const
|
||||
return -EINVAL;
|
||||
if (attr == NULL)
|
||||
return 0;
|
||||
if (list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
|
||||
&udev_enumerate->attr_nomatch_list, attr, value, 1, 0) == NULL)
|
||||
return -ENOMEM;
|
||||
return 0;
|
||||
@ -185,15 +185,15 @@ static int match_attr(struct udev_enumerate *udev_enumerate, const char *syspath
|
||||
struct udev_list_entry *list_entry;
|
||||
|
||||
/* skip list */
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->attr_nomatch_list)) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->attr_nomatch_list)) {
|
||||
if (match_attr_value(udev, syspath,
|
||||
udev_list_entry_get_name(list_entry),
|
||||
udev_list_entry_get_value(list_entry)))
|
||||
return 0;
|
||||
}
|
||||
/* include list */
|
||||
if (list_get_entry(&udev_enumerate->attr_match_list) != NULL) {
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->attr_match_list)) {
|
||||
if (udev_list_get_entry(&udev_enumerate->attr_match_list) != NULL) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->attr_match_list)) {
|
||||
/* anything that does not match, will make it FALSE */
|
||||
if (!match_attr_value(udev, syspath,
|
||||
udev_list_entry_get_name(list_entry),
|
||||
@ -249,7 +249,7 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
|
||||
continue;
|
||||
if (!match_attr(udev_enumerate, syspath))
|
||||
continue;
|
||||
list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1);
|
||||
udev_list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1);
|
||||
}
|
||||
closedir(dir);
|
||||
return 0;
|
||||
@ -259,12 +259,12 @@ static int match_subsystem(struct udev_enumerate *udev_enumerate, const char *su
|
||||
{
|
||||
struct udev_list_entry *list_entry;
|
||||
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_nomatch_list)) {
|
||||
if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
|
||||
return 0;
|
||||
}
|
||||
if (list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) {
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->subsystem_match_list)) {
|
||||
if (udev_list_get_entry(&udev_enumerate->subsystem_match_list) != NULL) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->subsystem_match_list)) {
|
||||
if (fnmatch(udev_list_entry_get_name(list_entry), subsystem, 0) == 0)
|
||||
return 1;
|
||||
}
|
||||
@ -323,9 +323,9 @@ static int devices_sort(struct udev_enumerate *udev_enumerate)
|
||||
{
|
||||
struct udev_list_entry *list_entry;
|
||||
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->devices_list)) {
|
||||
if (devices_delay(udev_enumerate->udev, udev_list_entry_get_name(list_entry)))
|
||||
list_entry_move_to_end(list_entry);
|
||||
udev_list_entry_move_to_end(list_entry);
|
||||
}
|
||||
udev_enumerate->devices_sorted = 1;
|
||||
return 0;
|
||||
@ -344,8 +344,8 @@ 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;
|
||||
list_entry_add(udev, &udev_enumerate->devices_list,
|
||||
udev_device_get_syspath(udev_device), NULL, 1, 1);
|
||||
udev_list_entry_add(udev, &udev_enumerate->devices_list,
|
||||
udev_device_get_syspath(udev_device), NULL, 1, 1);
|
||||
udev_device_unref(udev_device);
|
||||
return 0;
|
||||
}
|
||||
@ -391,9 +391,9 @@ int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate)
|
||||
}
|
||||
}
|
||||
/* sort delayed devices to the end of the list */
|
||||
udev_list_entry_foreach(list_entry, list_get_entry(&udev_enumerate->devices_list)) {
|
||||
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->devices_list)) {
|
||||
if (devices_delay(udev, udev_list_entry_get_name(list_entry)))
|
||||
list_entry_move_to_end(list_entry);
|
||||
udev_list_entry_move_to_end(list_entry);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -29,27 +29,27 @@
|
||||
|
||||
struct udev_list_entry {
|
||||
struct udev *udev;
|
||||
struct list_node node;
|
||||
struct list_node *list;
|
||||
struct udev_list_node node;
|
||||
struct udev_list_node *list;
|
||||
char *name;
|
||||
char *value;
|
||||
};
|
||||
|
||||
/* list head point to itself if empty */
|
||||
void list_init(struct list_node *list)
|
||||
void udev_list_init(struct udev_list_node *list)
|
||||
{
|
||||
list->next = list;
|
||||
list->prev = list;
|
||||
}
|
||||
|
||||
static int list_is_empty(struct list_node *list)
|
||||
static int list_is_empty(struct udev_list_node *list)
|
||||
{
|
||||
return list->next == list;
|
||||
}
|
||||
|
||||
static void list_node_insert_between(struct list_node *new,
|
||||
struct list_node *prev,
|
||||
struct list_node *next)
|
||||
static void list_node_insert_between(struct udev_list_node *new,
|
||||
struct udev_list_node *prev,
|
||||
struct udev_list_node *next)
|
||||
{
|
||||
next->prev = new;
|
||||
new->next = next;
|
||||
@ -57,10 +57,10 @@ static void list_node_insert_between(struct list_node *new,
|
||||
prev->next = new;
|
||||
}
|
||||
|
||||
static void list_node_remove(struct list_node *entry)
|
||||
static void list_node_remove(struct udev_list_node *entry)
|
||||
{
|
||||
struct list_node *prev = entry->prev;
|
||||
struct list_node *next = entry->next;
|
||||
struct udev_list_node *prev = entry->prev;
|
||||
struct udev_list_node *next = entry->next;
|
||||
|
||||
next->prev = prev;
|
||||
prev->next = next;
|
||||
@ -70,7 +70,7 @@ static void list_node_remove(struct list_node *entry)
|
||||
}
|
||||
|
||||
/* return list entry which embeds this node */
|
||||
static struct udev_list_entry *list_node_to_entry(struct list_node *node)
|
||||
static struct udev_list_entry *list_node_to_entry(struct udev_list_node *node)
|
||||
{
|
||||
char *list;
|
||||
|
||||
@ -80,7 +80,7 @@ static struct udev_list_entry *list_node_to_entry(struct list_node *node)
|
||||
}
|
||||
|
||||
/* insert entry into a list as the last element */
|
||||
static void list_entry_append(struct udev_list_entry *new, struct list_node *list)
|
||||
static void list_entry_append(struct udev_list_entry *new, struct udev_list_node *list)
|
||||
{
|
||||
/* inserting before the list head make the node the last node in the list */
|
||||
list_node_insert_between(&new->node, list->prev, list);
|
||||
@ -94,21 +94,21 @@ static void list_entry_insert_before(struct udev_list_entry *new, struct udev_li
|
||||
new->list = entry->list;
|
||||
}
|
||||
|
||||
void list_entry_remove(struct udev_list_entry *entry)
|
||||
void udev_list_entry_remove(struct udev_list_entry *entry)
|
||||
{
|
||||
list_node_remove(&entry->node);
|
||||
entry->list = NULL;
|
||||
}
|
||||
|
||||
struct udev_list_entry *list_entry_add(struct udev *udev, struct list_node *list,
|
||||
const char *name, const char *value,
|
||||
int unique, int sort)
|
||||
struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_node *list,
|
||||
const char *name, const char *value,
|
||||
int unique, int sort)
|
||||
{
|
||||
struct udev_list_entry *entry_loop = NULL;
|
||||
struct udev_list_entry *entry_new;
|
||||
|
||||
if (unique)
|
||||
udev_list_entry_foreach(entry_loop, list_get_entry(list)) {
|
||||
udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
|
||||
if (strcmp(entry_loop->name, name) == 0) {
|
||||
info(udev, "'%s' is already in the list\n", name);
|
||||
if (value != NULL) {
|
||||
@ -123,7 +123,7 @@ struct udev_list_entry *list_entry_add(struct udev *udev, struct list_node *list
|
||||
}
|
||||
|
||||
if (sort)
|
||||
udev_list_entry_foreach(entry_loop, list_get_entry(list)) {
|
||||
udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
|
||||
if (strcmp(entry_loop->name, name) > 0)
|
||||
break;
|
||||
}
|
||||
@ -153,26 +153,26 @@ struct udev_list_entry *list_entry_add(struct udev *udev, struct list_node *list
|
||||
return entry_new;
|
||||
}
|
||||
|
||||
void list_entry_move_to_end(struct udev_list_entry *list_entry)
|
||||
void udev_list_entry_move_to_end(struct udev_list_entry *list_entry)
|
||||
{
|
||||
list_node_remove(&list_entry->node);
|
||||
list_node_insert_between(&list_entry->node, list_entry->list->prev, list_entry->list);
|
||||
}
|
||||
|
||||
void list_cleanup(struct udev *udev, struct list_node *list)
|
||||
void udev_list_cleanup(struct udev *udev, struct udev_list_node *list)
|
||||
{
|
||||
struct udev_list_entry *entry_loop;
|
||||
struct udev_list_entry *entry_tmp;
|
||||
|
||||
list_entry_foreach_safe(entry_loop, entry_tmp, list_get_entry(list)) {
|
||||
list_entry_remove(entry_loop);
|
||||
list_entry_foreach_safe(entry_loop, entry_tmp, udev_list_get_entry(list)) {
|
||||
udev_list_entry_remove(entry_loop);
|
||||
free(entry_loop->name);
|
||||
free(entry_loop->value);
|
||||
free(entry_loop);
|
||||
}
|
||||
}
|
||||
|
||||
struct udev_list_entry *list_get_entry(struct list_node *list)
|
||||
struct udev_list_entry *udev_list_get_entry(struct udev_list_node *list)
|
||||
{
|
||||
if (list_is_empty(list))
|
||||
return NULL;
|
||||
@ -181,7 +181,7 @@ struct udev_list_entry *list_get_entry(struct list_node *list)
|
||||
|
||||
struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry)
|
||||
{
|
||||
struct list_node *next;
|
||||
struct udev_list_node *next;
|
||||
|
||||
if (list_entry == NULL)
|
||||
return NULL;
|
||||
|
||||
@ -304,46 +304,46 @@ struct udev_device *udev_monitor_receive_device(struct udev_monitor *udev_monito
|
||||
|
||||
util_strlcpy(path, udev_get_sys_path(udev_monitor->udev), sizeof(path));
|
||||
util_strlcat(path, &key[8], sizeof(path));
|
||||
device_set_syspath(udev_device, path);
|
||||
udev_device_set_syspath(udev_device, path);
|
||||
} else if (strncmp(key, "SUBSYSTEM=", 10) == 0) {
|
||||
device_set_subsystem(udev_device, &key[10]);
|
||||
udev_device_set_subsystem(udev_device, &key[10]);
|
||||
} else if (strncmp(key, "DEVNAME=", 8) == 0) {
|
||||
device_set_devnode(udev_device, &key[8]);
|
||||
udev_device_set_devnode(udev_device, &key[8]);
|
||||
} else if (strncmp(key, "DEVLINKS=", 9) == 0) {
|
||||
char *slink = &key[9];
|
||||
char *next = strchr(slink, ' ');
|
||||
|
||||
while (next != NULL) {
|
||||
next[0] = '\0';
|
||||
device_add_devlink(udev_device, slink);
|
||||
udev_device_add_devlink(udev_device, slink);
|
||||
slink = &next[1];
|
||||
next = strchr(slink, ' ');
|
||||
}
|
||||
if (slink[0] != '\0')
|
||||
device_add_devlink(udev_device, slink);
|
||||
udev_device_add_devlink(udev_device, slink);
|
||||
} else if (strncmp(key, "DRIVER=", 7) == 0) {
|
||||
device_set_driver(udev_device, &key[7]);
|
||||
udev_device_set_driver(udev_device, &key[7]);
|
||||
} else if (strncmp(key, "ACTION=", 7) == 0) {
|
||||
device_set_action(udev_device, &key[7]);
|
||||
udev_device_set_action(udev_device, &key[7]);
|
||||
} else if (strncmp(key, "MAJOR=", 6) == 0) {
|
||||
maj = strtoull(&key[6], NULL, 10);
|
||||
} else if (strncmp(key, "MINOR=", 6) == 0) {
|
||||
min = strtoull(&key[6], NULL, 10);
|
||||
} else if (strncmp(key, "DEVPATH_OLD=", 12) == 0) {
|
||||
device_set_devpath_old(udev_device, &key[12]);
|
||||
udev_device_set_devpath_old(udev_device, &key[12]);
|
||||
} else if (strncmp(key, "PHYSDEVPATH=", 12) == 0) {
|
||||
device_set_physdevpath(udev_device, &key[12]);
|
||||
udev_device_set_physdevpath(udev_device, &key[12]);
|
||||
} else if (strncmp(key, "SEQNUM=", 7) == 0) {
|
||||
device_set_seqnum(udev_device, strtoull(&key[7], NULL, 10));
|
||||
udev_device_set_seqnum(udev_device, strtoull(&key[7], NULL, 10));
|
||||
} else if (strncmp(key, "TIMEOUT=", 8) == 0) {
|
||||
device_set_timeout(udev_device, strtoull(&key[8], NULL, 10));
|
||||
udev_device_set_timeout(udev_device, strtoull(&key[8], NULL, 10));
|
||||
}
|
||||
if (strncmp(key, "PHYSDEV", 7) == 0)
|
||||
continue;
|
||||
device_add_property_from_string(udev_device, key);
|
||||
udev_device_add_property_from_string(udev_device, key);
|
||||
}
|
||||
device_set_devnum(udev_device, makedev(maj, min));
|
||||
udev_device_set_devnum(udev_device, makedev(maj, min));
|
||||
|
||||
device_set_info_loaded(udev_device);
|
||||
udev_device_set_info_loaded(udev_device);
|
||||
return udev_device;
|
||||
}
|
||||
|
||||
@ -24,20 +24,20 @@
|
||||
#include "libudev.h"
|
||||
|
||||
static inline void __attribute__ ((format(printf, 2, 3)))
|
||||
log_null(struct udev *udev, const char *format, ...) {}
|
||||
udev_log_null(struct udev *udev, const char *format, ...) {}
|
||||
|
||||
#ifdef USE_LOG
|
||||
# ifdef DEBUG
|
||||
# define dbg(udev, arg...) udev_log(udev, LOG_DEBUG, __FILE__, __LINE__, __FUNCTION__, ## arg)
|
||||
# else
|
||||
# define dbg(udev, arg...) log_null(udev, ## arg)
|
||||
# define dbg(udev, arg...) udev_log_null(udev, ## arg)
|
||||
# endif
|
||||
# define info(udev, arg...) udev_log(udev, LOG_INFO, __FILE__, __LINE__, __FUNCTION__, ## arg)
|
||||
# define err(udev, arg...) udev_log(udev, LOG_ERR, __FILE__, __LINE__, __FUNCTION__, ## arg)
|
||||
#else
|
||||
# define dbg(udev, arg...) log_null(udev, ## arg)
|
||||
# define info(udev, arg...) log_null(udev, ## arg)
|
||||
# define err(udev, arg...) log_null(udev, ## arg)
|
||||
# define dbg(udev, arg...) udev_log_null(udev, ## arg)
|
||||
# define info(udev, arg...) udev_log_null(udev, ## arg)
|
||||
# define err(udev, arg...) udev_log_null(udev, ## arg)
|
||||
#endif
|
||||
|
||||
/* libudev */
|
||||
@ -50,31 +50,31 @@ extern const char *udev_get_rules_path(struct udev *udev);
|
||||
extern int udev_get_run(struct udev *udev);
|
||||
|
||||
/* libudev-device */
|
||||
extern int device_set_syspath(struct udev_device *udev_device, const char *syspath);
|
||||
extern int device_set_subsystem(struct udev_device *udev_device, const char *subsystem);
|
||||
extern int device_set_devnode(struct udev_device *udev_device, const char *devnode);
|
||||
extern int device_add_devlink(struct udev_device *udev_device, const char *devlink);
|
||||
extern int device_add_property(struct udev_device *udev_device, const char *key, const char *value);
|
||||
extern int device_add_property_from_string(struct udev_device *udev_device, const char *property);
|
||||
extern int device_set_action(struct udev_device *udev_device, const char *action);
|
||||
extern int device_set_driver(struct udev_device *udev_device, const char *driver);
|
||||
extern const char *device_get_devpath_old(struct udev_device *udev_device);
|
||||
extern int device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old);
|
||||
extern const char *device_get_physdevpath(struct udev_device *udev_device);
|
||||
extern int device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath);
|
||||
extern int device_get_timeout(struct udev_device *udev_device);
|
||||
extern int device_set_timeout(struct udev_device *udev_device, int timeout);
|
||||
extern int device_get_event_timeout(struct udev_device *udev_device);
|
||||
extern int device_set_event_timeout(struct udev_device *udev_device, int event_timeout);
|
||||
extern int device_set_devnum(struct udev_device *udev_device, dev_t devnum);
|
||||
extern int device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum);
|
||||
extern int device_get_num_fake_partitions(struct udev_device *udev_device);
|
||||
extern int device_set_num_fake_partitions(struct udev_device *udev_device, int num);
|
||||
extern int device_get_devlink_priority(struct udev_device *udev_device);
|
||||
extern int device_set_devlink_priority(struct udev_device *udev_device, int prio);
|
||||
extern int device_get_ignore_remove(struct udev_device *udev_device);
|
||||
extern int device_set_ignore_remove(struct udev_device *udev_device, int ignore);
|
||||
extern void device_set_info_loaded(struct udev_device *device);
|
||||
extern int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath);
|
||||
extern int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem);
|
||||
extern int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode);
|
||||
extern int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink);
|
||||
extern int udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value);
|
||||
extern int udev_device_add_property_from_string(struct udev_device *udev_device, const char *property);
|
||||
extern int udev_device_set_action(struct udev_device *udev_device, const char *action);
|
||||
extern int udev_device_set_driver(struct udev_device *udev_device, const char *driver);
|
||||
extern const char *udev_device_get_devpath_old(struct udev_device *udev_device);
|
||||
extern int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old);
|
||||
extern const char *udev_device_get_physdevpath(struct udev_device *udev_device);
|
||||
extern int udev_device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath);
|
||||
extern int udev_device_get_timeout(struct udev_device *udev_device);
|
||||
extern int udev_device_set_timeout(struct udev_device *udev_device, int timeout);
|
||||
extern int udev_device_get_event_timeout(struct udev_device *udev_device);
|
||||
extern int udev_device_set_event_timeout(struct udev_device *udev_device, int event_timeout);
|
||||
extern int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum);
|
||||
extern int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum);
|
||||
extern int udev_device_get_num_fake_partitions(struct udev_device *udev_device);
|
||||
extern int udev_device_set_num_fake_partitions(struct udev_device *udev_device, int num);
|
||||
extern int udev_device_get_devlink_priority(struct udev_device *udev_device);
|
||||
extern int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio);
|
||||
extern int udev_device_get_ignore_remove(struct udev_device *udev_device);
|
||||
extern int udev_device_set_ignore_remove(struct udev_device *udev_device, int ignore);
|
||||
extern void udev_device_set_info_loaded(struct udev_device *device);
|
||||
|
||||
/* libudev-ctrl - daemon runtime setup */
|
||||
struct udev_ctrl;
|
||||
@ -103,17 +103,17 @@ extern const char *udev_ctrl_get_set_env(struct udev_ctrl_msg *ctrl_msg);
|
||||
extern int udev_ctrl_get_set_max_childs(struct udev_ctrl_msg *ctrl_msg);
|
||||
|
||||
/* libudev-list */
|
||||
struct list_node {
|
||||
struct list_node *next, *prev;
|
||||
struct udev_list_node {
|
||||
struct udev_list_node *next, *prev;
|
||||
};
|
||||
extern void list_init(struct list_node *list);
|
||||
extern void list_cleanup(struct udev *udev, struct list_node *name_list);
|
||||
extern struct udev_list_entry *list_entry_add(struct udev *udev, struct list_node *list,
|
||||
const char *name, const char *value,
|
||||
int unique, int sort);
|
||||
extern void list_entry_remove(struct udev_list_entry *entry);
|
||||
extern struct udev_list_entry *list_get_entry(struct list_node *list);
|
||||
extern void list_entry_move_to_end(struct udev_list_entry *list_entry);
|
||||
extern void udev_list_init(struct udev_list_node *list);
|
||||
extern void udev_list_cleanup(struct udev *udev, struct udev_list_node *name_list);
|
||||
extern struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_node *list,
|
||||
const char *name, const char *value,
|
||||
int unique, int sort);
|
||||
extern void udev_list_entry_remove(struct udev_list_entry *entry);
|
||||
extern struct udev_list_entry *udev_list_get_entry(struct udev_list_node *list);
|
||||
extern void udev_list_entry_move_to_end(struct udev_list_entry *list_entry);
|
||||
#define list_entry_foreach_safe(entry, tmp, first) \
|
||||
for (entry = first, \
|
||||
tmp = udev_list_entry_get_next(entry); \
|
||||
@ -121,10 +121,10 @@ extern void list_entry_move_to_end(struct udev_list_entry *list_entry);
|
||||
entry = tmp, tmp = udev_list_entry_get_next(tmp))
|
||||
|
||||
/* libudev-queue */
|
||||
extern int queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum);
|
||||
extern int queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
extern int queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
extern int queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
extern int udev_queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum);
|
||||
extern int udev_queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
extern int udev_queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
extern int udev_queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device);
|
||||
|
||||
/* libudev-utils */
|
||||
#define UTIL_PATH_SIZE 1024
|
||||
|
||||
@ -34,8 +34,8 @@ struct udev_queue {
|
||||
struct udev *udev;
|
||||
int refcount;
|
||||
unsigned long long int last_seen_udev_seqnum;
|
||||
struct list_node queue_list;
|
||||
struct list_node failed_list;
|
||||
struct udev_list_node queue_list;
|
||||
struct udev_list_node failed_list;
|
||||
};
|
||||
|
||||
struct udev_queue *udev_queue_new(struct udev *udev)
|
||||
@ -51,8 +51,8 @@ struct udev_queue *udev_queue_new(struct udev *udev)
|
||||
memset(udev_queue, 0x00, sizeof(struct udev_queue));
|
||||
udev_queue->refcount = 1;
|
||||
udev_queue->udev = udev;
|
||||
list_init(&udev_queue->queue_list);
|
||||
list_init(&udev_queue->failed_list);
|
||||
udev_list_init(&udev_queue->queue_list);
|
||||
udev_list_init(&udev_queue->failed_list);
|
||||
return udev_queue;
|
||||
}
|
||||
|
||||
@ -71,8 +71,8 @@ void udev_queue_unref(struct udev_queue *udev_queue)
|
||||
udev_queue->refcount--;
|
||||
if (udev_queue->refcount > 0)
|
||||
return;
|
||||
list_cleanup(udev_queue->udev, &udev_queue->queue_list);
|
||||
list_cleanup(udev_queue->udev, &udev_queue->failed_list);
|
||||
udev_list_cleanup(udev_queue->udev, &udev_queue->queue_list);
|
||||
udev_list_cleanup(udev_queue->udev, &udev_queue->failed_list);
|
||||
free(udev_queue);
|
||||
}
|
||||
|
||||
@ -192,7 +192,7 @@ struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev
|
||||
|
||||
if (udev_queue == NULL)
|
||||
return NULL;
|
||||
list_cleanup(udev_queue->udev, &udev_queue->queue_list);
|
||||
udev_list_cleanup(udev_queue->udev, &udev_queue->queue_list);
|
||||
util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
|
||||
util_strlcat(path, "/.udev/queue", sizeof(path));
|
||||
dir = opendir(path);
|
||||
@ -216,10 +216,10 @@ struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev
|
||||
continue;
|
||||
syspath[syslen + len] = '\0';
|
||||
info(udev_queue->udev, "found '%s' [%s]\n", syspath, dent->d_name);
|
||||
list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, dent->d_name, 0, 0);
|
||||
udev_list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, dent->d_name, 0, 0);
|
||||
}
|
||||
closedir(dir);
|
||||
return list_get_entry(&udev_queue->queue_list);
|
||||
return udev_list_get_entry(&udev_queue->queue_list);
|
||||
}
|
||||
|
||||
struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev_queue)
|
||||
@ -230,7 +230,7 @@ struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev
|
||||
|
||||
if (udev_queue == NULL)
|
||||
return NULL;
|
||||
list_cleanup(udev_queue->udev, &udev_queue->failed_list);
|
||||
udev_list_cleanup(udev_queue->udev, &udev_queue->failed_list);
|
||||
util_strlcpy(path, udev_get_dev_path(udev_queue->udev), sizeof(path));
|
||||
util_strlcat(path, "/.udev/failed", sizeof(path));
|
||||
dir = opendir(path);
|
||||
@ -259,28 +259,28 @@ struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev
|
||||
util_strlcat(filename, "/uevent", sizeof(filename));
|
||||
if (stat(filename, &statbuf) != 0)
|
||||
continue;
|
||||
list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0, 0);
|
||||
udev_list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0, 0);
|
||||
}
|
||||
closedir(dir);
|
||||
return list_get_entry(&udev_queue->failed_list);
|
||||
return udev_list_get_entry(&udev_queue->failed_list);
|
||||
}
|
||||
|
||||
int queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum)
|
||||
int udev_queue_export_udev_seqnum(struct udev_queue *udev_queue, unsigned long long int seqnum)
|
||||
{
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
extern int queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
extern int udev_queue_export_device_queued(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
{
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
extern int queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
extern int udev_queue_export_device_finished(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
{
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
extern int queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
extern int udev_queue_export_device_failed(struct udev_queue *udev_queue, struct udev_device *udev_device)
|
||||
{
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user