shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2025-01-11 09:18:07 +03:00
Code

libudev: device - get_attr_value() -> get_sysattr_value()

Browse Source
This commit is contained in:
Kay Sievers 2008-10-20 18:12:36 +02:00
parent 2d9a1b1ef2
commit 69239210be
10 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
extras/usb_id/usb_id.c
View File

@ -221,7 +221,7 @@ static int usb_id(struct udev_device *dev)
return 1;
}
if_class = udev_device_get_attr_value(dev_interface, "bInterfaceClass");
if_class = udev_device_get_sysattr_value(dev_interface, "bInterfaceClass");
if (!if_class) {
info(udev, "%s: cannot get bInterfaceClass attribute\n",
udev_device_get_sysname(dev));
@ -229,7 +229,7 @@ static int usb_id(struct udev_device *dev)
}
if_class_num = strtoul(if_class, NULL, 16);
if (if_class_num == 8) {
if_subclass = udev_device_get_attr_value(dev_interface, "bInterfaceSubClass");
if_subclass = udev_device_get_sysattr_value(dev_interface, "bInterfaceSubClass");
if (if_subclass != NULL)
protocol = set_usb_mass_storage_ifsubtype(type_str, if_subclass, sizeof(type_str)-1);
} else {
@ -266,7 +266,7 @@ static int usb_id(struct udev_device *dev)
}
/* Generic SPC-2 device */
scsi_vendor = udev_device_get_attr_value(dev_scsi, "vendor");
scsi_vendor = udev_device_get_sysattr_value(dev_scsi, "vendor");
if (!scsi_vendor) {
info(udev, "%s: cannot get SCSI vendor attribute\n",
udev_device_get_sysname(dev_scsi));
@ -274,7 +274,7 @@ static int usb_id(struct udev_device *dev)
}
set_str(vendor_str, scsi_vendor, sizeof(vendor_str)-1);
scsi_model = udev_device_get_attr_value(dev_scsi, "model");
scsi_model = udev_device_get_sysattr_value(dev_scsi, "model");
if (!scsi_model) {
info(udev, "%s: cannot get SCSI model attribute\n",
udev_device_get_sysname(dev_scsi));
@ -282,7 +282,7 @@ static int usb_id(struct udev_device *dev)
}
set_str(model_str, scsi_model, sizeof(model_str)-1);
scsi_type = udev_device_get_attr_value(dev_scsi, "type");
scsi_type = udev_device_get_sysattr_value(dev_scsi, "type");
if (!scsi_type) {
info(udev, "%s: cannot get SCSI type attribute\n",
udev_device_get_sysname(dev_scsi));
@ -290,7 +290,7 @@ static int usb_id(struct udev_device *dev)
}
set_scsi_type(type_str, scsi_type, sizeof(type_str)-1);
scsi_rev = udev_device_get_attr_value(dev_scsi, "rev");
scsi_rev = udev_device_get_sysattr_value(dev_scsi, "rev");
if (!scsi_rev) {
info(udev, "%s: cannot get SCSI revision attribute\n",
udev_device_get_sysname(dev_scsi));
@ -311,10 +311,10 @@ fallback:
const char *usb_vendor = NULL;
if (!use_num_info)
usb_vendor = udev_device_get_attr_value(dev_usb, "manufacturer");
usb_vendor = udev_device_get_sysattr_value(dev_usb, "manufacturer");
if (!usb_vendor)
usb_vendor = udev_device_get_attr_value(dev_usb, "idVendor");
usb_vendor = udev_device_get_sysattr_value(dev_usb, "idVendor");
if (!usb_vendor) {
info(udev, "No USB vendor information available\n");
@ -327,10 +327,10 @@ fallback:
const char *usb_model = NULL;
if (!use_num_info)
usb_model = udev_device_get_attr_value(dev_usb, "product");
usb_model = udev_device_get_sysattr_value(dev_usb, "product");
if (!usb_model)
usb_model = udev_device_get_attr_value(dev_usb, "idProduct");
usb_model = udev_device_get_sysattr_value(dev_usb, "idProduct");
if (!usb_model) {
dbg(udev, "No USB model information available\n");
@ -342,7 +342,7 @@ fallback:
if (revision_str[0] == '\0') {
const char *usb_rev;
usb_rev = udev_device_get_attr_value(dev_usb, "bcdDevice");
usb_rev = udev_device_get_sysattr_value(dev_usb, "bcdDevice");
if (usb_rev)
set_str(revision_str, usb_rev, sizeof(revision_str)-1);
}
@ -350,7 +350,7 @@ fallback:
if (serial_str[0] == '\0') {
const char *usb_serial;
usb_serial = udev_device_get_attr_value(dev_usb, "serial");
usb_serial = udev_device_get_sysattr_value(dev_usb, "serial");
if (usb_serial)
set_str(serial_str, usb_serial, sizeof(serial_str)-1);
}

2
udev/Makefile.am
View File

@ -17,7 +17,7 @@ common_files = \
udev-sysdeps.h \
udev-event.c \
udev-node.c \
udev-rules.c \
udev-rules2.c \
udev-util.c \
lib/libudev.h \
lib/libudev-private.h \

6
udev/lib/exported_symbols
View File

@ -32,7 +32,7 @@ udev_device_get_action
udev_device_get_driver
udev_device_get_devnum
udev_device_get_seqnum
udev_device_get_attr_value
udev_device_get_sysattr_value
udev_enumerate_new
udev_enumerate_ref
udev_enumerate_unref
@ -40,8 +40,8 @@ udev_enumerate_get_udev
udev_enumerate_get_list_entry
udev_enumerate_add_match_subsystem
udev_enumerate_add_nomatch_subsystem
udev_enumerate_add_match_attr
udev_enumerate_add_nomatch_attr
udev_enumerate_add_match_sysattr
udev_enumerate_add_nomatch_sysattr
udev_enumerate_scan_devices
udev_enumerate_scan_subsystems
udev_enumerate_add_syspath

26
udev/lib/libudev-device.c
View File

@ -60,7 +60,7 @@ struct udev_device {
int num_fake_partitions;
int devlink_priority;
int ignore_remove;
struct udev_list_node attr_list;
struct udev_list_node sysattr_list;
int info_loaded;
};
@ -244,7 +244,7 @@ struct udev_device *device_new(struct udev *udev)
udev_device->udev = udev;
udev_list_init(&udev_device->devlinks_list);
udev_list_init(&udev_device->properties_list);
udev_list_init(&udev_device->attr_list);
udev_list_init(&udev_device->sysattr_list);
udev_device->event_timeout = -1;
/* copy global properties */
udev_list_entry_foreach(list_entry, udev_get_properties_list_entry(udev))
@ -610,7 +610,7 @@ void udev_device_unref(struct udev_device *udev_device)
free(udev_device->driver);
free(udev_device->devpath_old);
free(udev_device->physdevpath);
udev_list_cleanup_entries(udev_device->udev, &udev_device->attr_list);
udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
for (i = 0; i < ARRAY_SIZE(udev_device->envp) && udev_device->envp[i] != NULL; i++)
free(udev_device->envp[i]);
info(udev_device->udev, "udev_device: %p released\n", udev_device);
@ -823,7 +823,7 @@ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
return udev_device->seqnum;
}
const char *udev_device_get_attr_value(struct udev_device *udev_device, const char *attr)
const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
{
struct udev_list_entry *list_entry;
char path[UTIL_PATH_SIZE];
@ -835,25 +835,25 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch
if (udev_device == NULL)
return NULL;
if (attr == NULL)
if (sysattr == NULL)
return NULL;
/* look for possibly already cached result */
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) {
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_device->sysattr_list)) {
if (strcmp(udev_list_entry_get_name(list_entry), sysattr) == 0) {
info(udev_device->udev, "got '%s' (%s) from cache\n",
attr, udev_list_entry_get_value(list_entry));
sysattr, udev_list_entry_get_value(list_entry));
return udev_list_entry_get_value(list_entry);
}
}
util_strlcpy(path, udev_device_get_syspath(udev_device), sizeof(path));
util_strlcat(path, "/", sizeof(path));
util_strlcat(path, attr, sizeof(path));
util_strlcat(path, sysattr, sizeof(path));
if (lstat(path, &statbuf) != 0) {
info(udev_device->udev, "no attribute '%s', keep negative entry\n", path);
udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, NULL, 0, 0);
udev_list_entry_add(udev_device->udev, &udev_device->sysattr_list, sysattr, NULL, 0, 0);
goto out;
}
@ -869,8 +869,8 @@ const char *udev_device_get_attr_value(struct udev_device *udev_device, const ch
pos = strrchr(target, '/');
if (pos != NULL) {
pos = &pos[1];
info(udev_device->udev, "cache '%s' with link value '%s'\n", attr, pos);
list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0);
info(udev_device->udev, "cache '%s' with link value '%s'\n", sysattr, pos);
list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_list, sysattr, pos, 0, 0);
val = udev_list_entry_get_value(list_entry);
}
}
@ -902,7 +902,7 @@ 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 = udev_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->sysattr_list, sysattr, value, 0, 0);
val = udev_list_entry_get_value(list_entry);
out:
return val;

