X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=namedev.c;h=e69eba657a5be161deda8eafdee9e79d238e86d3;hp=b9e099413bc3bec815d860f11b730ddb6227adf2;hb=647c8fc43eb8f3d92ed7142f7c235f3db02f4cfa;hpb=9f1da3613897346b6a45e1f7a706d2315bc0f420

diff --git a/namedev.c b/namedev.c
index b9e099413..e69eba657 100644
--- a/namedev.c
+++ b/namedev.c
@@ -30,6 +30,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <sys/wait.h>
+#include <sys/stat.h>
 
 #include "list.h"
 #include "udev.h"
@@ -39,6 +40,7 @@
 #include "klibc_fixups.h"
 
 LIST_HEAD(config_device_list);
+LIST_HEAD(perm_device_list);
 
 /* compare string with pattern (supports * ? [0-9] [!A-Z]) */
 static int strcmp_pattern(const char *p, const char *s)
@@ -100,78 +102,95 @@ static int strcmp_pattern(const char *p, const char *s)
 	if (strlen(b->var))		\
 		strcpy(a->var, b->var);
 
-int add_config_dev(struct config_device *new_dev)
+int add_perm_dev(struct perm_device *new_dev)
 {
 	struct list_head *tmp;
-	struct config_device *tmp_dev;
+	struct perm_device *tmp_dev;
 
 	/* update the values if we already have the device */
-	list_for_each(tmp, &config_device_list) {
-		struct config_device *dev = list_entry(tmp, struct config_device, node);
+	list_for_each(tmp, &perm_device_list) {
+		struct perm_device *dev = list_entry(tmp, struct perm_device, node);
 		if (strcmp_pattern(new_dev->name, dev->name))
 			continue;
-		if (strncmp(dev->bus, new_dev->bus, sizeof(dev->name)))
-			continue;
-		copy_var(dev, new_dev, type);
 		copy_var(dev, new_dev, mode);
-		copy_string(dev, new_dev, bus);
-		copy_string(dev, new_dev, sysfs_file);
-		copy_string(dev, new_dev, sysfs_value);
-		copy_string(dev, new_dev, id);
-		copy_string(dev, new_dev, place);
-		copy_string(dev, new_dev, kernel_name);
-		copy_string(dev, new_dev, exec_program);
 		copy_string(dev, new_dev, owner);
 		copy_string(dev, new_dev, group);
 		return 0;
 	}
 
-	/* not found, add new structure to the device list */
+	/* not found, add new structure to the perm list */
 	tmp_dev = malloc(sizeof(*tmp_dev));
 	if (!tmp_dev)
 		return -ENOMEM;
 	memcpy(tmp_dev, new_dev, sizeof(*tmp_dev));
-	list_add_tail(&tmp_dev->node, &config_device_list);
-	//dump_config_dev(tmp_dev);
+	list_add_tail(&tmp_dev->node, &perm_device_list);
+	//dump_perm_dev(tmp_dev);
 	return 0;
 }
 
-static mode_t get_default_mode(struct sysfs_class_device *class_dev)
+static struct perm_device *find_perm(char *name)
 {
-	/* just default everyone to rw for the world! */
-	return 0666;
+	struct list_head *tmp;
+	struct perm_device *perm = NULL;
+
+	list_for_each(tmp, &perm_device_list) {
+		perm = list_entry(tmp, struct perm_device, node);
+		if (strcmp_pattern(perm->name, name))
+			continue;
+		return perm;
+	}
+	return NULL;
 }
 
-static void build_kernel_number(struct sysfs_class_device *class_dev, struct udevice *udev)
+static mode_t get_default_mode(struct sysfs_class_device *class_dev)
 {
-	char *dig;
+	mode_t mode = 0600;	/* default to owner rw only */
 
-	/* FIXME, figure out how to handle stuff like sdaj which will not work right now. */
-	dig = class_dev->name + strlen(class_dev->name);
-	while (isdigit(*(dig-1)))
-		dig--;
-	strfieldcpy(udev->kernel_number, dig);
-	dbg("kernel_number='%s'", udev->kernel_number);
+	if (strlen(default_mode_str) != 0) {
+		mode = strtol(default_mode_str, NULL, 8);
+	}
+	return mode;
 }
 
 static void apply_format(struct udevice *udev, unsigned char *string)
 {
 	char name[NAME_SIZE];
+	char temp[NAME_SIZE];
+	char *tail;
 	char *pos;
+	char *pos2;
+	char *pos3;
+	int num;
 
 	while (1) {
+		num = 0;
 		pos = strchr(string, '%');
 
 		if (pos) {
-			strfieldcpy(name, pos+2);
-			*pos = 0x00;
-			switch (pos[1]) {
+			*pos = '\0';
+			tail = pos+1;
+			if (isdigit(tail[0])) {
+				num = (int) strtoul(&pos[1], &tail, 10);
+				if (tail == NULL) {
+					dbg("format parsing error '%s'", pos+1);
+					break;
+				}
+			}
+			strfieldcpy(name, tail+1);
+
+			switch (tail[0]) {
 			case 'b':
 				if (strlen(udev->bus_id) == 0)
 					break;
 				strcat(pos, udev->bus_id);
 				dbg("substitute bus_id '%s'", udev->bus_id);
 				break;
+			case 'k':
+				if (strlen(udev->kernel_name) == 0)
+					break;
+				strcat(pos, udev->kernel_name);
+				dbg("substitute kernel name '%s'", udev->kernel_name);
+				break;
 			case 'n':
 				if (strlen(udev->kernel_number) == 0)
 					break;
@@ -180,12 +199,13 @@ static void apply_format(struct udevice *udev, unsigned char *string)
 				break;
 			case 'D':
 				if (strlen(udev->kernel_number) == 0) {
-					strcat(pos, "disk");
+					strcat(pos, "disc");
+					dbg("substitute devfs disc");
 					break;
 				}
 				strcat(pos, "part");
 				strcat(pos, udev->kernel_number);
-				dbg("substitute kernel number '%s'", udev->kernel_number);
+				dbg("substitute devfs part '%s'", udev->kernel_number);
 				break;
 			case 'm':
 				sprintf(pos, "%u", udev->minor);
@@ -198,8 +218,26 @@ static void apply_format(struct udevice *udev, unsigned char *string)
 			case 'c':
 				if (strlen(udev->callout_value) == 0)
 					break;
-				strcat(pos, udev->callout_value);
-				dbg("substitute callout output '%s'", udev->callout_value);
+				if (num) {
+					/* get part of return string */
+					strncpy(temp, udev->callout_value, sizeof(temp));
+					pos2 = temp;
+					while (num) {
+						num--;
+						pos3 = strsep(&pos2, " ");
+						if (pos3 == NULL) {
+							dbg("requested part of callout string not found");
+							break;
+						}
+					}
+					if (pos3) {
+						strcat(pos, pos3);
+						dbg("substitute partial callout output '%s'", pos3);
+					}
+				} else {
+					strcat(pos, udev->callout_value);
+					dbg("substitute callout output '%s'", udev->callout_value);
+				}
 				break;
 			default:
 				dbg("unknown substitution type '%%%c'", pos[1]);
@@ -211,6 +249,57 @@ static void apply_format(struct udevice *udev, unsigned char *string)
 	}
 }
 
+static struct bus_file {
+	char *bus;
+	char *file;
+} bus_files[] = {
+	{ .bus = "scsi",	.file = "vendor" },
+	{ .bus = "usb",		.file = "idVendor" },
+	{ .bus = "ide",		.file = "detach_state" },
+	{ .bus = "pci",		.file = "vendor" },
+	{}
+};
+
+#define SECONDS_TO_WAIT_FOR_FILE	10
+static void wait_for_device_to_initialize(struct sysfs_device *sysfs_device)
+{
+	/* sleep until we see the file for this specific bus type show up this
+	 * is needed because we can easily out-run the kernel in looking for
+	 * these files before the paticular subsystem has created them in the
+	 * sysfs tree properly.
+	 *
+	 * And people thought that the /sbin/hotplug event system was going to
+	 * be slow, poo on you for arguing that before even testing it...
+	 */
+	struct bus_file *b = &bus_files[0];
+	struct sysfs_attribute *tmpattr;
+	int loop;
+
+	while (1) {
+		if (b->bus == NULL)
+			break;
+		if (strcmp(sysfs_device->bus, b->bus) == 0) {
+			tmpattr = NULL;
+			loop = SECONDS_TO_WAIT_FOR_FILE;
+			while (loop--) {
+				dbg("looking for file '%s' on bus '%s'", b->file, b->bus);
+				tmpattr = sysfs_get_device_attr(sysfs_device, b->file);
+				if (tmpattr) {
+					/* found it! */
+					goto exit;
+				}
+				/* sleep to give the kernel a chance to create the file */
+				sleep(1);
+			}
+			dbg("Timed out waiting for '%s' file, continuing on anyway...", b->file);
+			goto exit;
+		}
+		b++;
+	}
+	dbg("Did not find bus type '%s' on list of bus_id_files, contact greg@kroah.com", sysfs_device->bus);
+exit:
+	return; /* here to prevent compiler warning... */
+}
 
 static int exec_callout(struct config_device *dev, char *value, int len)
 {
@@ -221,7 +310,7 @@ static int exec_callout(struct config_device *dev, char *value, int len)
 	pid_t pid;
 	int value_set = 0;
 	char buffer[256];
-	char *arg;
+	char *pos;
 	char *args[CALLOUT_MAXARG];
 	int i;
 
@@ -243,9 +332,9 @@ static int exec_callout(struct config_device *dev, char *value, int len)
 		dup(fds[1]);	/* dup write side of pipe to STDOUT */
 		if (strchr(dev->exec_program, ' ')) {
 			/* callout with arguments */
-			arg = dev->exec_program;
+			pos = dev->exec_program;
 			for (i=0; i < CALLOUT_MAXARG-1; i++) {
-				args[i] = strsep(&arg, " ");
+				args[i] = strsep(&pos, " ");
 				if (args[i] == NULL)
 					break;
 			}
@@ -281,9 +370,12 @@ static int exec_callout(struct config_device *dev, char *value, int len)
 			} else {
 				value_set = 1;
 				strncpy(value, buffer, len);
+				pos = value + strlen(value)-1;
+				if (pos[0] == '\n')
+				pos[0] = '\0';
+				dbg("callout returned '%s'", value);
 			}
 		}
-		dbg("callout returned '%s'", value);
 		close(fds[0]);
 		res = wait(&status);
 		if (res < 0) {
@@ -311,7 +403,10 @@ static int do_callout(struct sysfs_class_device *class_dev, struct udevice *udev
 		if (dev->type != CALLOUT)
 			continue;
 
-		if (sysfs_device) {
+		if (dev->bus[0] != '\0') {
+			/* as the user specified a bus, we must match it up */
+			if (!sysfs_device)
+				continue;
 			dbg("dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus);
 			if (strcasecmp(dev->bus, sysfs_device->bus) != 0)
 				continue;
@@ -324,69 +419,91 @@ static int do_callout(struct sysfs_class_device *class_dev, struct udevice *udev
 		if (strcmp_pattern(dev->id, udev->callout_value) != 0)
 			continue;
 		strfieldcpy(udev->name, dev->name);
-		if (dev->mode != 0) {
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
-		}
-		dbg("callout returned matching value '%s', '%s' becomes '%s'"
-		    " - owner='%s', group='%s', mode=%#o",
-		    dev->id, class_dev->name, udev->name,
-		    dev->owner, dev->group, dev->mode);
+		strfieldcpy(udev->symlink, dev->symlink);
+		dbg("callout returned matching value '%s', '%s' becomes '%s'",
+		    dev->id, class_dev->name, udev->name);
 		return 0;
 	}
 	return -ENODEV;
 }
 
-static int do_label(struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device)
+static int match_pair(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, struct sysfs_pair *pair)
 {
 	struct sysfs_attribute *tmpattr = NULL;
+	char *c;
+
+	if ((pair == NULL) || (pair->file[0] == '\0') || (pair->value == '\0'))
+		return -ENODEV;
+
+	dbg("look for device attribute '%s'", pair->file);
+	/* try to find the attribute in the class device directory */
+	tmpattr = sysfs_get_classdev_attr(class_dev, pair->file);
+	if (tmpattr)
+		goto label_found;
+
+	/* look in the class device directory if present */
+	if (sysfs_device) {
+		tmpattr = sysfs_get_device_attr(sysfs_device, pair->file);
+		if (tmpattr)
+			goto label_found;
+	}
+
+	return -ENODEV;
+
+label_found:
+	c = tmpattr->value + strlen(tmpattr->value)-1;
+	if (*c == '\n')
+		*c = 0x00;
+	dbg("compare attribute '%s' value '%s' with '%s'",
+		  pair->file, tmpattr->value, pair->value);
+	if (strcmp_pattern(pair->value, tmpattr->value) != 0)
+		return -ENODEV;
+
+	dbg("found matching attribute '%s' with value '%s'",
+	    pair->file, pair->value);
+	return 0;
+}
+
+static int do_label(struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device)
+{
+	struct sysfs_pair *pair;
 	struct config_device *dev;
 	struct list_head *tmp;
+	int i;
+	int match;
 
 	list_for_each(tmp, &config_device_list) {
 		dev = list_entry(tmp, struct config_device, node);
 		if (dev->type != LABEL)
 			continue;
 
-		if (sysfs_device) {
+		if (dev->bus[0] != '\0') {
+			/* as the user specified a bus, we must match it up */
+			if (!sysfs_device)
+				continue;
 			dbg("dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus);
 			if (strcasecmp(dev->bus, sysfs_device->bus) != 0)
 				continue;
 		}
 
-		dbg("look for device attribute '%s'", dev->sysfs_file);
-		/* try to find the attribute in the class device directory */
-		tmpattr = sysfs_get_classdev_attr(class_dev, dev->sysfs_file);
-		if (tmpattr)
-			goto label_found;
-
-		/* look in the class device directory if present */
-		if (sysfs_device) {
-			tmpattr = sysfs_get_device_attr(sysfs_device, dev->sysfs_file);
-			if (tmpattr)
-				goto label_found;
+		match = 1;
+		for (i = 0; i < MAX_SYSFS_PAIRS; ++i) {
+			pair = &dev->sysfs_pair[i];
+			if ((pair->file[0] == '\0') || (pair->value[0] == '\0'))
+				break;
+			if (match_pair(class_dev, sysfs_device, pair) != 0) {
+				match = 0;
+				break;
+			}
 		}
-
-		continue;
-
-label_found:
-		tmpattr->value[strlen(tmpattr->value)-1] = 0x00;
-		dbg("compare attribute '%s' value '%s' with '%s'",
-			  dev->sysfs_file, tmpattr->value, dev->sysfs_value);
-		if (strcmp(dev->sysfs_value, tmpattr->value) != 0)
+		if (match == 0)
 			continue;
 
+		/* found match */
 		strfieldcpy(udev->name, dev->name);
-		if (dev->mode != 0) {
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
-		}
-		dbg("found matching attribute '%s', '%s' becomes '%s' "
-			  "- owner='%s', group='%s', mode=%#o",
-			  dev->sysfs_file, class_dev->name, udev->name,
-			  dev->owner, dev->group, dev->mode);
+		strfieldcpy(udev->symlink, dev->symlink);
+		dbg("found matching attribute, '%s' becomes '%s' ",
+		    class_dev->name, udev->name);
 
 		return 0;
 	}
@@ -430,15 +547,9 @@ static int do_number(struct sysfs_class_device *class_dev, struct udevice *udev,
 		if (!found)
 			continue;
 		strfieldcpy(udev->name, dev->name);
-		if (dev->mode != 0) {
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
-		}
-		dbg("found matching id '%s', '%s' becomes '%s'"
-		    " - owner='%s', group ='%s', mode=%#o",
-		    dev->id, class_dev->name, udev->name,
-		    dev->owner, dev->group, dev->mode);
+		strfieldcpy(udev->symlink, dev->symlink);
+		dbg("found matching id '%s', '%s' becomes '%s'",
+		    dev->id, class_dev->name, udev->name);
 		return 0;
 	}
 	return -ENODEV;
@@ -482,15 +593,9 @@ static int do_topology(struct sysfs_class_device *class_dev, struct udevice *ude
 			continue;
 
 		strfieldcpy(udev->name, dev->name);
-		if (dev->mode != 0) {
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
-		}
-		dbg("found matching place '%s', '%s' becomes '%s'"
-		    " - owner='%s', group ='%s', mode=%#o",
-		    dev->place, class_dev->name, udev->name,
-		    dev->owner, dev->group, dev->mode);
+		strfieldcpy(udev->symlink, dev->symlink);
+		dbg("found matching place '%s', '%s' becomes '%s'",
+		    dev->place, class_dev->name, udev->name);
 		return 0;
 	}
 	return -ENODEV;
@@ -511,15 +616,8 @@ static int do_replace(struct sysfs_class_device *class_dev, struct udevice *udev
 			continue;
 
 		strfieldcpy(udev->name, dev->name);
-		if (dev->mode != 0) {
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
-		}
-		dbg("found name, '%s' becomes '%s'"
-		    " - owner='%s', group='%s', mode = %#o",
-		    dev->kernel_name, udev->name,
-		    dev->owner, dev->group, dev->mode);
+		strfieldcpy(udev->symlink, dev->symlink);
+		dbg("found name, '%s' becomes '%s'", dev->kernel_name, udev->name);
 		
 		return 0;
 	}
@@ -528,76 +626,125 @@ static int do_replace(struct sysfs_class_device *class_dev, struct udevice *udev
 
 static void do_kernelname(struct sysfs_class_device *class_dev, struct udevice *udev)
 {
-	struct config_device *dev;
-	struct list_head *tmp;
-	int len;
-
+	/* heh, this is pretty simple... */
 	strfieldcpy(udev->name, class_dev->name);
-	/* look for permissions */
-	list_for_each(tmp, &config_device_list) {
-		dev = list_entry(tmp, struct config_device, node);
-		len = strlen(dev->name);
-		if (strcmp_pattern(dev->name, class_dev->name))
-			continue;
-		if (dev->mode != 0) {
-			dbg("found permissions for '%s'", class_dev->name);
-			udev->mode = dev->mode;
-			strfieldcpy(udev->owner, dev->owner);
-			strfieldcpy(udev->group, dev->group);
+}
+
+static struct sysfs_device *get_sysfs_device(struct sysfs_class_device *class_dev)
+{
+	struct sysfs_device *sysfs_device;
+	struct sysfs_class_device *class_dev_parent;
+	int loop;
+	char filename[SYSFS_PATH_MAX + 6];
+	int retval;
+	char *temp;
+	int partition = 0;
+
+	/* Figure out where the device symlink is at.  For char devices this will
+	 * always be in the class_dev->path.  But for block devices, it's different.
+	 * The main block device will have the device symlink in it's path, but
+	 * all partitions have the symlink in its parent directory.
+	 * But we need to watch out for block devices that do not have parents, yet
+	 * look like a partition (fd0, loop0, etc.)  They all do not have a device
+	 * symlink yet.  We do sit and spin on waiting for them right now, we should
+	 * possibly have a whitelist for these devices here...
+	 */
+	strcpy(filename, class_dev->path);
+	dbg("filename = %s", filename);
+	if (strcmp(class_dev->classname, SYSFS_BLOCK_NAME) == 0) {
+		if (isdigit(class_dev->path[strlen(class_dev->path)-1])) {
+			temp = strrchr(filename, '/');
+			if (temp) {
+				partition = 1;
+				*temp = 0x00;
+				char *temp2 = strrchr(filename, '/');
+				dbg("temp2 = %s", temp2);
+				if (temp2 && (strcmp(temp2, "/block") == 0)) {
+					/* oops, we have no parent block device, so go back to original directory */
+					strcpy(filename, class_dev->path);
+					partition = 0;
+				}
+			}
 		}
 	}
+	strcat(filename, "/device");
+
+	loop = 2;
+	while (loop--) {
+		struct stat buf;
+		dbg("looking for '%s'", filename);
+		retval = stat(filename, &buf);
+		if (!retval)
+			break;
+		/* sleep to give the kernel a chance to create the device file */
+		sleep(1);
+	}
+
+	loop = 1;	/* FIXME put a real value in here for when everything is fixed... */
+	while (loop--) {
+		/* find the sysfs_device for this class device */
+		/* Wouldn't it really be nice if libsysfs could do this for us? */
+		sysfs_device = sysfs_get_classdev_device(class_dev);
+		if (sysfs_device != NULL)
+			goto exit;
+
+		/* if it's a partition, we need to get the parent device */
+		if (partition) {
+			/* FIXME  HACK HACK HACK HACK
+			 * for some reason partitions need this extra sleep here, in order
+			 * to wait for the device properly.  Once the libsysfs code is
+			 * fixed properly, this sleep should go away, and we can just loop above.
+			 */
+			sleep(1);
+			dbg("really is a partition");
+			class_dev_parent = sysfs_get_classdev_parent(class_dev);
+			if (class_dev_parent == NULL) {
+				dbg("sysfs_get_classdev_parent for class device '%s' failed", class_dev->name);
+			} else {
+				dbg("class_dev_parent->name='%s'", class_dev_parent->name);
+				sysfs_device = sysfs_get_classdev_device(class_dev_parent);
+				if (sysfs_device != NULL)
+					goto exit;
+			}
+		}
+		/* sleep to give the kernel a chance to create the link */
+		/* FIXME remove comment...
+		sleep(1); */
+	}
+	dbg("Timed out waiting for device symlink, continuing on anyway...");
+exit:
+	return sysfs_device;
 }
 
 int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *udev)
 {
 	struct sysfs_device *sysfs_device = NULL;
-	struct sysfs_class_device *class_dev_parent = NULL;
 	int retval = 0;
-	char *temp = NULL;
+	struct perm_device *perm;
+	char *pos;
 
 	udev->mode = 0;
 
-	/* find the sysfs_device for this class device */
-	/* Wouldn't it really be nice if libsysfs could do this for us? */
-	if (class_dev->sysdevice) {
-		sysfs_device = class_dev->sysdevice;
-	} else {
-		/* bah, let's go backwards up a level to see if the device is there,
-		 * as block partitions don't point to the physical device.  Need to fix that
-		 * up in the kernel...
-		 */
-		if (strstr(class_dev->path, "block")) {
-			dbg("looking at block device");
-			if (isdigit(class_dev->path[strlen(class_dev->path)-1])) {
-				char path[SYSFS_PATH_MAX];
-
-				dbg("really is a partition");
-				strfieldcpy(path, class_dev->path);
-				temp = strrchr(path, '/');
-				*temp = 0x00;
-				dbg("looking for a class device at '%s'", path);
-				class_dev_parent = sysfs_open_class_device(path);
-				if (class_dev_parent == NULL) {
-					dbg("sysfs_open_class_device at '%s' failed", path);
-				} else {
-					dbg("class_dev_parent->name='%s'", class_dev_parent->name);
-					if (class_dev_parent->sysdevice)
-						sysfs_device = class_dev_parent->sysdevice;
-				}
-			}
-		}
-	}
-		
+	/* find the sysfs_device associated with this class device */
+	sysfs_device = get_sysfs_device(class_dev);
 	if (sysfs_device) {
 		dbg("sysfs_device->path='%s'", sysfs_device->path);
 		dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id);
 		dbg("sysfs_device->bus='%s'", sysfs_device->bus);
 		strfieldcpy(udev->bus_id, sysfs_device->bus_id);
+		wait_for_device_to_initialize(sysfs_device);
 	} else {
 		dbg("class_dev->name = '%s'", class_dev->name);
 	}
 
-	build_kernel_number(class_dev, udev);
+	strfieldcpy(udev->kernel_name, class_dev->name);
+
+	/* get kernel number */
+	pos = class_dev->name + strlen(class_dev->name);
+	while (isdigit(*(pos-1)))
+		pos--;
+	strfieldcpy(udev->kernel_number, pos);
+	dbg("kernel_number='%s'", udev->kernel_number);
 
 	/* rules are looked at in priority order */
 	retval = do_callout(class_dev, udev, sysfs_device);
@@ -624,19 +771,24 @@ int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *ud
 	goto done;
 
 found:
-	/* substitute placeholder in NAME  */
+	/* substitute placeholder */
 	apply_format(udev, udev->name);
+	apply_format(udev, udev->symlink);
 
 done:
-	/* mode was never set above */
-	if (!udev->mode) {
+	perm = find_perm(udev->name);
+	if (perm) {
+		udev->mode = perm->mode;
+		strfieldcpy(udev->owner, perm->owner);
+		strfieldcpy(udev->group, perm->group);
+	} else {
+		/* no matching perms found :( */
 		udev->mode = get_default_mode(class_dev);
 		udev->owner[0] = 0x00;
 		udev->group[0] = 0x00;
 	}
-
-	if (class_dev_parent)
-		sysfs_close_class_device(class_dev_parent);
+	dbg("name, '%s' is going to have owner='%s', group='%s', mode = %#o",
+	    udev->name, udev->owner, udev->group, udev->mode);
 
 	return 0;
 }
@@ -644,7 +796,7 @@ done:
 int namedev_init(void)
 {
 	int retval;
-	
+
 	retval = namedev_init_rules();
 	if (retval)
 		return retval;
@@ -654,5 +806,6 @@ int namedev_init(void)
 		return retval;
 
 	dump_config_dev_list();
+	dump_perm_dev_list();
 	return retval;
 }