* Userspace devfs
*
* Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2003-2005 Kay Sievers <kay.sievers@vrfy.org>
*
*
* This program is free software; you can redistribute it and/or modify it
#include <ctype.h>
#include <unistd.h>
#include <errno.h>
-#include <time.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include "libsysfs/sysfs/libsysfs.h"
#include "list.h"
#include "udev.h"
+#include "udev_utils.h"
#include "udev_version.h"
#include "logging.h"
#include "namedev.h"
-#include "klibc_fixups.h"
+#include "udev_db.h"
static struct sysfs_attribute *find_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, char *attr);
-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)
{
return 1;
}
-static struct perm_device *find_perm(char *name)
-{
- struct perm_device *perm;
-
- list_for_each_entry(perm, &perm_device_list, node) {
- if (strcmp_pattern(perm->name, name))
- continue;
- return perm;
- }
- return NULL;
-}
-
-static mode_t get_default_mode(void)
-{
- mode_t mode = 0600; /* default to owner rw only */
-
- if (strlen(default_mode_str) != 0)
- mode = strtol(default_mode_str, NULL, 8);
-
- return mode;
-}
-
-static char *get_default_owner(void)
-{
- if (strlen(default_owner_str) == 0)
- strfieldcpy(default_owner_str, "root");
-
- return default_owner_str;
-}
-
-static char *get_default_group(void)
-{
- if (strlen(default_group_str) == 0)
- strfieldcpy(default_group_str, "root");
-
- return default_group_str;
-}
-
/* extract possible {attr} and move str behind it */
static char *get_format_attribute(char **str)
{
return -1;
}
+/** Finds the lowest positive N such that <name>N isn't present in
+ * $(udevroot) either as a file or a symlink.
+ *
+ * @param name Name to check for
+ * @return 0 if <name> didn't exist and N otherwise.
+ */
+static int find_free_number(struct udevice *udev, const char *name)
+{
+ char filename[NAME_SIZE];
+ int num = 0;
+ struct udevice db_udev;
+
+ strfieldcpy(filename, name);
+ while (1) {
+ dbg("look for existing node '%s'", filename);
+ memset(&db_udev, 0x00, sizeof(struct udevice));
+ if (udev_db_get_device_by_name(&db_udev, filename) != 0) {
+ dbg("free num=%d", num);
+ return num;
+ }
+
+ num++;
+ if (num > 1000) {
+ info("find_free_number gone crazy (num=%d), aborted", num);
+ return -1;
+ }
+ snprintf(filename, NAME_SIZE, "%s%d", name, num);
+ filename[NAME_SIZE-1] = '\0';
+ }
+}
+
static void apply_format(struct udevice *udev, char *string, size_t maxsize,
struct sysfs_class_device *class_dev,
struct sysfs_device *sysfs_device)
int i;
char c;
char *spos;
+ char *rest;
int slen;
struct sysfs_attribute *tmpattr;
+ unsigned int next_free_number;
+ struct sysfs_class_device *class_dev_parent;
pos = string;
-
while (1) {
- pos = strchr(string, '%');
- if (pos != NULL) {
- pos[0] = '\0';
- tail = pos+1;
- len = get_format_len(&tail);
- c = tail[0];
- strfieldcpy(temp, tail+1);
- tail = temp;
- } else {
+ pos = strchr(pos, '%');
+ if (pos == NULL)
break;
- }
- dbg("format=%c, string='%s', tail='%s'",c , string, tail);
+ pos[0] = '\0';
+ tail = pos+1;
+ len = get_format_len(&tail);
+ c = tail[0];
+ strfieldcpy(temp, tail+1);
+ tail = temp;
+ dbg("format=%c, string='%s', tail='%s'",c , string, tail);
attr = get_format_attribute(&tail);
switch (c) {
+ case 'p':
+ if (strlen(udev->devpath) == 0)
+ break;
+ strfieldcatmax(string, udev->devpath, maxsize);
+ dbg("substitute kernel name '%s'", udev->kernel_name);
+ break;
case 'b':
if (strlen(udev->bus_id) == 0)
break;
dbg("substitute kernel number '%s'", udev->kernel_number);
break;
case 'm':
- strintcatmax(string, udev->minor, maxsize);
- dbg("substitute minor number '%u'", udev->minor);
+ strintcatmax(string, minor(udev->devt), maxsize);
+ dbg("substitute minor number '%u'", minor(udev->devt));
break;
case 'M':
- strintcatmax(string, udev->major, maxsize);
- dbg("substitute major number '%u'", udev->major);
+ strintcatmax(string, major(udev->devt), maxsize);
+ dbg("substitute major number '%u'", major(udev->devt));
break;
case 'c':
if (strlen(udev->program_result) == 0)
/* get part part of the result string */
i = 0;
if (attr != NULL)
- i = atoi(attr);
+ i = strtoul(attr, &rest, 10);
if (i > 0) {
foreach_strpart(udev->program_result, " \n\r", spos, slen) {
i--;
dbg("requested part of result string not found");
break;
}
- strfieldcpymax(temp2, spos, slen+1);
+ if (rest[0] == '+')
+ strfieldcpy(temp2, spos);
+ else
+ strfieldcpymax(temp2, spos, slen+1);
strfieldcatmax(string, temp2, maxsize);
dbg("substitute part of result string '%s'", temp2);
} else {
}
break;
case 's':
- if (attr != NULL) {
- tmpattr = find_sysfs_attribute(class_dev, sysfs_device, attr);
- if (tmpattr == NULL) {
- dbg("sysfa attribute '%s' not found", attr);
- break;
- }
- strfieldcatmax(string, tmpattr->value, maxsize);
- dbg("substitute sysfs value '%s'", tmpattr->value);
- } else {
+ if (!class_dev)
+ break;
+ if (attr == NULL) {
dbg("missing attribute");
+ break;
+ }
+ tmpattr = find_sysfs_attribute(class_dev, sysfs_device, attr);
+ if (tmpattr == NULL) {
+ dbg("sysfa attribute '%s' not found", attr);
+ break;
+ }
+ /* strip trailing whitespace of matching value */
+ if (isspace(tmpattr->value[strlen(tmpattr->value)-1])) {
+ i = len = strlen(tmpattr->value);
+ while (i > 0 && isspace(tmpattr->value[i-1]))
+ i--;
+ if (i < len) {
+ tmpattr->value[i] = '\0';
+ dbg("remove %i trailing whitespace chars from '%s'",
+ len - i, tmpattr->value);
+ }
}
+ strfieldcatmax(string, tmpattr->value, maxsize);
+ dbg("substitute sysfs value '%s'", tmpattr->value);
break;
case '%':
strfieldcatmax(string, "%", maxsize);
+ pos++;
+ break;
+ case 'e':
+ next_free_number = find_free_number(udev, string);
+ if (next_free_number > 0) {
+ sprintf(temp2, "%d", next_free_number);
+ strfieldcatmax(string, temp2, maxsize);
+ }
+ break;
+ case 'P':
+ if (!class_dev)
+ break;
+ class_dev_parent = sysfs_get_classdev_parent(class_dev);
+ if (class_dev_parent != NULL) {
+ struct udevice udev_parent;
+
+ dbg("found parent '%s', get the node name", class_dev_parent->path);
+ memset(&udev_parent, 0x00, sizeof(struct udevice));
+ /* lookup the name in the udev_db with the DEVPATH of the parent */
+ if (udev_db_get_device_by_devpath(&udev_parent, &class_dev_parent->path[strlen(sysfs_path)]) == 0) {
+ strfieldcatmax(string, udev_parent.name, maxsize);
+ dbg("substitute parent node name'%s'", udev_parent.name);
+ } else
+ dbg("parent not found in database");
+ }
+ break;
+ case 'N':
+ if (udev->tmp_node[0] == '\0') {
+ dbg("create temporary device node for callout");
+ snprintf(udev->tmp_node, NAME_SIZE, "%s/.tmp-%u-%u", udev_root, major(udev->devt), minor(udev->devt));
+ udev->tmp_node[NAME_SIZE] = '\0';
+ udev_make_node(udev, udev->tmp_node, udev->devt, 0600, 0, 0);
+ }
+ strfieldcatmax(string, udev->tmp_node, maxsize);
+ dbg("substitute temporary device node name '%s'", udev->tmp_node);
+ break;
+ case 'r':
+ strfieldcatmax(string, udev_root, maxsize);
+ dbg("substitute udev_root '%s'", udev_root);
break;
default:
dbg("unknown substitution type '%%%c'", c);
}
}
-/*
- * Note, we can have multiple files for different busses in here due
- * to the mess that USB has for its device tree...
- */
-static struct bus_file {
- char *bus;
- char *file;
-} bus_files[] = {
- { .bus = "scsi", .file = "vendor" },
- { .bus = "usb", .file = "idVendor" },
- { .bus = "usb", .file = "iInterface" },
- { .bus = "usb-serial", .file = "detach_state" },
- { .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 found = 0;
- int loop = SECONDS_TO_WAIT_FOR_FILE;
-
- while (1) {
- if (b->bus == NULL) {
- if (!found)
- break;
- /* sleep to give the kernel a chance to create the file */
- sleep(1);
- --loop;
- if (loop == 0)
- break;
- b = &bus_files[0];
- }
- if (strcmp(sysfs_device->bus, b->bus) == 0) {
- found = 1;
- 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;
- }
- dbg("can't find '%s' file", b->file);
- }
- ++b;
- }
- if (!found)
- 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 void fix_kernel_name(struct udevice *udev)
-{
- char *temp = udev->kernel_name;
-
- while (*temp != 0x00) {
- /* Some block devices have a ! in their name,
- * we need to change that to / */
- if (*temp == '!')
- *temp = '/';
- ++temp;
- }
-}
-
-static int execute_program(char *path, char *value, int len)
+static int execute_program(struct udevice *udev, const char *path, char *value, int len)
{
int retval;
int count;
pid_t pid;
char *pos;
char arg[PROGRAM_SIZE];
- char *argv[sizeof(arg) / 2];
+ char *argv[(PROGRAM_SIZE / 2) + 1];
int i;
+ strfieldcpy(arg, path);
i = 0;
if (strchr(path, ' ')) {
- strfieldcpy(arg, path);
pos = arg;
while (pos != NULL) {
if (pos[0] == '\'') {
/* don't separate if in apostrophes */
pos++;
argv[i] = strsep(&pos, "\'");
- while (pos[0] == ' ')
+ while (pos && pos[0] == ' ')
pos++;
- } else {
+ } else {
argv[i] = strsep(&pos, " ");
}
dbg("arg[%i] '%s'", i, argv[i]);
i++;
}
+ argv[i] = NULL;
+ dbg("execute '%s' with parsed arguments", arg);
+ } else {
+ argv[0] = arg;
+ argv[1] = udev->subsystem;
+ argv[2] = NULL;
+ dbg("execute '%s' with subsystem '%s' argument", arg, argv[1]);
}
- argv[i] = NULL;
retval = pipe(fds);
if (retval != 0) {
switch(pid) {
case 0:
/* child */
- close(STDOUT_FILENO);
-
- /* dup write side of pipe to STDOUT */
- dup(fds[1]);
- if (argv[0] != NULL) {
- dbg("execute '%s' with given arguments", argv[0]);
- retval = execv(argv[0], argv);
- } else {
- dbg("execute '%s' with main argument", path);
- retval = execv(path, main_argv);
- }
+ /* dup2 write side of pipe to STDOUT */
+ dup2(fds[1], STDOUT_FILENO);
+ retval = execv(arg, argv);
info(FIELD_PROGRAM " execution of '%s' failed", path);
exit(1);
retval = -1;
}
- if (i > 0 && value[i] == '\n')
+ if (i > 0 && value[i-1] == '\n')
i--;
value[i] = '\0';
dbg("result is '%s'", value);
close(fds[0]);
- wait(&status);
+ waitpid(pid, &status, 0);
if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) {
dbg("exec program status 0x%x", status);
static int match_id(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
{
char path[SYSFS_PATH_MAX];
- char *temp = NULL;
+ char *temp;
/* we have to have a sysfs device for ID to work */
if (!sysfs_device)
dbg("search '%s' in '%s', path='%s'", dev->id, temp, path);
if (strcmp_pattern(dev->id, temp) != 0)
return -ENODEV;
- else
- return 0;
+
+ return 0;
}
static int match_place(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
{
char path[SYSFS_PATH_MAX];
- int found;
- char *temp = NULL;
+ char *temp;
/* we have to have a sysfs device for PLACE to work */
if (!sysfs_device)
return -ENODEV;
- found = 0;
strfieldcpy(path, sysfs_device->path);
temp = strrchr(path, '/');
dbg("search '%s' in '%s', path='%s'", dev->place, temp, path);
- if (strstr(temp, dev->place) != NULL) {
- found = 1;
- } else {
- *temp = 0x00;
- temp = strrchr(path, '/');
- dbg("search '%s' in '%s', path='%s'", dev->place, temp, path);
- if (strstr(temp, dev->place) != NULL)
- found = 1;
- }
- if (!found) {
- dbg("place doesn't match");
- return -ENODEV;
- }
+ if (strstr(temp, dev->place) != NULL)
+ return 0;
- return 0;
+ /* try the parent */
+ temp[0] = '\0';
+ temp = strrchr(path, '/');
+ dbg("search '%s' in '%s', path='%s'", dev->place, temp, path);
+ if (strstr(temp, dev->place) == NULL)
+ return 0;
+
+ dbg("place doesn't match");
+ return -ENODEV;
}
-static struct sysfs_device *get_sysfs_device(struct sysfs_class_device *class_dev)
+static int match_rule(struct udevice *udev, struct config_device *dev,
+ struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
{
- struct sysfs_device *sysfs_device;
- struct sysfs_class_device *class_dev_parent;
- struct timespec tspec;
- int loop;
-
- /* 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...
- */
- class_dev_parent = sysfs_get_classdev_parent(class_dev);
- if (class_dev_parent)
- dbg("Really a partition");
-
- tspec.tv_sec = 0;
- tspec.tv_nsec = 10000000; /* sleep 10 millisec */
- loop = 10;
- while (loop--) {
- if (udev_sleep)
- nanosleep(&tspec, NULL);
- if (class_dev_parent)
- sysfs_device = sysfs_get_classdev_device(class_dev_parent);
- else
- sysfs_device = sysfs_get_classdev_device(class_dev);
-
- if (sysfs_device != NULL)
- goto device_found;
+ if (dev->kernel[0] != '\0') {
+ dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'",
+ dev->kernel, class_dev->name);
+ if (strcmp_pattern(dev->kernel, class_dev->name) != 0) {
+ dbg(FIELD_KERNEL " is not matching");
+ goto exit;
+ }
+ dbg(FIELD_KERNEL " matches");
}
- dbg("timed out waiting for device symlink, continuing on anyway...");
-
-device_found:
- /* We have another issue with just the wait above - the sysfs part of
- * the kernel may not be quick enough to have created the link to the
- * device under the "bus" subsystem. Due to this, the sysfs_device->bus
- * will not contain the actual bus name :(
- *
- * Libsysfs now provides a new API sysfs_get_device_bus(), so use it
- * if needed
- */
- if (sysfs_device) {
- if (sysfs_device->bus[0] != '\0')
- goto bus_found;
-
- loop = 10;
- tspec.tv_nsec = 10000000;
- while (loop--) {
- if (udev_sleep)
- nanosleep(&tspec, NULL);
- sysfs_get_device_bus(sysfs_device);
-
- if (sysfs_device->bus[0] != '\0')
- goto bus_found;
+
+ if (dev->subsystem[0] != '\0') {
+ dbg("check for " FIELD_SUBSYSTEM " dev->subsystem='%s' class_dev->name='%s'",
+ dev->subsystem, class_dev->name);
+ if (strcmp_pattern(dev->subsystem, udev->subsystem) != 0) {
+ dbg(FIELD_SUBSYSTEM " is not matching");
+ goto exit;
}
- dbg("timed out waiting to find the device bus, continuing on anyway");
- goto exit;
-bus_found:
- dbg("device %s is registered with bus '%s'",
- sysfs_device->name, sysfs_device->bus);
+ dbg(FIELD_SUBSYSTEM " matches");
}
-exit:
- return sysfs_device;
-}
-static int match_rule(struct config_device *dev, struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device)
-{
+ /* walk up the chain of physical devices and find a match */
while (1) {
+ /* check for matching driver */
+ if (dev->driver[0] != '\0') {
+ dbg("check for " FIELD_DRIVER " dev->driver='%s' sysfs_device->driver_name='%s'",
+ dev->driver, sysfs_device->driver_name);
+ if (strcmp_pattern(dev->driver, sysfs_device->driver_name) != 0) {
+ dbg(FIELD_DRIVER " is not matching");
+ goto try_parent;
+ }
+ dbg(FIELD_DRIVER " matches");
+ }
+
/* check for matching bus value */
if (dev->bus[0] != '\0') {
if (sysfs_device == NULL) {
dbg("device has no bus");
goto try_parent;
}
- dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus);
+ dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'",
+ dev->bus, sysfs_device->bus);
if (strcmp_pattern(dev->bus, sysfs_device->bus) != 0) {
dbg(FIELD_BUS " is not matching");
goto try_parent;
- } else {
- dbg(FIELD_BUS " matches");
- }
- }
-
- /* check for matching kernel name*/
- if (dev->kernel[0] != '\0') {
- dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'", dev->kernel, class_dev->name);
- if (strcmp_pattern(dev->kernel, class_dev->name) != 0) {
- dbg(FIELD_KERNEL " is not matching");
- goto try_parent;
- } else {
- dbg(FIELD_KERNEL " matches");
}
+ dbg(FIELD_BUS " matches");
}
/* check for matching bus id */
if (match_id(dev, class_dev, sysfs_device) != 0) {
dbg(FIELD_ID " is not matching");
goto try_parent;
- } else {
- dbg(FIELD_ID " matches");
}
+ dbg(FIELD_ID " matches");
}
/* check for matching place of device */
if (match_place(dev, class_dev, sysfs_device) != 0) {
dbg(FIELD_PLACE " is not matching");
goto try_parent;
- } else {
- dbg(FIELD_PLACE " matches");
}
+ dbg(FIELD_PLACE " matches");
}
/* check for matching sysfs pairs */
if (match_sysfs_pairs(dev, class_dev, sysfs_device) != 0) {
dbg(FIELD_SYSFS " is not matching");
goto try_parent;
- } else {
- dbg(FIELD_SYSFS " matches");
- }
- }
-
- /* execute external program */
- if (dev->program[0] != '\0') {
- dbg("check " FIELD_PROGRAM);
- apply_format(udev, dev->program, sizeof(dev->program),
- class_dev, sysfs_device);
- if (execute_program(dev->program, udev->program_result, NAME_SIZE) != 0) {
- dbg(FIELD_PROGRAM " returned nonzero");
- goto try_parent;
- } else {
- dbg(FIELD_PROGRAM " returned successful");
}
+ dbg(FIELD_SYSFS " matches");
}
- /* check for matching result of external program */
- if (dev->result[0] != '\0') {
- dbg("check for " FIELD_RESULT
- " dev->result='%s', udev->program_result='%s'",
- dev->result, udev->program_result);
- if (strcmp_pattern(dev->result, udev->program_result) != 0) {
- dbg(FIELD_RESULT " is not matching");
- goto try_parent;
- } else {
- dbg(FIELD_RESULT " matches");
- }
- }
-
- /* Yeah, we matched! */
- return 0;
-
+ /* found matching physical device */
+ break;
try_parent:
dbg("try parent sysfs device");
sysfs_device = sysfs_get_device_parent(sysfs_device);
if (sysfs_device == NULL)
- return -ENODEV;
+ goto exit;
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);
}
+ /* execute external program */
+ if (dev->program[0] != '\0') {
+ char program[PROGRAM_SIZE];
+
+ dbg("check " FIELD_PROGRAM);
+ strfieldcpy(program, dev->program);
+ apply_format(udev, program, sizeof(program), class_dev, sysfs_device);
+ if (execute_program(udev, program, udev->program_result, NAME_SIZE) != 0) {
+ dbg(FIELD_PROGRAM " returned nonzero");
+ goto try_parent;
+ }
+ dbg(FIELD_PROGRAM " returned successful");
+ }
+
+ /* check for matching result of external program */
+ if (dev->result[0] != '\0') {
+ dbg("check for " FIELD_RESULT " dev->result='%s', udev->program_result='%s'",
+ dev->result, udev->program_result);
+ if (strcmp_pattern(dev->result, udev->program_result) != 0) {
+ dbg(FIELD_RESULT " is not matching");
+ goto try_parent;
+ }
+ dbg(FIELD_RESULT " matches");
+ }
+
+ /* rule matches */
+ return 0;
+
+exit:
+ return -1;
}
-int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *udev)
+int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_dev)
{
+ struct sysfs_class_device *class_dev_parent;
struct sysfs_device *sysfs_device = NULL;
struct config_device *dev;
- struct perm_device *perm;
- char *pos;
- udev->mode = 0;
+ dbg("class_dev->name='%s'", class_dev->name);
+
+ /* Figure out where the "device"-symlink is at. For char devices this will
+ * always be in the class_dev->path. On block devices, only the main block
+ * device will have the device symlink in it's path. All partition devices
+ * need to look at the symlink in its parent directory.
+ */
+ class_dev_parent = sysfs_get_classdev_parent(class_dev);
+ if (class_dev_parent != NULL) {
+ dbg("given class device has a parent, use this instead");
+ sysfs_device = sysfs_get_classdev_device(class_dev_parent);
+ } else {
+ sysfs_device = sysfs_get_classdev_device(class_dev);
+ }
- /* 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);
+ dbg("found devices device: path='%s', bus_id='%s', bus='%s'",
+ sysfs_device->path, sysfs_device->bus_id, sysfs_device->bus);
strfieldcpy(udev->bus_id, sysfs_device->bus_id);
- wait_for_device_to_initialize(sysfs_device);
}
- dbg("class_dev->name = '%s'", class_dev->name);
- strfieldcpy(udev->kernel_name, class_dev->name);
- fix_kernel_name(udev);
- dbg("udev->kernel_name = '%s'", udev->kernel_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);
+ dbg("udev->kernel_name='%s'", udev->kernel_name);
/* look for a matching rule to apply */
list_for_each_entry(dev, &config_device_list, node) {
dbg("process rule");
- if (match_rule(dev, class_dev, udev, sysfs_device) == 0) {
- if (dev->name[0] == '\0' && dev->symlink[0] == '\0') {
- info("configured rule in '%s' at line %i applied, '%s' is ignored",
+ if (match_rule(udev, dev, class_dev, sysfs_device) == 0) {
+
+ /* apply options */
+ if (dev->ignore_device) {
+ info("configured rule in '%s[%i]' applied, '%s' is ignored",
dev->config_file, dev->config_line, udev->kernel_name);
return -1;
}
+ if (dev->ignore_remove) {
+ udev->ignore_remove = dev->ignore_remove;
+ dbg_parse("remove event should be ignored");
+ }
+ /* apply all_partitions option only at a main block device */
+ if (dev->partitions && udev->type == BLOCK && udev->kernel_number[0] == '\0') {
+ udev->partitions = dev->partitions;
+ dbg("creation of partition nodes requested");
+ }
+
+ /* apply permissions */
+ if (dev->mode != 0000) {
+ udev->mode = dev->mode;
+ dbg("applied mode=%#o to '%s'", udev->mode, udev->kernel_name);
+ }
+ if (dev->owner[0] != '\0') {
+ strfieldcpy(udev->owner, dev->owner);
+ apply_format(udev, udev->owner, sizeof(udev->owner), class_dev, sysfs_device);
+ dbg("applied owner='%s' to '%s'", udev->owner, udev->kernel_name);
+ }
+ if (dev->group[0] != '\0') {
+ strfieldcpy(udev->group, dev->group);
+ apply_format(udev, udev->group, sizeof(udev->group), class_dev, sysfs_device);
+ dbg("applied group='%s' to '%s'", udev->group, udev->kernel_name);
+ }
+ /* collect symlinks */
if (dev->symlink[0] != '\0') {
- char temp[NAME_MAX];
+ char temp[NAME_SIZE];
- info("configured rule in '%s' at line %i applied, added symlink '%s'",
+ info("configured rule in '%s[%i]' applied, added symlink '%s'",
dev->config_file, dev->config_line, dev->symlink);
- /* do not clobber dev */
strfieldcpy(temp, dev->symlink);
- apply_format(udev, temp, sizeof(temp),
- class_dev, sysfs_device);
+ apply_format(udev, temp, sizeof(temp), class_dev, sysfs_device);
+ if (udev->symlink[0] != '\0')
+ strfieldcat(udev->symlink, " ");
strfieldcat(udev->symlink, temp);
- strfieldcat(udev->symlink, " ");
}
+ /* rule matches */
if (dev->name[0] != '\0') {
- info("configured rule in '%s' at line %i applied, '%s' becomes '%s'",
+ info("configured rule in '%s[%i]' applied, '%s' becomes '%s'",
dev->config_file, dev->config_line, udev->kernel_name, dev->name);
+
strfieldcpy(udev->name, dev->name);
- goto found;
+ apply_format(udev, udev->name, sizeof(udev->name), class_dev, sysfs_device);
+ strfieldcpy(udev->config_file, dev->config_file);
+ udev->config_line = dev->config_line;
+
+ if (udev->type != NET)
+ dbg("name, '%s' is going to have owner='%s', group='%s', mode=%#o partitions=%i",
+ udev->name, udev->owner, udev->group, udev->mode, udev->partitions);
+
+ goto exit;
}
}
}
- /* no rule was found so we use the kernel name */
+ /* no rule matched, so we use the kernel name */
strfieldcpy(udev->name, udev->kernel_name);
- goto done;
-
-found:
- apply_format(udev, udev->name, sizeof(udev->name),
- class_dev, sysfs_device);
- udev->partitions = dev->partitions;
-
-done:
- /* get permissions given in rule */
- set_empty_perms(udev, dev->mode,
- dev->owner,
- dev->group);
-
- /* get permissions given in config file or set defaults */
- perm = find_perm(udev->name);
- if (perm != NULL) {
- set_empty_perms(udev, perm->mode,
- perm->owner,
- perm->group);
- } else {
- set_empty_perms(udev, get_default_mode(),
- get_default_owner(),
- get_default_group());
- }
+ dbg("no rule found, use kernel name '%s'", udev->name);
- dbg("name, '%s' is going to have owner='%s', group='%s', mode = %#o",
- udev->name, udev->owner, udev->group, udev->mode);
+exit:
+ if (udev->tmp_node[0] != '\0') {
+ dbg("removing temporary device node");
+ unlink_secure(udev->tmp_node);
+ udev->tmp_node[0] = '\0';
+ }
return 0;
}
-
-int namedev_init(void)
-{
- int retval;
-
- retval = namedev_init_rules();
- if (retval)
- return retval;
-
- retval = namedev_init_permissions();
- if (retval)
- return retval;
-
- dump_config_dev_list();
- dump_perm_dev_list();
- return retval;
-}
~ianmdlvl / elogind.git / blobdiff