42
udev/lib/libudev-enumerate.c
View File

@ -35,8 +35,8 @@ static int devices_sort(struct udev_enumerate *udev_enumerate);
struct udev_enumerate {
struct udev *udev;
int refcount;
struct udev_list_node attr_match_list;
struct udev_list_node attr_nomatch_list;
struct udev_list_node sysattr_match_list;
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 devices_list;
@ -60,8 +60,8 @@ struct udev_enumerate *udev_enumerate_new(struct udev *udev)
udev_enumerate->refcount = 1;
udev_enumerate->udev = udev;
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->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);
return udev_enumerate;
@ -83,8 +83,8 @@ void udev_enumerate_unref(struct udev_enumerate *udev_enumerate)
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->attr_match_list);
udev_list_cleanup_entries(udev_enumerate->udev, &udev_enumerate->attr_nomatch_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);
free(udev_enumerate);
@ -130,31 +130,31 @@ int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate,
return 0;
}
int udev_enumerate_add_match_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value)
int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
{
if (udev_enumerate == NULL)
return -EINVAL;
if (attr == NULL)
if (sysattr == NULL)
return 0;
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
&udev_enumerate->attr_match_list, attr, value, 1, 0) == NULL)
&udev_enumerate->sysattr_match_list, sysattr, value, 1, 0) == NULL)
return -ENOMEM;
return 0;
}
int udev_enumerate_add_nomatch_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value)
int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value)
{
if (udev_enumerate == NULL)
return -EINVAL;
if (attr == NULL)
if (sysattr == NULL)
return 0;
if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
&udev_enumerate->attr_nomatch_list, attr, value, 1, 0) == NULL)
&udev_enumerate->sysattr_nomatch_list, sysattr, value, 1, 0) == NULL)
return -ENOMEM;
return 0;
}
static int match_attr_value(struct udev *udev, const char *syspath, const char *attr, const char *match_val)
static int match_sysattr_value(struct udev *udev, const char *syspath, const char *sysattr, const char *match_val)
{
struct udev_device *device;
const char *val = NULL;
@ -163,7 +163,7 @@ static int match_attr_value(struct udev *udev, const char *syspath, const char *
device = udev_device_new_from_syspath(udev, syspath);
if (device == NULL)
return -EINVAL;
val = udev_device_get_attr_value(device, attr);
val = udev_device_get_sysattr_value(device, sysattr);
if (val == NULL)
goto exit;
if (match_val == NULL) {
@ -179,23 +179,23 @@ exit:
return match;
}
static int match_attr(struct udev_enumerate *udev_enumerate, const char *syspath)
static int match_sysattr(struct udev_enumerate *udev_enumerate, const char *syspath)
{
struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
struct udev_list_entry *list_entry;
/* skip 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_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_nomatch_list)) {
if (match_sysattr_value(udev, syspath,
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry)))
return 0;
}
/* include 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)) {
if (udev_list_get_entry(&udev_enumerate->sysattr_match_list) != NULL) {
udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_enumerate->sysattr_match_list)) {
/* anything that does not match, will make it FALSE */
if (!match_attr_value(udev, syspath,
if (!match_sysattr_value(udev, syspath,
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry)))
return 0;
@ -247,7 +247,7 @@ static int scan_dir_and_add_devices(struct udev_enumerate *udev_enumerate,
util_strlcat(filename, "/uevent", sizeof(filename));
if (stat(filename, &statbuf) != 0)
continue;
if (!match_attr(udev_enumerate, syspath))
if (!match_sysattr(udev_enumerate, syspath))
continue;
udev_list_entry_add(udev, &udev_enumerate->devices_list, syspath, NULL, 1, 1);
}

6
udev/lib/libudev.h
View File

@ -77,7 +77,7 @@ extern const char *udev_device_get_driver(struct udev_device *udev_device);
extern dev_t udev_device_get_devnum(struct udev_device *udev_device);
extern const char *udev_device_get_action(struct udev_device *udev_device);
extern unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device);
extern const char *udev_device_get_attr_value(struct udev_device *udev_device, const char *attr);
extern const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr);
/* udev and kernel device events */
struct udev_monitor;
@ -98,8 +98,8 @@ extern void udev_enumerate_unref(struct udev_enumerate *udev_enumerate);
extern struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate);
extern int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem);
extern int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem);
extern int udev_enumerate_add_match_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value);
extern int udev_enumerate_add_nomatch_attr(struct udev_enumerate *udev_enumerate, const char *attr, const char *value);
extern int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value);
extern int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value);
extern int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath);
extern int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate);
extern int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate);

