X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=libudev%2Flibudev-device.c;h=991398c76d4df2c22a9267c3b515658feee8395e;hp=af0bc2e5a3e457a49e827dcd7b586963e6b93c14;hb=2fdaa983a958822d79821c1afe51e22e7a3e00ff;hpb=f180ad259f1480a3d58106e38eb760f79600e0e1

diff --git a/libudev/libudev-device.c b/libudev/libudev-device.c
index af0bc2e5a..991398c76 100644
--- a/libudev/libudev-device.c
+++ b/libudev/libudev-device.c
@@ -19,7 +19,11 @@
 #include <dirent.h>
 #include <fcntl.h>
 #include <ctype.h>
+#include <net/if.h>
 #include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/sockios.h>
 
 #include "libudev.h"
 #include "libudev-private.h"
@@ -47,25 +51,24 @@ struct udev_device {
 	char *sysname;
 	const char *sysnum;
 	char *devnode;
+	mode_t devnode_mode;
 	char *subsystem;
 	char *devtype;
 	char *driver;
 	char *action;
 	char *devpath_old;
-	char *sysname_old;
 	char *knodename;
 	char *id_filename;
 	char **envp;
 	char *monitor_buf;
 	size_t monitor_buf_len;
-	struct udev_list_node devlinks_list;
-	struct udev_list_node properties_list;
-	struct udev_list_node sysattr_list;
-	struct udev_list_node available_sysattr_list;
-	struct udev_list_node tags_list;
+	struct udev_list devlinks_list;
+	struct udev_list properties_list;
+	struct udev_list sysattr_value_list;
+	struct udev_list sysattr_list;
+	struct udev_list tags_list;
 	unsigned long long int seqnum;
 	unsigned long long int usec_initialized;
-	int event_timeout;
 	int timeout;
 	int devlink_priority;
 	int refcount;
@@ -84,9 +87,264 @@ struct udev_device {
 	bool db_loaded;
 	bool uevent_loaded;
 	bool is_initialized;
-	bool sysattrs_cached;
+	bool sysattr_list_read;
+	bool db_persist;
 };
 
+/**
+ * udev_device_get_devnum:
+ * @udev_device: udev device
+ *
+ * This is only valid if the device was received through a monitor. Devices read from
+ * sys do not have a sequence number.
+ *
+ * Returns: the kernel event sequence number, or 0 if there is no sequence number available.
+ **/
+UDEV_EXPORT unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
+{
+	if (udev_device == NULL)
+		return 0;
+	return udev_device->seqnum;
+}
+
+static int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
+{
+	char num[32];
+
+	udev_device->seqnum = seqnum;
+	snprintf(num, sizeof(num), "%llu", seqnum);
+	udev_device_add_property(udev_device, "SEQNUM", num);
+	return 0;
+}
+
+int udev_device_get_ifindex(struct udev_device *udev_device)
+{
+	if (!udev_device->info_loaded)
+		udev_device_read_uevent_file(udev_device);
+	return udev_device->ifindex;
+}
+
+static int udev_device_set_ifindex(struct udev_device *udev_device, int ifindex)
+{
+	char num[32];
+
+	udev_device->ifindex = ifindex;
+	snprintf(num, sizeof(num), "%u", ifindex);
+	udev_device_add_property(udev_device, "IFINDEX", num);
+	return 0;
+}
+
+/**
+ * udev_device_get_devnum:
+ * @udev_device: udev device
+ *
+ * Returns: the device major/minor number.
+ **/
+UDEV_EXPORT dev_t udev_device_get_devnum(struct udev_device *udev_device)
+{
+	if (udev_device == NULL)
+		return makedev(0, 0);
+	if (!udev_device->info_loaded)
+		udev_device_read_uevent_file(udev_device);
+	return udev_device->devnum;
+}
+
+static int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
+{
+	char num[32];
+
+	udev_device->devnum = devnum;
+
+	snprintf(num, sizeof(num), "%u", major(devnum));
+	udev_device_add_property(udev_device, "MAJOR", num);
+	snprintf(num, sizeof(num), "%u", minor(devnum));
+	udev_device_add_property(udev_device, "MINOR", num);
+	return 0;
+}
+
+int udev_device_get_timeout(struct udev_device *udev_device)
+{
+	return udev_device->timeout;
+}
+
+static int udev_device_set_timeout(struct udev_device *udev_device, int timeout)
+{
+	char num[32];
+
+	udev_device->timeout = timeout;
+	snprintf(num, sizeof(num), "%u", timeout);
+	udev_device_add_property(udev_device, "TIMEOUT", num);
+	return 0;
+}
+
+const char *udev_device_get_knodename(struct udev_device *udev_device)
+{
+	return udev_device->knodename;
+}
+
+static int udev_device_set_knodename(struct udev_device *udev_device, const char *knodename)
+{
+	free(udev_device->knodename);
+	udev_device->knodename = strdup(knodename);
+	if (udev_device->knodename == NULL)
+		return -ENOMEM;
+	/* do not overwrite the udev property with the kernel property */
+	if (udev_device->devnode == NULL)
+		udev_device_add_property(udev_device, "DEVNAME", udev_device->knodename);
+	return 0;
+}
+
+const char *udev_device_get_devpath_old(struct udev_device *udev_device)
+{
+	return udev_device->devpath_old;
+}
+
+static int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
+{
+	const char *pos;
+
+	free(udev_device->devpath_old);
+	udev_device->devpath_old = strdup(devpath_old);
+	if (udev_device->devpath_old == NULL)
+		return -ENOMEM;
+	udev_device_add_property(udev_device, "DEVPATH_OLD", udev_device->devpath_old);
+
+	pos = strrchr(udev_device->devpath_old, '/');
+	if (pos == NULL)
+		return -EINVAL;
+	return 0;
+}
+
+/**
+ * udev_device_get_driver:
+ * @udev_device: udev device
+ *
+ * Returns: the driver string, or #NULL if there is no driver attached.
+ **/
+UDEV_EXPORT const char *udev_device_get_driver(struct udev_device *udev_device)
+{
+	char driver[UTIL_NAME_SIZE];
+
+	if (udev_device == NULL)
+		return NULL;
+	if (!udev_device->driver_set) {
+		udev_device->driver_set = true;
+		if (util_get_sys_core_link_value(udev_device->udev, "driver", udev_device->syspath, driver, sizeof(driver)) > 0)
+			udev_device->driver = strdup(driver);
+	}
+	return udev_device->driver;
+}
+
+static int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
+{
+	free(udev_device->driver);
+	udev_device->driver = strdup(driver);
+	if (udev_device->driver == NULL)
+		return -ENOMEM;
+	udev_device->driver_set = true;
+	udev_device_add_property(udev_device, "DRIVER", udev_device->driver);
+	return 0;
+}
+
+/**
+ * udev_device_get_devtype:
+ * @udev_device: udev device
+ *
+ * Retrieve the devtype string of the udev device.
+ *
+ * Returns: the devtype name of the udev device, or #NULL if it can not be determined
+ **/
+UDEV_EXPORT const char *udev_device_get_devtype(struct udev_device *udev_device)
+{
+	if (udev_device == NULL)
+		return NULL;
+	if (!udev_device->devtype_set) {
+		udev_device->devtype_set = true;
+		udev_device_read_uevent_file(udev_device);
+	}
+	return udev_device->devtype;
+}
+
+static int udev_device_set_devtype(struct udev_device *udev_device, const char *devtype)
+{
+	free(udev_device->devtype);
+	udev_device->devtype = strdup(devtype);
+	if (udev_device->devtype == NULL)
+		return -ENOMEM;
+	udev_device->devtype_set = true;
+	udev_device_add_property(udev_device, "DEVTYPE", udev_device->devtype);
+	return 0;
+}
+
+static int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
+{
+	free(udev_device->subsystem);
+	udev_device->subsystem = strdup(subsystem);
+	if (udev_device->subsystem == NULL)
+		return -ENOMEM;
+	udev_device->subsystem_set = true;
+	udev_device_add_property(udev_device, "SUBSYSTEM", udev_device->subsystem);
+	return 0;
+}
+
+/**
+ * udev_device_get_subsystem:
+ * @udev_device: udev device
+ *
+ * Retrieve the subsystem string of the udev device. The string does not
+ * contain any "/".
+ *
+ * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
+ **/
+UDEV_EXPORT const char *udev_device_get_subsystem(struct udev_device *udev_device)
+{
+	char subsystem[UTIL_NAME_SIZE];
+
+	if (udev_device == NULL)
+		return NULL;
+	if (!udev_device->subsystem_set) {
+		udev_device->subsystem_set = true;
+		/* read "subsystem" link */
+		if (util_get_sys_core_link_value(udev_device->udev, "subsystem", udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
+			udev_device_set_subsystem(udev_device, subsystem);
+			return udev_device->subsystem;
+		}
+		/* implicit names */
+		if (strncmp(udev_device->devpath, "/module/", 8) == 0) {
+			udev_device_set_subsystem(udev_device, "module");
+			return udev_device->subsystem;
+		}
+		if (strstr(udev_device->devpath, "/drivers/") != NULL) {
+			udev_device_set_subsystem(udev_device, "drivers");
+			return udev_device->subsystem;
+		}
+		if (strncmp(udev_device->devpath, "/subsystem/", 11) == 0 ||
+		    strncmp(udev_device->devpath, "/class/", 7) == 0 ||
+		    strncmp(udev_device->devpath, "/bus/", 5) == 0) {
+			udev_device_set_subsystem(udev_device, "subsystem");
+			return udev_device->subsystem;
+		}
+	}
+	return udev_device->subsystem;
+}
+
+mode_t udev_device_get_devnode_mode(struct udev_device *udev_device)
+{
+	if (!udev_device->info_loaded)
+		udev_device_read_uevent_file(udev_device);
+	return udev_device->devnode_mode;
+}
+
+static int udev_device_set_devnode_mode(struct udev_device *udev_device, mode_t mode)
+{
+	char num[32];
+
+	udev_device->devnode_mode = mode;
+	snprintf(num, sizeof(num), "%#o", mode);
+	udev_device_add_property(udev_device, "DEVMODE", num);
+	return 0;
+}
+
 struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
 {
 	udev_device->envp_uptodate = false;
@@ -99,7 +357,7 @@ struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device
 			udev_list_entry_delete(list_entry);
 		return NULL;
 	}
-	return udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0);
+	return udev_list_entry_add(&udev_device->properties_list, key, value);
 }
 
 static struct udev_list_entry *udev_device_add_property_from_string(struct udev_device *udev_device, const char *property)
