X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev_sysfs.c;h=0e448894fef8f3c6edee1a0cd49cdd631f4d2893;hp=d46f1f26d85bf94fc55eab0a425ba2f164aac15d;hb=82c60ce57206148d00e8d3a210a72a0e7f2aa380;hpb=4be25ce1d0e1cef62120a5605f8472761a26689e

diff --git a/udev_sysfs.c b/udev_sysfs.c
index d46f1f26d..0e448894f 100644
--- a/udev_sysfs.c
+++ b/udev_sysfs.c
@@ -1,8 +1,5 @@
 /*
- * udev_sysfs.c  - sysfs linux kernel specific knowledge
- *
- * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
- * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2005-2006 Kay Sievers <kay.sievers@vrfy.org>
  *
  *	This program is free software; you can redistribute it and/or modify it
  *	under the terms of the GNU General Public License as published by the
@@ -15,452 +12,412 @@
  * 
  *	You should have received a copy of the GNU General Public License along
  *	with this program; if not, write to the Free Software Foundation, Inc.,
- *	675 Mass Ave, Cambridge, MA 02139, USA.
+ *	51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
  */
 
+
+#include <stdlib.h>
 #include <stdio.h>
 #include <stddef.h>
-#include <stdlib.h>
 #include <unistd.h>
-#include <string.h>
+#include <fcntl.h>
 #include <ctype.h>
 #include <errno.h>
 #include <sys/stat.h>
 
-#include "libsysfs/sysfs/libsysfs.h"
-#include "udev_version.h"
-#include "udev_sysfs.h"
-#include "udev_utils.h"
-#include "logging.h"
-
-/* list of subsystem specific files, NULL if there is no file to wait for */
-static const struct subsystem_file {
-	const char *subsystem;
-	const char *file;
-} subsystem_files[] = {
-	{ .subsystem = "class",		.file = NULL },
-	{ .subsystem = "net",		.file = "ifindex" },
-	{ .subsystem = "scsi_host",	.file = "unique_id" },
-	{ .subsystem = "scsi_device",	.file = NULL },
-	{ .subsystem = "pcmcia_socket",	.file = "card_type" },
-	{ .subsystem = "usb_host",	.file = NULL },
-	{ .subsystem = "bluetooth",	.file = "address" },
-	{ .subsystem = "firmware",	.file = "data" },
-	{ .subsystem = "i2c-adapter",	.file = NULL },
-	{ .subsystem = "pci_bus",	.file = NULL },
-	{ .subsystem = "ieee1394",	.file = NULL },
-	{ .subsystem = "ieee1394_host",	.file = NULL },
-	{ .subsystem = "ieee1394_node",	.file = NULL },
-	{ .subsystem = "fc_transport",	.file = "port_id" },
-	{ .subsystem = "fc_host",	.file = "port_id" },
-	{ .subsystem = "spi_transport",	.file = "width" },
-	{ .subsystem = "spi_host",	.file = "width" },
-	{ NULL, NULL }
-};
+#include "udev.h"
 
-int subsystem_expect_no_dev(const char *subsystem)
-{
-	const struct subsystem_file *file;
+char sysfs_path[PATH_SIZE];
 
-	for (file = subsystem_files; file->subsystem != NULL; file++)
-		if (strcmp(subsystem, file->subsystem) == 0)
-			return 1;
+/* device cache */
+static LIST_HEAD(dev_list);
 
-	return 0;
-}
+/* attribute value cache */
+static LIST_HEAD(attr_list);
+struct sysfs_attr {
+	struct list_head node;
+	char path[PATH_SIZE];
+	char *value;			/* points to value_local if value is cached */
+	char value_local[NAME_SIZE];
+};
 