2
udev/lib/test-libudev.c
View File

@ -97,7 +97,7 @@ static void print_device(struct udev_device *device)
if (count > 0)
printf("found %i properties\n", count);
str = udev_device_get_attr_value(device, "dev");
str = udev_device_get_sysattr_value(device, "dev");
if (str != NULL)
printf("attr{dev}: '%s'\n", str);

6
udev/udev-event.c
View File

@ -141,7 +141,7 @@ int udev_event_apply_subsys_kernel(struct udev_event *udev_event, const char *st
if (read_value) {
const char *val;
val = udev_device_get_attr_value(dev, attr);
val = udev_device_get_sysattr_value(dev, attr);
if (val != NULL)
util_strlcpy(result, val, maxsize);
else
@ -359,7 +359,7 @@ found:
if (value[0] == '\0' && event->dev_parent != NULL && event->dev_parent != event->dev) {
const char *val;
val = udev_device_get_attr_value(event->dev_parent, attr);
val = udev_device_get_sysattr_value(event->dev_parent, attr);
if (val != NULL)
util_strlcpy(value, val, sizeof(value));
}
@ -371,7 +371,7 @@ found:
do {
dbg(event->udev, "looking at '%s'\n", udev_device_get_syspath(dev_parent));
val = udev_device_get_attr_value(dev_parent, attr);
val = udev_device_get_sysattr_value(dev_parent, attr);
if (val != NULL) {
util_strlcpy(value, val, sizeof(value));
break;

2
udev/udevadm-info.c
View File

@ -60,7 +60,7 @@ static void print_all_attributes(struct udev_device *device, const char *key)
if (S_ISLNK(statbuf.st_mode))
continue;
value = udev_device_get_attr_value(device, dent->d_name);
value = udev_device_get_sysattr_value(device, dent->d_name);
if (value == NULL)
continue;
dbg(udev, "attr '%s'='%s'(%zi)\n", dent->d_name, value, len);

4
udev/udevadm-trigger.c
View File

@ -156,7 +156,7 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
val[0] = 0;
val = &val[1];
}
udev_enumerate_add_match_attr(udev_enumerate, attr, val);
udev_enumerate_add_match_sysattr(udev_enumerate, attr, val);
break;
case 'A':
util_strlcpy(attr, optarg, sizeof(attr));
@ -165,7 +165,7 @@ int udevadm_trigger(struct udev *udev, int argc, char *argv[])
val[0] = 0;
val = &val[1];
}
udev_enumerate_add_nomatch_attr(udev_enumerate, attr, val);
udev_enumerate_add_nomatch_sysattr(udev_enumerate, attr, val);
break;
case 'h':
printf("Usage: udevadm trigger OPTIONS\n"