@@ -179,6 +437,8 @@ void udev_device_add_property_from_string_parse(struct udev_device *udev_device,
 				udev_device_add_tag(udev_device, tag);
 			}
 		}
+	} else if (strncmp(property, "USEC_INITIALIZED=", 19) == 0) {
+		udev_device_set_usec_initialized(udev_device, strtoull(&property[19], NULL, 10));
 	} else if (strncmp(property, "DRIVER=", 7) == 0) {
 		udev_device_set_driver(udev_device, &property[7]);
 	} else if (strncmp(property, "ACTION=", 7) == 0) {
@@ -195,6 +455,8 @@ void udev_device_add_property_from_string_parse(struct udev_device *udev_device,
 		udev_device_set_timeout(udev_device, strtoull(&property[8], NULL, 10));
 	} else if (strncmp(property, "IFINDEX=", 8) == 0) {
 		udev_device_set_ifindex(udev_device, strtoull(&property[8], NULL, 10));
+	} else if (strncmp(property, "DEVMODE=", 8) == 0) {
+		udev_device_set_devnode_mode(udev_device, strtoul(&property[8], NULL, 8));
 	} else {
 		udev_device_add_property_from_string(udev_device, property);
 	}
@@ -219,7 +481,7 @@ int udev_device_add_property_from_string_parse_finish(struct udev_device *udev_d
  *
  * Returns: the value of a device property, or #NULL if there is no such property.
  **/
-const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
+UDEV_EXPORT const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
 {
 	struct udev_list_entry *list_entry;
 
@@ -229,28 +491,34 @@ const char *udev_device_get_property_value(struct udev_device *udev_device, cons
 		return NULL;
 
 	list_entry = udev_device_get_properties_list_entry(udev_device);
-	list_entry =  udev_list_entry_get_by_name(list_entry, key);
+	list_entry = udev_list_entry_get_by_name(list_entry, key);
 	return udev_list_entry_get_value(list_entry);
 }
 
-int udev_device_read_db(struct udev_device *udev_device)
+int udev_device_read_db(struct udev_device *udev_device, const char *dbfile)
 {
-	const char *id;
 	char filename[UTIL_PATH_SIZE];
 	char line[UTIL_LINE_SIZE];
 	FILE *f;
 
-	if (udev_device->db_loaded)
-		return 0;
-	udev_device->db_loaded = true;
+	/* providing a database file will always force-load it */
+	if (dbfile == NULL) {
+		const char *id;
 
-	id = udev_device_get_id_filename(udev_device);
-	if (id == NULL)
-		return -1;
-	util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev_device->udev), "/.udev/db/", id, NULL);
-	f = fopen(filename, "re");
+		if (udev_device->db_loaded)
+			return 0;
+		udev_device->db_loaded = true;
+
+		id = udev_device_get_id_filename(udev_device);
+		if (id == NULL)
+			return -1;
+		util_strscpyl(filename, sizeof(filename), udev_get_run_path(udev_device->udev), "/data/", id, NULL);
+		dbfile = filename;
+	}
+
+	f = fopen(dbfile, "re");
 	if (f == NULL) {
-		info(udev_device->udev, "no db file to read %s: %m\n", filename);
+		info(udev_device->udev, "no db file to read %s: %m\n", dbfile);
 		return -1;
 	}
 	udev_device->is_initialized = true;
@@ -279,7 +547,7 @@ int udev_device_read_db(struct udev_device *udev_device)
 			break;
 		case 'E':
 			entry = udev_device_add_property_from_string(udev_device, val);
-			udev_list_entry_set_flags(entry, 1);
+			udev_list_entry_set_num(entry, true);
 			break;
 		case 'G':
 			udev_device_add_tag(udev_device, val);
@@ -333,6 +601,8 @@ int udev_device_read_uevent_file(struct udev_device *udev_device)
 			udev_device_set_ifindex(udev_device, strtoull(&line[8], NULL, 10));
 		else if (strncmp(line, "DEVNAME=", 8) == 0)
 			udev_device_set_knodename(udev_device, &line[8]);
+		else if (strncmp(line, "DEVMODE=", 8) == 0)
+			udev_device->devnode_mode = strtoul(&line[8], NULL, 8);
 
 		udev_device_add_property_from_string(udev_device, line);
 	}
@@ -360,12 +630,12 @@ struct udev_device *udev_device_new(struct udev *udev)
 		return NULL;
 	udev_device->refcount = 1;
 	udev_device->udev = udev;
-	udev_list_init(&udev_device->devlinks_list);
-	udev_list_init(&udev_device->properties_list);
-	udev_list_init(&udev_device->sysattr_list);
-	udev_list_init(&udev_device->available_sysattr_list);
-	udev_list_init(&udev_device->tags_list);
-	udev_device->event_timeout = -1;
+	udev_list_init(udev, &udev_device->devlinks_list, true);
+	udev_list_init(udev, &udev_device->properties_list, true);
+	udev_list_init(udev, &udev_device->sysattr_value_list, true);
+	udev_list_init(udev, &udev_device->sysattr_list, false);
+	udev_list_init(udev, &udev_device->tags_list, true);
+	udev_device->timeout = -1;
 	udev_device->watch_handle = -1;
 	/* copy global properties */
 	udev_list_entry_foreach(list_entry, udev_get_properties_list_entry(udev))
@@ -390,7 +660,7 @@ struct udev_device *udev_device_new(struct udev *udev)
  *
  * Returns: a new udev device, or #NULL, if it does not exist
  **/
-struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath)
+UDEV_EXPORT struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *syspath)
 {
 	size_t len;
 	const char *subdir;
@@ -466,7 +736,7 @@ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *
  *
  * Returns: a new udev device, or #NULL, if it does not exist
  **/
-struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
+UDEV_EXPORT struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, dev_t devnum)
 {
 	char path[UTIL_PATH_SIZE];
 	const char *type_str;
@@ -497,6 +767,35 @@ struct udev_device *udev_device_new_from_id_filename(struct udev *udev, char *id
 		if (sscanf(id, "%c%i:%i", &type, &maj, &min) != 3)
 			return NULL;
 		return udev_device_new_from_devnum(udev, type, makedev(maj, min));
+	case 'n': {
+		int sk;
+		struct ifreq ifr;
+		struct udev_device *dev;
+		int ifindex;
+
+		ifindex = strtoul(&id[1], NULL, 10);
+		if (ifindex <= 0)
+			return NULL;
+
+		sk = socket(PF_INET, SOCK_DGRAM, 0);
+		if (sk < 0)
+			return NULL;
+		memset(&ifr, 0x00, sizeof(struct ifreq));
+		ifr.ifr_ifindex = ifindex;
+		if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) {
+			close(sk);
+			return NULL;
+		}
+		close(sk);
+
+		dev = udev_device_new_from_subsystem_sysname(udev, "net", ifr.ifr_name);
+		if (dev == NULL)
+			return NULL;
+		if (udev_device_get_ifindex(dev) == ifindex)
+			return dev;
+		udev_device_unref(dev);
+		return NULL;
+	}
 	case '+':
 		util_strscpy(subsys, sizeof(subsys), &id[1]);
 		sysname = strchr(subsys, ':');
@@ -525,7 +824,7 @@ struct udev_device *udev_device_new_from_id_filename(struct udev *udev, char *id
  *
  * Returns: a new udev device, or #NULL, if it does not exist
  **/
-struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
+UDEV_EXPORT struct udev_device *udev_device_new_from_subsystem_sysname(struct udev *udev, const char *subsystem, const char *sysname)
 {
 	char path_full[UTIL_PATH_SIZE];
 	char *path;
@@ -609,7 +908,7 @@ found:
  *
  * Returns: a new udev device, or #NULL, if it does not exist
  **/
-struct udev_device *udev_device_new_from_environment(struct udev *udev)
+UDEV_EXPORT struct udev_device *udev_device_new_from_environment(struct udev *udev)
 {
 	int i;
 	struct udev_device *udev_device;
@@ -672,7 +971,7 @@ static struct udev_device *device_new_from_parent(struct udev_device *udev_devic
  *
  * Returns: a new udev device, or #NULL, if it no parent exist.
  **/
-struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -707,7 +1006,7 @@ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
  *
  * Returns: a new udev device, or #NULL if no matching parent exists.
  **/
-struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
+UDEV_EXPORT struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 {
 	struct udev_device *parent;
 
@@ -740,7 +1039,7 @@ struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_de
  *
  * Returns: the udev library context
  **/
-struct udev *udev_device_get_udev(struct udev_device *udev_device)
+UDEV_EXPORT struct udev *udev_device_get_udev(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -755,7 +1054,7 @@ struct udev *udev_device_get_udev(struct udev_device *udev_device)
  *
  * Returns: the passed udev device
  **/
-struct udev_device *udev_device_ref(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_device *udev_device_ref(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -771,7 +1070,7 @@ struct udev_device *udev_device_ref(struct udev_device *udev_device)
  * the resources of the device will be released.
  *
  **/
-void udev_device_unref(struct udev_device *udev_device)
+UDEV_EXPORT void udev_device_unref(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return;
@@ -785,15 +1084,14 @@ void udev_device_unref(struct udev_device *udev_device)
 	free(udev_device->devnode);
 	free(udev_device->subsystem);
 	free(udev_device->devtype);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->devlinks_list);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->properties_list);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->available_sysattr_list);
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->tags_list);
+	udev_list_cleanup(&udev_device->devlinks_list);
+	udev_list_cleanup(&udev_device->properties_list);
+	udev_list_cleanup(&udev_device->sysattr_value_list);
+	udev_list_cleanup(&udev_device->sysattr_list);
+	udev_list_cleanup(&udev_device->tags_list);
 	free(udev_device->action);
 	free(udev_device->driver);
 	free(udev_device->devpath_old);
-	free(udev_device->sysname_old);
 	free(udev_device->knodename);
 	free(udev_device->id_filename);
 	free(udev_device->envp);
@@ -811,7 +1109,7 @@ void udev_device_unref(struct udev_device *udev_device)
  *
  * Returns: the devpath of the udev device
  **/
-const char *udev_device_get_devpath(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_devpath(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -827,7 +1125,7 @@ const char *udev_device_get_devpath(struct udev_device *udev_device)
  *
  * Returns: the sys path of the udev device
  **/
-const char *udev_device_get_syspath(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_syspath(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -840,7 +1138,7 @@ const char *udev_device_get_syspath(struct udev_device *udev_device)
  *
  * Returns: the sys name of the device device
  **/
-const char *udev_device_get_sysname(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_sysname(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -853,7 +1151,7 @@ const char *udev_device_get_sysname(struct udev_device *udev_device)
  *
  * Returns: the trailing number of of the device name
  **/
-const char *udev_device_get_sysnum(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_sysnum(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
@@ -869,13 +1167,13 @@ const char *udev_device_get_sysnum(struct udev_device *udev_device)
  *
  * Returns: the device node file name of the udev device, or #NULL if no device node exists
  **/
-const char *udev_device_get_devnode(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_devnode(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->info_loaded) {
 		udev_device_read_uevent_file(udev_device);
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	}
 
 	/* we might get called before we handled an event and have a db, use the kernel-provided name */
@@ -891,66 +1189,6 @@ const char *udev_device_get_devnode(struct udev_device *udev_device)
 	return udev_device->devnode;
 }
 
-/**
- * udev_device_get_subsystem:
- * @udev_device: udev device
- *
- * Retrieve the subsystem string of the udev device. The string does not
- * contain any "/".
- *
- * Returns: the subsystem name of the udev device, or #NULL if it can not be determined
- **/
-const char *udev_device_get_subsystem(struct udev_device *udev_device)
-{
-	char subsystem[UTIL_NAME_SIZE];
-
-	if (udev_device == NULL)
-		return NULL;
-	if (!udev_device->subsystem_set) {
-		udev_device->subsystem_set = true;
-		/* read "subsystem" link */
-		if (util_get_sys_subsystem(udev_device->udev, udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
-			udev_device_set_subsystem(udev_device, subsystem);
-			return udev_device->subsystem;
-		}
-		/* implicit names */
-		if (strncmp(udev_device->devpath, "/module/", 8) == 0) {
-			udev_device_set_subsystem(udev_device, "module");
-			return udev_device->subsystem;
-		}
-		if (strstr(udev_device->devpath, "/drivers/") != NULL) {
-			udev_device_set_subsystem(udev_device, "drivers");
-			return udev_device->subsystem;
-		}
-		if (strncmp(udev_device->devpath, "/subsystem/", 11) == 0 ||
-		    strncmp(udev_device->devpath, "/class/", 7) == 0 ||
-		    strncmp(udev_device->devpath, "/bus/", 5) == 0) {
-			udev_device_set_subsystem(udev_device, "subsystem");
-			return udev_device->subsystem;
-		}
-	}
-	return udev_device->subsystem;
-}
-
-/**
- * udev_device_get_devtype:
- * @udev_device: udev device
- *
- * Retrieve the devtype string of the udev device.
- *
- * Returns: the devtype name of the udev device, or #NULL if it can not be determined
- **/
-const char *udev_device_get_devtype(struct udev_device *udev_device)
-{
-	if (udev_device == NULL)
-		return NULL;
-	if (!udev_device->devtype_set) {
-		udev_device->devtype_set = true;
-		udev_device_read_uevent_file(udev_device);
-	}
-	return udev_device->devtype;
-}
-
 /**
  * udev_device_get_devlinks_list_entry:
  * @udev_device: udev device
@@ -964,19 +1202,19 @@ const char *udev_device_get_devtype(struct udev_device *udev_device)
  *
  * Returns: the first entry of the device node link list
  **/
-struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_list_entry *udev_device_get_devlinks_list_entry(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	return udev_list_get_entry(&udev_device->devlinks_list);
 }
 
 void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
 {
 	udev_device->devlinks_uptodate = false;
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->devlinks_list);
+	udev_list_cleanup(&udev_device->devlinks_list);
 }
 
 /**
@@ -991,13 +1229,13 @@ void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
  *
  * Returns: the first entry of the property list
  **/
-struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
 	if (!udev_device->info_loaded) {
 		udev_device_read_uevent_file(udev_device);
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	}
 	if (!udev_device->devlinks_uptodate) {
 		char symlinks[UTIL_PATH_SIZE];
@@ -1034,41 +1272,6 @@ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device
 	return udev_list_get_entry(&udev_device->properties_list);
 }
 
-/**
- * udev_device_get_driver:
- * @udev_device: udev device
- *
- * Returns: the driver string, or #NULL if there is no driver attached.
- **/
-const char *udev_device_get_driver(struct udev_device *udev_device)
-{
-	char driver[UTIL_NAME_SIZE];
-
-	if (udev_device == NULL)
-		return NULL;
-	if (!udev_device->driver_set) {
-		udev_device->driver_set = true;
-		if (util_get_sys_driver(udev_device->udev, udev_device->syspath, driver, sizeof(driver)) > 0)
-			udev_device->driver = strdup(driver);
-	}
-	return udev_device->driver;
-}
-
-/**
- * udev_device_get_devnum:
- * @udev_device: udev device
- *
- * Returns: the device major/minor number.
- **/
-dev_t udev_device_get_devnum(struct udev_device *udev_device)
-{
-	if (udev_device == NULL)
-		return makedev(0, 0);
-	if (!udev_device->info_loaded)
-		udev_device_read_uevent_file(udev_device);
-	return udev_device->devnum;
-}
-
 /**
  * udev_device_get_action:
  * @udev_device: udev device
@@ -1079,29 +1282,13 @@ dev_t udev_device_get_devnum(struct udev_device *udev_device)
  *
  * Returns: the kernel action value, or #NULL if there is no action value available.
  **/
-const char *udev_device_get_action(struct udev_device *udev_device)
+UDEV_EXPORT const char *udev_device_get_action(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
 	return udev_device->action;
 }
 
-/**
- * udev_device_get_devnum:
- * @udev_device: udev device
- *
- * This is only valid if the device was received through a monitor. Devices read from
- * sys do not have a sequence number.
- *
- * Returns: the kernel event sequence number, or 0 if there is no sequence number available.
- **/
-unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
-{
-	if (udev_device == NULL)
-		return 0;
-	return udev_device->seqnum;
-}
-
 /**
  * udev_device_get_usec_since_initialized:
  * @udev_device: udev device
@@ -1114,17 +1301,17 @@ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
  *
  * Returns: the number of microseconds since the device was first seen.
  **/
-unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
+UDEV_EXPORT unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
 {
 	unsigned long long now;
 
 	if (udev_device == NULL)
 		return 0;
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	if (udev_device->usec_initialized == 0)
 		return 0;
-	now = usec_monotonic();
+	now = now_usec();
 	if (now == 0)
 		return 0;
 	return now - udev_device->usec_initialized;
@@ -1137,7 +1324,11 @@ unsigned long long udev_device_get_usec_initialized(struct udev_device *udev_dev
 
 void udev_device_set_usec_initialized(struct udev_device *udev_device, unsigned long long usec_initialized)
 {
+	char num[32];
+
 	udev_device->usec_initialized = usec_initialized;
+	snprintf(num, sizeof(num), "%llu", usec_initialized);
+	udev_device_add_property(udev_device, "USEC_INITIALIZED", num);
 }
 
 /**
@@ -1150,7 +1341,7 @@ void udev_device_set_usec_initialized(struct udev_device *udev_device, unsigned
  *
  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
  **/
-const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const char *sysattr)
+UDEV_EXPORT 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];
@@ -1166,43 +1357,48 @@ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const
 		return NULL;
 
 	/* look for possibly already cached result */
-	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) {
-			dbg(udev_device->udev, "got '%s' (%s) from cache\n",
-			    sysattr, udev_list_entry_get_value(list_entry));
-			return udev_list_entry_get_value(list_entry);
-		}
+	list_entry = udev_list_get_entry(&udev_device->sysattr_value_list);
+	list_entry = udev_list_entry_get_by_name(list_entry, sysattr);
+	if (list_entry != NULL) {
+		dbg(udev_device->udev, "got '%s' (%s) from cache\n",
+		    sysattr, udev_list_entry_get_value(list_entry));
+		return udev_list_entry_get_value(list_entry);
 	}
 
 	util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
 	if (lstat(path, &statbuf) != 0) {
 		dbg(udev_device->udev, "no attribute '%s', keep negative entry\n", path);
-		udev_list_entry_add(udev_device->udev, &udev_device->sysattr_list, sysattr, NULL, 0, 0);
+		udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, NULL);
 		goto out;
 	}
 
 	if (S_ISLNK(statbuf.st_mode)) {
-		char target[UTIL_NAME_SIZE];
-		int len;
-		char *pos;
-
-		/* some core links return the last element of the target path */
-		if (strcmp(sysattr, "driver") != 0 &&
-		    strcmp(sysattr, "subsystem") != 0 &&
-		    strcmp(sysattr, "module") != 0)
-			goto out;
-
-		len = readlink(path, target, sizeof(target));
-		if (len <= 0 || len == sizeof(target))
+		struct udev_device *dev;
+
+		/*
+		 * Some core links return only the last element of the target path,
+		 * these are just values, the paths should not be exposed.
+		 */
+		if (strcmp(sysattr, "driver") == 0 ||
+		    strcmp(sysattr, "subsystem") == 0 ||
+		    strcmp(sysattr, "module") == 0) {
+			if (util_get_sys_core_link_value(udev_device->udev, sysattr,
+							 udev_device->syspath, value, sizeof(value)) < 0)
+				return NULL;
+			dbg(udev_device->udev, "cache '%s' with link value '%s'\n", sysattr, value);
+			list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
+			val = udev_list_entry_get_value(list_entry);
 			goto out;
-		target[len] = '\0';
+		}
 
-		pos = strrchr(target, '/');
-		if (pos != NULL) {
-			pos = &pos[1];
-			dbg(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);
+		/* resolve link to a device and return its syspath */
+		util_strscpyl(path, sizeof(path), udev_device->syspath, "/", sysattr, NULL);
+		dev = udev_device_new_from_syspath(udev_device->udev, path);
+		if (dev != NULL) {
+			list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr,
+							 udev_device_get_syspath(dev));
 			val = udev_list_entry_get_value(list_entry);
+			udev_device_unref(dev);
 		}
 
 		goto out;
@@ -1233,22 +1429,21 @@ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const
 	value[size] = '\0';
 	util_remove_trailing_chars(value, '\n');
 	dbg(udev_device->udev, "'%s' has attribute value '%s'\n", path, value);
-	list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_list, sysattr, value, 0, 0);
+	list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, value);
 	val = udev_list_entry_get_value(list_entry);
 out:
 	return val;
 }
 
-static int udev_device_cache_sysattrs(struct udev_device *udev_device)
+static int udev_device_sysattr_list_read(struct udev_device *udev_device)
 {
-	struct dirent *entry;
+	struct dirent *dent;
 	DIR *dir;
 	int num = 0;
 
 	if (udev_device == NULL)
 		return -1;
-	/* caching already done? */
-	if (udev_device->sysattrs_cached)
+	if (udev_device->sysattr_list_read)
 		return 0;
 
 	dir = opendir(udev_device_get_syspath(udev_device));
@@ -1258,37 +1453,27 @@ static int udev_device_cache_sysattrs(struct udev_device *udev_device)
 		return -1;
 	}
 
-	while (NULL != (entry = readdir(dir))) {
+	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
 		char path[UTIL_PATH_SIZE];
 		struct stat statbuf;
 
 		/* only handle symlinks and regular files */
-		if (DT_LNK != entry->d_type && DT_REG != entry->d_type)
+		if (dent->d_type != DT_LNK && dent->d_type != DT_REG)
 			continue;
 
-		util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device),
-				"/", entry->d_name, NULL);
-		if (0 != lstat(path, &statbuf))
+		util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", dent->d_name, NULL);
+		if (lstat(path, &statbuf) != 0)
 			continue;
-
-		if (0 == (statbuf.st_mode & S_IRUSR))
+		if ((statbuf.st_mode & S_IRUSR) == 0)
 			continue;
 
-		if (DT_LNK == entry->d_type) {
-			if (strcmp(entry->d_name, "driver") != 0 &&
-				strcmp(entry->d_name, "subsystem") != 0 &&
-				strcmp(entry->d_name, "module") != 0)
-				continue;
-		}
-		udev_list_entry_add(udev_device->udev,
-				&udev_device->available_sysattr_list, entry->d_name,
-				DT_LNK == entry->d_type ? "s" : "r", 0, 0);
-		++num;
+		udev_list_entry_add(&udev_device->sysattr_list, dent->d_name, NULL);
+		num++;
 	}
 
-	dbg(udev_device->udev, "found %d sysattrs for '%s'\n", num,
-			udev_device_get_syspath(udev_device));
-	udev_device->sysattrs_cached = true;
+	closedir(dir);
+	dbg(udev_device->udev, "found %d sysattrs for '%s'\n", num, udev_device_get_syspath(udev_device));
+	udev_device->sysattr_list_read = true;
 
 	return num;
 }
@@ -1298,22 +1483,21 @@ static int udev_device_cache_sysattrs(struct udev_device *udev_device)
  * @udev_device: udev device
  *
  * Retrieve the list of available sysattrs, with value being empty;
- * This is to be able to read all available sysfs attributes for a particular
- * device without the necessity to access sysfs from outside libudev.
+ * This just return all available sysfs attributes for a particular
+ * device without reading their values.
  *
  * Returns: the first entry of the property list
  **/
-struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_list_entry *udev_device_get_sysattr_list_entry(struct udev_device *udev_device)
 {
-	/* perform initial caching of sysattr list */
-	if (!udev_device->sysattrs_cached) {
+	if (!udev_device->sysattr_list_read) {
 		int ret;
-		ret = udev_device_cache_sysattrs(udev_device);
+		ret = udev_device_sysattr_list_read(udev_device);
 		if (0 > ret)
 			return NULL;
 	}
 
-	return udev_list_get_entry(&udev_device->available_sysattr_list);
+	return udev_list_get_entry(&udev_device->sysattr_list);
 }
 
 int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath)
@@ -1354,28 +1538,6 @@ int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath
 	return 0;
 }
 
-int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
-{
-	free(udev_device->subsystem);
-	udev_device->subsystem = strdup(subsystem);
-	if (udev_device->subsystem == NULL)
-		return -ENOMEM;
-	udev_device->subsystem_set = true;
-	udev_device_add_property(udev_device, "SUBSYSTEM", udev_device->subsystem);
-	return 0;
-}
-
-int udev_device_set_devtype(struct udev_device *udev_device, const char *devtype)
-{
-	free(udev_device->devtype);
-	udev_device->devtype = strdup(devtype);
-	if (udev_device->devtype == NULL)
-		return -ENOMEM;
-	udev_device->devtype_set = true;
-	udev_device_add_property(udev_device, "DEVTYPE", udev_device->devtype);
-	return 0;
-}
-
 int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
 {
 	free(udev_device->devnode);
@@ -1391,11 +1553,11 @@ int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink
 	struct udev_list_entry *list_entry;
 
 	udev_device->devlinks_uptodate = false;
-	list_entry = udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0);
+	list_entry = udev_list_entry_add(&udev_device->devlinks_list, devlink, NULL);
 	if (list_entry == NULL)
 		return -ENOMEM;
 	if (unique)
-		udev_list_entry_set_flags(list_entry, 1);
+		udev_list_entry_set_num(list_entry, true);
 	return 0;
 }
 
@@ -1446,10 +1608,10 @@ const char *udev_device_get_id_filename(struct udev_device *udev_device)
  *
  * Returns: 1 if the device is set up. 0 otherwise.
  **/
-int udev_device_get_is_initialized(struct udev_device *udev_device)
+UDEV_EXPORT int udev_device_get_is_initialized(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	return udev_device->is_initialized;
 }
 
@@ -1463,7 +1625,7 @@ int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
 	if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
 		return -EINVAL;
 	udev_device->tags_uptodate = false;
-	if (udev_list_entry_add(udev_device->udev, &udev_device->tags_list, tag, NULL, 1, 0) != NULL)
+	if (udev_list_entry_add(&udev_device->tags_list, tag, NULL) != NULL)
 		return 0;
 	return -ENOMEM;
 }
@@ -1471,7 +1633,7 @@ int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
 void udev_device_cleanup_tags_list(struct udev_device *udev_device)
 {
 	udev_device->tags_uptodate = false;
-	udev_list_cleanup_entries(udev_device->udev, &udev_device->tags_list);
+	udev_list_cleanup(&udev_device->tags_list);
 }
 
 /**
@@ -1485,24 +1647,27 @@ void udev_device_cleanup_tags_list(struct udev_device *udev_device)
  *
  * Returns: the first entry of the tag list
  **/
-struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
+UDEV_EXPORT struct udev_list_entry *udev_device_get_tags_list_entry(struct udev_device *udev_device)
 {
 	if (udev_device == NULL)
 		return NULL;
+	if (!udev_device->info_loaded)
+		udev_device_read_db(udev_device, NULL);
 	return udev_list_get_entry(&udev_device->tags_list);
 }
 
-int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
+UDEV_EXPORT int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
 {
 	struct udev_list_entry *list_entry;
 
+	if (udev_device == NULL)
+		return false;
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	list_entry = udev_device_get_tags_list_entry(udev_device);
-	list_entry =  udev_list_entry_get_by_name(list_entry, tag);
-	if (list_entry != NULL)
-		return 1;
-	return 0;
+	if (udev_list_entry_get_by_name(list_entry, tag) != NULL)
+		return true;
+	return false;
 }
 
 #define ENVP_SIZE			128
@@ -1586,128 +1751,10 @@ int udev_device_set_action(struct udev_device *udev_device, const char *action)
 	return 0;
 }
 
-int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
-{
-	free(udev_device->driver);
-	udev_device->driver = strdup(driver);
-	if (udev_device->driver == NULL)
-		return -ENOMEM;
-	udev_device->driver_set = true;
-	udev_device_add_property(udev_device, "DRIVER", udev_device->driver);
-	return 0;
-}
-
-const char *udev_device_get_devpath_old(struct udev_device *udev_device)
-{
-	return udev_device->devpath_old;
-}
-
-int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
-{
-	const char *pos;
-	size_t len;
-
-	free(udev_device->devpath_old);
-	udev_device->devpath_old = strdup(devpath_old);
-	if (udev_device->devpath_old == NULL)
-		return -ENOMEM;
-	udev_device_add_property(udev_device, "DEVPATH_OLD", udev_device->devpath_old);
-
-	pos = strrchr(udev_device->devpath_old, '/');
-	if (pos == NULL)
-		return -EINVAL;
-	udev_device->sysname_old = strdup(&pos[1]);
-	if (udev_device->sysname_old == NULL)
-		return -ENOMEM;
-
-	/* some devices have '!' in their name, change that to '/' */
-	len = 0;
-	while (udev_device->sysname_old[len] != '\0') {
-		if (udev_device->sysname_old[len] == '!')
-			udev_device->sysname_old[len] = '/';
-		len++;
-	}
-	return 0;
-}
-
-const char *udev_device_get_sysname_old(struct udev_device *udev_device)
-{
-	if (udev_device == NULL)
-		return NULL;
-	return udev_device->sysname_old;
-}
-
-const char *udev_device_get_knodename(struct udev_device *udev_device)
-{
-	return udev_device->knodename;
-}
-
-int udev_device_set_knodename(struct udev_device *udev_device, const char *knodename)
-{
-	free(udev_device->knodename);
-	udev_device->knodename = strdup(knodename);
-	if (udev_device->knodename == NULL)
-		return -ENOMEM;
-	/* do not overwrite the udev property with the kernel property */
-	if (udev_device->devnode == NULL)
-		udev_device_add_property(udev_device, "DEVNAME", udev_device->knodename);
-	return 0;
-}
-
-int udev_device_get_timeout(struct udev_device *udev_device)
-{
-	return udev_device->timeout;
-}
-
-int udev_device_set_timeout(struct udev_device *udev_device, int timeout)
-{
-	udev_device->timeout = timeout;
-	return 0;
-}
-int udev_device_get_event_timeout(struct udev_device *udev_device)
-{
-	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
-	return udev_device->event_timeout;
-}
-
-int udev_device_set_event_timeout(struct udev_device *udev_device, int event_timeout)
-{
-	char num[32];
-
-	udev_device->event_timeout = event_timeout;
-	snprintf(num, sizeof(num), "%u", event_timeout);
-	udev_device_add_property(udev_device, "TIMEOUT", num);
-	return 0;
-}
-
-int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
-{
-	char num[32];
-
-	udev_device->seqnum = seqnum;
-	snprintf(num, sizeof(num), "%llu", seqnum);
-	udev_device_add_property(udev_device, "SEQNUM", num);
-	return 0;
-}
-
-int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
-{
-	char num[32];
-
-	udev_device->devnum = devnum;
-
-	snprintf(num, sizeof(num), "%u", major(devnum));
-	udev_device_add_property(udev_device, "MAJOR", num);
-	snprintf(num, sizeof(num), "%u", minor(devnum));
-	udev_device_add_property(udev_device, "MINOR", num);
-	return 0;
-}
-
 int udev_device_get_devlink_priority(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	return udev_device->devlink_priority;
 }
 
@@ -1720,7 +1767,7 @@ int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
 int udev_device_get_watch_handle(struct udev_device *udev_device)
 {
 	if (!udev_device->info_loaded)
-		udev_device_read_db(udev_device);
+		udev_device_read_db(udev_device, NULL);
 	return udev_device->watch_handle;
 }
 
@@ -1730,19 +1777,12 @@ int udev_device_set_watch_handle(struct udev_device *udev_device, int handle)
 	return 0;
 }
 
-int udev_device_get_ifindex(struct udev_device *udev_device)
+bool udev_device_get_db_persist(struct udev_device *udev_device)
 {
-	if (!udev_device->info_loaded)
-		udev_device_read_uevent_file(udev_device);
-	return udev_device->ifindex;
+	return udev_device->db_persist;
 }
 
-int udev_device_set_ifindex(struct udev_device *udev_device, int ifindex)
+void udev_device_set_db_persist(struct udev_device *udev_device)
 {
-	char num[32];
-
-	udev_device->ifindex = ifindex;
-	snprintf(num, sizeof(num), "%u", ifindex);
-	udev_device_add_property(udev_device, "IFINDEX", num);
-	return 0;
+	udev_device->db_persist = true;
 }