-/* get subsystem specific files, returns "dev" if no other found */
-static const char *get_subsystem_specific_file(const char *subsystem)
+int sysfs_init(void)
 {
-	const struct subsystem_file *file;
-
-	/* look if we want to look for another file instead of "dev" */
-	for (file = subsystem_files; file->subsystem != NULL; file++)
-		if (strcmp(subsystem, file->subsystem) == 0)
-			return file->file;
-
-	return "dev";
+	const char *env;
+
+	env = getenv("SYSFS_PATH");
+	if (env) {
+		strlcpy(sysfs_path, env, sizeof(sysfs_path));
+		remove_trailing_chars(sysfs_path, '/');
+	} else
+		strlcpy(sysfs_path, "/sys", sizeof(sysfs_path));
+	dbg("sysfs_path='%s'", sysfs_path);
+
+	INIT_LIST_HEAD(&dev_list);
+	INIT_LIST_HEAD(&attr_list);
+	return 0;
 }
 
-/* wait for class pecific file to show up */
-static int wait_for_class_device_attributes(struct sysfs_class_device *class_dev,
-					    const char **error)
+void sysfs_cleanup(void)
 {
-	const char *file;
-	char filename[SYSFS_PATH_MAX];
-	int loop;
-
-	file = get_subsystem_specific_file(class_dev->classname);
-	if (file == NULL) {
-		dbg("class '%s' has no file to wait for", class_dev->classname);
-		return 0;
+	struct sysfs_attr *attr_loop;
+	struct sysfs_attr *attr_temp;
+	struct sysfs_device *dev_loop;
+	struct sysfs_device *dev_temp;
+
+	list_for_each_entry_safe(attr_loop, attr_temp, &attr_list, node) {
+		list_del(&attr_loop->node);
+		free(attr_loop);
 	}
 
-	snprintf(filename, SYSFS_PATH_MAX-1, "%s/%s", class_dev->path, file);
-	dbg("looking at class '%s' for specific file '%s'", class_dev->classname, filename);
-
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		struct stat stats;
-
-		if (stat(class_dev->path, &stats) == -1) {
-			dbg("'%s' now disappeared (probably remove has beaten us)", class_dev->path);
-			return -ENODEV;
-		}
-
-		if (stat(filename, &stats) == 0) {
-			dbg("class '%s' specific file '%s' found", class_dev->classname, file);
-			return 0;
-		}
+	list_for_each_entry_safe(dev_loop, dev_temp, &dev_list, node) {
+		list_del(&dev_loop->node);
+		free(dev_loop);
+	}
+}
 
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+void sysfs_device_set_values(struct sysfs_device *dev, const char *devpath,
+			     const char *subsystem, const char *driver)
+{
+	char *pos;
+
+	strlcpy(dev->devpath, devpath, sizeof(dev->devpath));
+	if (subsystem != NULL)
+		strlcpy(dev->subsystem, subsystem, sizeof(dev->subsystem));
+	if (driver != NULL)
+		strlcpy(dev->driver, driver, sizeof(dev->driver));
+
+	/* set kernel name */
+	pos = strrchr(dev->devpath, '/');
+	if (pos == NULL)
+		return;
+
+	strlcpy(dev->kernel, &pos[1], sizeof(dev->kernel));
+	dbg("kernel='%s'", dev->kernel);
+
+	/* some devices have '!' in their name, change that to '/' */
+	pos = dev->kernel;
+	while (pos[0] != '\0') {
+		if (pos[0] == '!')
+			pos[0] = '/';
+		pos++;
 	}
 
-	dbg("error: getting class '%s' specific file '%s'", class_dev->classname, file);
-	if (error)
-		*error = "class specific file unavailable";
-	return -ENOENT;
+	/* get kernel number */
+	pos = &dev->kernel[strlen(dev->kernel)];
+	while (isdigit(pos[-1]))
+		pos--;
+	strlcpy(dev->kernel_number, pos, sizeof(dev->kernel_number));
+	dbg("kernel_number='%s'", dev->kernel_number);
 }
 
-/* check if we need to wait for a physical device */
-static int class_device_expect_no_device_link(struct sysfs_class_device *class_dev)
+int sysfs_resolve_link(char *devpath, size_t size)
 {
-	/* list of devices without a "device" symlink to the physical device
-	 * if device is set to NULL, no devices in that subsystem has a link */
-	static const struct class_device {
-		const char *subsystem;
-		const char *device;
-	} class_device[] = {
-		{ .subsystem = "block",		.device = "double" },
-		{ .subsystem = "block",		.device = "nb" },
-		{ .subsystem = "block",		.device = "ram" },
-		{ .subsystem = "block",		.device = "loop" },
-		{ .subsystem = "block",		.device = "fd" },
-		{ .subsystem = "block",		.device = "md" },
-		{ .subsystem = "block",		.device = "dos_cd" },
-		{ .subsystem = "block",		.device = "rflash" },
-		{ .subsystem = "block",		.device = "rom" },
-		{ .subsystem = "block",		.device = "rrom" },
-		{ .subsystem = "block",		.device = "flash" },
-		{ .subsystem = "block",		.device = "msd" },
-		{ .subsystem = "block",		.device = "sbpcd" },
-		{ .subsystem = "block",		.device = "pcd" },
-		{ .subsystem = "block",		.device = "pf" },
-		{ .subsystem = "block",		.device = "scd" },
-		{ .subsystem = "block",		.device = "ubd" },
-		{ .subsystem = "block",		.device = "dm-" },
-		{ .subsystem = "block",		.device = "bcrypt" },
-		{ .subsystem = "input",		.device = "event" },
-		{ .subsystem = "input",		.device = "mice" },
-		{ .subsystem = "input",		.device = "mouse" },
-		{ .subsystem = "input",		.device = "ts" },
-		{ .subsystem = "vc",		.device = NULL },
-		{ .subsystem = "tty",		.device = NULL },
-		{ .subsystem = "cpuid",		.device = "cpu" },
-		{ .subsystem = "graphics",	.device = "fb" },
-		{ .subsystem = "mem",		.device = NULL },
-		{ .subsystem = "misc",		.device = NULL },
-		{ .subsystem = "msr",		.device = NULL },
-		{ .subsystem = "netlink",	.device = NULL },
-		{ .subsystem = "net",		.device = "sit" },
-		{ .subsystem = "net",		.device = "lo" },
-		{ .subsystem = "net",		.device = "tap" },
-		{ .subsystem = "net",		.device = "ipsec" },
-		{ .subsystem = "net",		.device = "dummy" },
-		{ .subsystem = "net",		.device = "irda" },
-		{ .subsystem = "net",		.device = "ppp" },
-		{ .subsystem = "net",		.device = "tun" },
-		{ .subsystem = "net",		.device = "pan" },
-		{ .subsystem = "net",		.device = "bnep" },
-		{ .subsystem = "net",		.device = "vmnet" },
-		{ .subsystem = "net",		.device = "ippp" },
-		{ .subsystem = "net",		.device = "nlv" },
-		{ .subsystem = "net",		.device = "atml" },
-		{ .subsystem = "ppp",		.device = NULL },
-		{ .subsystem = "sound",		.device = NULL },
-		{ .subsystem = "printer",	.device = "lp" },
-		{ .subsystem = "ppdev",		.device = NULL },
-		{ .subsystem = "nvidia",	.device = NULL },
-		{ .subsystem = "video4linux",	.device = "vbi" },
-		{ .subsystem = "dvb",		.device = NULL },
-		{ .subsystem = "lirc",		.device = NULL },
-		{ .subsystem = "firmware",	.device = NULL },
-		{ .subsystem = "drm",		.device = NULL },
-		{ .subsystem = "pci_bus",	.device = NULL },
-		{ .subsystem = "ieee1394",	.device = NULL },
-		{ .subsystem = "ieee1394_host",	.device = NULL },
-		{ .subsystem = "ieee1394_node",	.device = NULL },
-		{ .subsystem = "raw",		.device = NULL },
-		{ .subsystem = "zaptel",	.device = NULL },
-		{ .subsystem = "tiglusb",	.device = NULL },
-		{ .subsystem = "ppdev",		.device = NULL },
-		{ .subsystem = "ticables",	.device = NULL },
-		{ .subsystem = "snsc",		.device = NULL },
-		{ .subsystem = "staliomem",	.device = NULL },
-		{ .subsystem = "tape",		.device = NULL },
-		{ .subsystem = "ip2",		.device = NULL },
-		{ .subsystem = "tpqic02",	.device = NULL },
-		{ .subsystem = "dsp56k",	.device = NULL },
-		{ .subsystem = "zft",		.device = NULL },
-		{ .subsystem = "adb",		.device = NULL },
-		{ .subsystem = "cosa",		.device = NULL },
-		{ .subsystem = "pg",		.device = NULL },
-		{ .subsystem = "pt",		.device = NULL },
-		{ .subsystem = "capi",		.device = NULL },
-		{ NULL, NULL }
-	};
-	const struct class_device *classdevice;
+	char link_path[PATH_SIZE];
+	char link_target[PATH_SIZE];
 	int len;
+	int i;
+	int back;
 
-	/* the kernel may tell us what to wait for */
-	if (kernel_release_satisfactory(2,6,10) > 0)
-		if (getenv("PHYSDEVPATH") == NULL) {
-			dbg("the kernel says, that there is no physical device for '%s'", class_dev->path);
-			return 1;
-		}
-
-	for (classdevice = class_device; classdevice->subsystem != NULL; classdevice++) {
-		if (strcmp(class_dev->classname, classdevice->subsystem) == 0) {
-			/* see if no device in this class is expected to have a device-link */
-			if (classdevice->device == NULL)
-				return 1;
-
-			len = strlen(classdevice->device);
-
-			/* see if device name matches */
-			if (strncmp(class_dev->name, classdevice->device, len) != 0)
-				continue;
+	strlcpy(link_path, sysfs_path, sizeof(link_path));
+	strlcat(link_path, devpath, sizeof(link_path));
+	len = readlink(link_path, link_target, sizeof(link_target));
+	if (len <= 0)
+		return -1;
+	link_target[len] = '\0';
+	dbg("path link '%s' points to '%s'", devpath, link_target);
 
-			/* exact name match */
-			if (strlen(class_dev->name) == len)
-				return 1;
+	for (back = 0; strncmp(&link_target[back * 3], "../", 3) == 0; back++)
+		;
+	dbg("base '%s', tail '%s', back %i", devpath, &link_target[back * 3], back);
+	for (i = 0; i <= back; i++) {
+		char *pos = strrchr(devpath, '/');
 
-			/* name match with instance number */
-			if (isdigit(class_dev->name[len]))
-				return 1;
-		}
+		if (pos == NULL)
+			return -1;
+		pos[0] = '\0';
 	}
-
+	dbg("after moving back '%s'", devpath);
+	strlcat(devpath, "/", size);
+	strlcat(devpath, &link_target[back * 3], size);
 	return 0;
 }
 
-/* skip waiting for the bus of the devices device */
-static int class_device_expect_no_bus(struct sysfs_class_device *class_dev)
+struct sysfs_device *sysfs_device_get(const char *devpath)
 {
-	static const char *devices_without_bus[] = {
-		"scsi_host",
-		"i2c-adapter",
-		"i2c-dev",
-		NULL
-	};
-	const char **device;
-
-	for (device = devices_without_bus; *device != NULL; device++) {
-		int len = strlen(*device);
-
-		if (strncmp(class_dev->classname, *device, len) == 0)
-			return 1;
-	}
+	char path[PATH_SIZE];
+	char devpath_real[PATH_SIZE];
+	struct sysfs_device *dev;
+	struct sysfs_device *dev_loop;
+	struct stat statbuf;
+	char link_path[PATH_SIZE];
+	char link_target[PATH_SIZE];
+	int len;
+	char *pos;
 
-	return 0;
-}
+	dbg("open '%s'", devpath);
+	strlcpy(devpath_real, devpath, sizeof(devpath_real));
+	remove_trailing_chars(devpath_real, '/');
 
-/* wait for a devices device specific file to show up */
-int wait_for_devices_device(struct sysfs_device *devices_dev,
-			const char **error)
-{
-	static const struct device_file {
-		const char *bus;
-		const char *file;
-	} device_files[] = {
-		{ .bus = "scsi",	.file = "vendor" },
-		{ .bus = "usb",		.file = "idVendor" },
-		{ .bus = "usb",		.file = "iInterface" },
-		{ .bus = "usb",		.file = "bNumEndpoints" },
-		{ .bus = "usb-serial",	.file = "detach_state" },
-		{ .bus = "ide",		.file = "detach_state" },
-		{ .bus = "pci",		.file = "vendor" },
-		{ .bus = "platform",	.file = "detach_state" },
-		{ .bus = "pcmcia",	.file = "detach_state" },
-		{ .bus = "i2c",		.file = "detach_state" },
-		{ .bus = "ieee1394",	.file = "node_count" },
-		{ .bus = "ieee1394",	.file = "nodeid" },
-		{ .bus = "ieee1394",	.file = "address" },
-		{ .bus = "bttv-sub",	.file = NULL },
-		{ .bus = "pnp",		.file = "detach_state" },
-		{ .bus = "eisa",	.file = "detach_state" },
-		{ .bus = "pseudo",	.file = "detach_state" },
-		{ .bus = "mmc",		.file = "detach_state" },
-		{ .bus = "macio",	.file = "detach_state" },
-		{ .bus = "of_platform",	.file = "detach_state" },
-		{ .bus = "vio",		.file = "detach_state" },
-		{ .bus = "ecard",	.file = "detach_state" },
-		{ .bus = "sa1111-rab",	.file = "detach_state" },
-		{ .bus = "amba",	.file = "detach_state" },
-		{ .bus = "locomo-bus",	.file = "detach_state" },
-		{ .bus = "logicmodule",	.file = "detach_state" },
-		{ .bus = "parisc",	.file = "detach_state" },
-		{ .bus = "ocp",		.file = "detach_state" },
-		{ .bus = "dio",		.file = "detach_state" },
-		{ .bus = "MCA",		.file = "detach_state" },
-		{ .bus = "wl",		.file = "detach_state" },
-		{ .bus = "ccwgroup",	.file = "detach_state" },
-		{ .bus = "css",		.file = "detach_state" },
-		{ .bus = "ccw",		.file = "detach_state" },
-		{ .bus = "iucv",	.file = "detach_state" },
-		{ NULL, NULL }
-	};
-	const struct device_file *devicefile;
-	int loop;
-
-	/* the kernel may tell us what to wait for */
-	if (kernel_release_satisfactory(2,6,10) > 0)
-		if (getenv("PHYSDEVBUS") == NULL) {
-			dbg("the kernel says, that there is no bus for '%s'", devices_dev->path);
-			return 0;
+	/* look for device already in cache (we never put an untranslated path in the cache) */
+	list_for_each_entry(dev_loop, &dev_list, node) {
+		if (strcmp(dev_loop->devpath, devpath_real) == 0) {
+			dbg("found in cache '%s'", dev_loop->devpath);
+			return dev_loop;
 		}
+	}
 
-	/* wait for the bus device link to the devices device */
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		if (sysfs_get_device_bus(devices_dev) == 0)
-			break;
-
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+	/* if we got a link, resolve it to the real device */
+	strlcpy(path, sysfs_path, sizeof(path));
+	strlcat(path, devpath_real, sizeof(path));
+	if (lstat(path, &statbuf) != 0) {
+		dbg("stat '%s' failed: %s", path, strerror(errno));
+		return NULL;
 	}
-	if (loop == 0) {
-		dbg("error: getting bus device link");
-		if (error)
-			*error = "no bus device link";
-		return -1;
+	if (S_ISLNK(statbuf.st_mode)) {
+		if (sysfs_resolve_link(devpath_real, sizeof(devpath_real)) != 0)
+			return NULL;
+
+		/* now look for device in cache after path translation */
+		list_for_each_entry(dev_loop, &dev_list, node) {
+			if (strcmp(dev_loop->devpath, devpath_real) == 0) {
+				dbg("found in cache '%s'", dev_loop->devpath);
+				return dev_loop;
+			}
+		}
 	}
-	dbg("bus device link found for bus '%s'", devices_dev->bus);
-
-	/* wait for a bus device specific file to show up */
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		int found_bus_type = 0;
-
-		for (devicefile = device_files; devicefile->bus != NULL; devicefile++) {
-			if (strcmp(devices_dev->bus, devicefile->bus) == 0) {
-				char filename[SYSFS_PATH_MAX];
-				struct stat stats;
-
-				if (devicefile->file == NULL) {
-					dbg("bus '%s' has no file to wait for", devices_dev->bus);
-					return 0;
-				}
-
-				found_bus_type = 1;
-				snprintf(filename, SYSFS_PATH_MAX-1, "%s/%s", devices_dev->path, devicefile->file);
-				dbg("looking at bus '%s' device for specific file '%s'", devices_dev->bus, filename);
-
-				if (stat(filename, &stats) == 0) {
-					dbg("bus '%s' device specific file '%s' found", devices_dev->bus, devicefile->file);
-					return 0;
-				}
+
+	/* it is a new device */
+	dbg("new uncached device '%s'", devpath_real);
+	dev = malloc(sizeof(struct sysfs_device));
+	if (dev == NULL)
+		return NULL;
+	memset(dev, 0x00, sizeof(struct sysfs_device));
+
+	sysfs_device_set_values(dev, devpath_real, NULL, NULL);
+
+	/* get subsystem */
+	if (strncmp(dev->devpath, "/class/", 7) == 0) {
+		strlcpy(dev->subsystem, &dev->devpath[7], sizeof(dev->subsystem));
+		pos = strchr(dev->subsystem, '/');
+		if (pos != NULL)
+			pos[0] = '\0';
+		else
+			dev->subsystem[0] = '\0';
+	} else if (strncmp(dev->devpath, "/block/", 7) == 0) {
+		strlcpy(dev->subsystem, "block", sizeof(dev->subsystem));
+	} else if (strncmp(dev->devpath, "/devices/", 9) == 0) {
+		/* get subsystem from "bus" link */
+		strlcpy(link_path, sysfs_path, sizeof(link_path));
+		strlcat(link_path, dev->devpath, sizeof(link_path));
+		strlcat(link_path, "/bus", sizeof(link_path));
+		len = readlink(link_path, link_target, sizeof(link_target));
+		if (len > 0) {
+			link_target[len] = '\0';
+			dbg("bus link '%s' points to '%s'", link_path, link_target);
+			pos = strrchr(link_target, '/');
+			if (pos != NULL)
+				strlcpy(dev->subsystem, &pos[1], sizeof(dev->subsystem));
+		} else {
+			/* get subsystem from "subsystem" link */
+			strlcpy(link_path, sysfs_path, sizeof(link_path));
+			strlcat(link_path, dev->devpath, sizeof(link_path));
+			strlcat(link_path, "/subsystem", sizeof(link_path));
+			len = readlink(link_path, link_target, sizeof(link_target));
+			if (len > 0) {
+				link_target[len] = '\0';
+				dbg("subsystem link '%s' points to '%s'", link_path, link_target);
+				pos = strrchr(link_target, '/');
+				if (pos != NULL)
+					strlcpy(dev->subsystem, &pos[1], sizeof(dev->subsystem));
 			}
 		}
-		if (found_bus_type == 0) {
-			if (error)
-				*error = "unknown bus";
-			info("error: unknown bus, please report to "
-			     "<linux-hotplug-devel@lists.sourceforge.net> '%s'", devices_dev->bus);
-			return -1;
+		/* get driver name */
+		strlcpy(link_path, sysfs_path, sizeof(link_path));
+		strlcat(link_path, dev->devpath, sizeof(link_path));
+		strlcat(link_path, "/driver", sizeof(link_path));
+		len = readlink(link_path, link_target, sizeof(link_target));
+		if (len > 0) {
+			link_target[len] = '\0';
+			dbg("driver link '%s' points to '%s'", link_path, link_target);
+			pos = strrchr(link_target, '/');
+			if (pos != NULL)
+				strlcpy(dev->driver, &pos[1], sizeof(dev->driver));
 		}
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+	} else if (strncmp(dev->devpath, "/bus/", 5) == 0 && strstr(dev->devpath, "/drivers/")) {
+		strlcpy(dev->subsystem, "drivers", sizeof(dev->subsystem));
+	} else if (strncmp(dev->devpath, "/module/", 8) == 0) {
+		strlcpy(dev->subsystem, "module", sizeof(dev->subsystem));
 	}
 
-	dbg("error: getting '%s' device specific file '%s'", devices_dev->bus, devicefile->file);
-	if (error)
-		*error = "bus device specific file unavailable";
-	return -1;
-}
+	dbg("add to cache 'devpath=%s', subsystem='%s', driver='%s'", dev->devpath, dev->subsystem, dev->driver);
+	list_add(&dev->node, &dev_list);
 
+	return dev;
+}
 
-struct sysfs_class_device *wait_class_device_open(const char *path)
+struct sysfs_device *sysfs_device_get_parent(struct sysfs_device *dev)
 {
-	struct sysfs_class_device *class_dev;
-	int loop;
-
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		class_dev = sysfs_open_class_device_path(path);
-		if (class_dev)
-			break;
-
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+	char parent_devpath[PATH_SIZE];
+	char *pos;
+
+	dbg("open '%s'", dev->devpath);
+
+	/* look if we already know the parent */
+	if (dev->parent != NULL)
+		return dev->parent;
+
+	/* requesting a parent is only valid for devices */
+	if ((strncmp(dev->devpath, "/devices/", 9) != 0) &&
+	    (strncmp(dev->devpath, "/class/", 7) != 0) &&
+	    (strncmp(dev->devpath, "/block/", 7) != 0))
+		return NULL;
+
+	strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
+	dbg("'%s'", parent_devpath);
+
+	/* strip last element */
+	pos = strrchr(parent_devpath, '/');
+	if (pos == NULL || pos == parent_devpath)
+		return NULL;
+	pos[0] = '\0';
+
+	/* are we at the top level of /devices */
+	if (strcmp(parent_devpath, "/devices") == 0) {
+		dbg("/devices top level");
+		return NULL;
 	}
 
-	return (class_dev);
+	/* at the top level of class/block we want to follow the "device" link */
+	if (strcmp(parent_devpath, "/block") == 0) {
+		dbg("/block top level, look for device link");
+		goto device_link;
+	}
+	if (strncmp(parent_devpath, "/class", 6) == 0) {
+		pos = strrchr(parent_devpath, '/');
+		if (pos == &parent_devpath[6] || pos == parent_devpath) {
+			dbg("/class top level, look for device link");
+			goto device_link;
+		}
+	}
+	/* get parent and remember it */
+	dev->parent = sysfs_device_get(parent_devpath);
+	return dev->parent;
+
+device_link:
+	strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
+	strlcat(parent_devpath, "/device", sizeof(parent_devpath));
+	if (sysfs_resolve_link(parent_devpath, sizeof(parent_devpath)) != 0)
+		return NULL;
+
+	/* get parent and remember it */
+	dev->parent = sysfs_device_get(parent_devpath);
+	return dev->parent;
 }
 
-int wait_for_class_device(struct sysfs_class_device *class_dev,
-			  const char **error)
+struct sysfs_device *sysfs_device_get_parent_with_subsystem(struct sysfs_device *dev, const char *subsystem)
 {
-	struct sysfs_class_device *class_dev_parent;
-	struct sysfs_device *devices_dev = NULL;
-	int loop;
-
-	if (wait_for_class_device_attributes(class_dev, error) != 0)
-		return -ENOENT;
+	struct sysfs_device *dev_parent;
 
-	/* skip devices without devices-link */
-	if (class_device_expect_no_device_link(class_dev)) {
-		dbg("no device symlink expected for '%s', ", class_dev->name);
-		return 0;
+	dev_parent = sysfs_device_get_parent(dev);
+	while (dev_parent != NULL) {
+		if (strcmp(dev_parent->subsystem, subsystem) == 0)
+			return dev_parent;
+		dev_parent = sysfs_device_get_parent(dev_parent);
 	}
+	return NULL;
+}
 
-	/* the symlink may be on the parent device */
-	class_dev_parent = sysfs_get_classdev_parent(class_dev);
-	if (class_dev_parent)
-		dbg("looking at parent device for device link '%s'", class_dev_parent->path);
-
-	/* wait for the symlink to the devices device */
-	dbg("waiting for symlink to devices device");
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		if (class_dev_parent)
-			devices_dev = sysfs_get_classdev_device(class_dev_parent);
-		else
-			devices_dev = sysfs_get_classdev_device(class_dev);
-
-		if (devices_dev)
-			break;
-
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
-	}
-	if (!devices_dev) {
-		dbg(" error: no devices device symlink found");
-		if (error)
-			*error = "no device symlink";
-		return -ENODEV;
+char *sysfs_attr_get_value(const char *devpath, const char *attr_name)
+{
+	char path_full[PATH_SIZE];
+	const char *path;
+	char value[NAME_SIZE];
+	struct sysfs_attr *attr_loop;
+	struct sysfs_attr *attr;
+	struct stat statbuf;
+	int fd;
+	ssize_t size;
+	size_t sysfs_len;
+
+	dbg("open '%s'/'%s'", devpath, attr_name);
+	sysfs_len = strlcpy(path_full, sysfs_path, sizeof(path_full));
+	path = &path_full[sysfs_len];
+	strlcat(path_full, devpath, sizeof(path_full));
+	strlcat(path_full, "/", sizeof(path_full));
+	strlcat(path_full, attr_name, sizeof(path_full));
+
+	/* look for attribute in cache */
+	list_for_each_entry(attr_loop, &attr_list, node) {
+		if (strcmp(attr_loop->path, path) == 0) {
+			dbg("found in cache '%s'", attr_loop->path);
+			return attr_loop->value;
+		}
 	}
-	dbg("device symlink found pointing to '%s'", devices_dev->path);
 
-	/* wait for the devices device */
-	if (class_device_expect_no_bus(class_dev)) {
-		dbg("no bus device expected for '%s', ", class_dev->classname);
-		return 0;
+	/* store attribute in cache (also negatives are kept in cache) */
+	dbg("new uncached attribute '%s'", path_full);
+	attr = malloc(sizeof(struct sysfs_attr));
+	if (attr == NULL)
+		return NULL;
+	memset(attr, 0x00, sizeof(struct sysfs_attr));
+	strlcpy(attr->path, path, sizeof(attr->path));
+	dbg("add to cache '%s'", path_full);
+	list_add(&attr->node, &attr_list);
+
+	if (lstat(path_full, &statbuf) != 0) {
+		dbg("stat '%s' failed: %s", path_full, strerror(errno));
+		goto out;
 	}
 
-	return wait_for_devices_device(devices_dev, error);
-}
+	if (S_ISLNK(statbuf.st_mode)) {
+		/* links return the last element of the target path */
+		char link_target[PATH_SIZE];
+		int len;
+		const char *pos;
+
+		len = readlink(path_full, link_target, sizeof(link_target));
+		if (len > 0) {
+			link_target[len] = '\0';
+			pos = strrchr(link_target, '/');
+			if (pos != NULL) {
+				dbg("cache '%s' with link value '%s'", path_full, value);
+				strlcpy(attr->value_local, &pos[1], sizeof(attr->value_local));
+				attr->value = attr->value_local;
+			}
+		}
+		goto out;
+	}
 
-struct sysfs_device *wait_devices_device_open(const char *path)
-{
-	struct sysfs_device *devices_dev;
-	int loop;
+	/* skip directories */
+	if (S_ISDIR(statbuf.st_mode))
+		goto out;
 
-	loop = WAIT_MAX_SECONDS * WAIT_LOOP_PER_SECOND;
-	while (--loop) {
-		devices_dev = sysfs_open_device_path(path);
-		if (devices_dev)
-			break;
+	/* skip non-readable files */
+	if ((statbuf.st_mode & S_IRUSR) == 0)
+		goto out;
 
-		usleep(1000 * 1000 / WAIT_LOOP_PER_SECOND);
+	/* read attribute value */
+	fd = open(path_full, O_RDONLY);
+	if (fd < 0) {
+		dbg("attribute '%s' does not exist", path_full);
+		goto out;
 	}
-
-	return(devices_dev);
+	size = read(fd, value, sizeof(value));
+	close(fd);
+	if (size < 0)
+		goto out;
+	if (size == sizeof(value))
+		goto out;
+
+	/* got a valid value, store and return it */
+	value[size] = '\0';
+	remove_trailing_chars(value, '\n');
+	dbg("cache '%s' with attribute value '%s'", path_full, value);
+	strlcpy(attr->value_local, value, sizeof(attr->value_local));
+	attr->value = attr->value_local;
+
+out:
+	return attr->value;
 }