HEADERS = \
udev.h \
udev_utils.h \
- namedev.h \
+ udev_rules.h \
udev_version.h \
udev_db.h \
udev_sysfs.h \
udev_sysfs.o \
udev_db.o \
udev_multiplex.o \
- namedev.o \
- namedev_parse.o \
+ udev_rules.o \
+ udev_rules_parse.o \
udev_libc_wrapper.o
OBJS = \
This will put the udev binary in /sbin, create the /udev and /etc/udev
directories, and place the udev configuration files in /etc/udev. You
- will probably want to edit the namedev.* files to create custom naming
+ will probably want to edit the *.rules files to create custom naming
rules. More info on how the config files are set up are contained in
comments in the files, and is located in the documentation.
#define info(format, arg...) do { } while (0)
#define dbg(format, arg...) do { } while (0)
-#define dbg_parse(format, arg...) do { } while (0)
#define logging_init(foo) do { } while (0)
#define logging_close(foo) do { } while (0)
} while (0)
#endif
-/* Parser needs it's own debugging statement, we usually don't care about this at all */
-#ifdef DEBUG_PARSER
-#undef dbg_parse
-#define dbg_parse(format, arg...) \
- do { \
- log_message(LOG_DEBUG , "%s: " format , __FUNCTION__ , ## arg); \
- } while (0)
-#endif
-
extern void log_message(int level, const char *format, ...)
__attribute__ ((format (printf, 2, 3)));
#include "udev_utils.h"
#include "udev_sysfs.h"
#include "udev_version.h"
-#include "namedev.h"
+#include "udev_rules.h"
#include "logging.h"
wait_for_class_device(class_dev, &error);
/* init rules */
- namedev_init();
+ udev_rules_init();
/* name, create node, store in db */
retval = udev_add_device(&udev, class_dev);
#include "udev_sysfs.h"
#include "udev_version.h"
#include "logging.h"
-#include "namedev.h"
+#include "udev_rules.h"
#include "udev_db.h"
#include "udev_selinux.h"
}
}
- if (namedev_name_device(udev, class_dev) != 0)
+ if (udev_rules_get_name(udev, class_dev) != 0)
return 0;
dbg("adding name='%s'", udev->name);
*
*/
-/* define this to enable parsing debugging */
-/* #define DEBUG_PARSER */
-
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "udev_utils.h"
#include "udev_version.h"
#include "logging.h"
-#include "namedev.h"
+#include "udev_rules.h"
/* global variables */
char sysfs_path[PATH_SIZE];
strlcpy(line, bufline, count);
temp = line;
- dbg_parse("read '%s'", temp);
+ dbg("read '%s'", temp);
retval = parse_get_pair(&temp, &variable, &value);
if (retval != 0)
info("%s:%d:%Zd: error parsing '%s'",
udev_config_filename, lineno, temp-line, temp);
- dbg_parse("variable='%s', value='%s'", variable, value);
+ dbg("variable='%s', value='%s'", variable, value);
if (strcasecmp(variable, "udev_root") == 0) {
strlcpy(udev_root, value, sizeof(udev_root));
#include "udev.h"
#include "udev_utils.h"
#include "udev_version.h"
-#include "namedev.h"
#include "udev_db.h"
#include "logging.h"
/*
- * namedev.c
+ * udev_rules.c
*
* Userspace devfs
*
#include "udev_utils.h"
#include "udev_version.h"
#include "logging.h"
-#include "namedev.h"
+#include "udev_rules.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);
return 0;
}
-static int match_sysfs_pairs(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
+static int match_sysfs_pairs(struct udev_rule *rule, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
{
struct sysfs_pair *pair;
int i;
for (i = 0; i < MAX_SYSFS_PAIRS; ++i) {
- pair = &dev->sysfs_pair[i];
+ pair = &rule->sysfs_pair[i];
if ((pair->file[0] == '\0') || (pair->value[0] == '\0'))
break;
if (compare_sysfs_attribute(class_dev, sysfs_device, pair) != 0) {
return 0;
}
-static int match_id(struct config_device *dev, struct sysfs_device *sysfs_device)
+static int match_id(struct udev_rule *rule, struct sysfs_device *sysfs_device)
{
char path[PATH_SIZE];
char *temp;
strlcpy(path, sysfs_device->path, sizeof(path));
temp = strrchr(path, '/');
temp++;
- dbg("search '%s' in '%s', path='%s'", dev->id, temp, path);
- if (strcmp_pattern(dev->id, temp) != 0)
+ dbg("search '%s' in '%s', path='%s'", rule->id, temp, path);
+ if (strcmp_pattern(rule->id, temp) != 0)
return -ENODEV;
return 0;
}
-static int match_rule(struct udevice *udev, struct config_device *dev,
+static int match_rule(struct udevice *udev, struct udev_rule *rule,
struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device)
{
- 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) {
+ if (rule->kernel[0] != '\0') {
+ dbg("check for " FIELD_KERNEL " rule->kernel='%s' class_dev->name='%s'",
+ rule->kernel, class_dev->name);
+ if (strcmp_pattern(rule->kernel, class_dev->name) != 0) {
dbg(FIELD_KERNEL " is not matching");
goto exit;
}
dbg(FIELD_KERNEL " matches");
}
- 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) {
+ if (rule->subsystem[0] != '\0') {
+ dbg("check for " FIELD_SUBSYSTEM " rule->subsystem='%s' class_dev->name='%s'",
+ rule->subsystem, class_dev->name);
+ if (strcmp_pattern(rule->subsystem, udev->subsystem) != 0) {
dbg(FIELD_SUBSYSTEM " is not matching");
goto exit;
}
/* walk up the chain of physical devices and find a match */
while (1) {
/* check for matching driver */
- if (dev->driver[0] != '\0') {
+ if (rule->driver[0] != '\0') {
if (sysfs_device == NULL) {
dbg("device has no sysfs_device");
goto try_parent;
}
- 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("check for " FIELD_DRIVER " rule->driver='%s' sysfs_device->driver_name='%s'",
+ rule->driver, sysfs_device->driver_name);
+ if (strcmp_pattern(rule->driver, sysfs_device->driver_name) != 0) {
dbg(FIELD_DRIVER " is not matching");
goto try_parent;
}
}
/* check for matching bus value */
- if (dev->bus[0] != '\0') {
+ if (rule->bus[0] != '\0') {
if (sysfs_device == NULL) {
dbg("device has no sysfs_device");
goto try_parent;
}
- 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("check for " FIELD_BUS " rule->bus='%s' sysfs_device->bus='%s'",
+ rule->bus, sysfs_device->bus);
+ if (strcmp_pattern(rule->bus, sysfs_device->bus) != 0) {
dbg(FIELD_BUS " is not matching");
goto try_parent;
}
}
/* check for matching bus id */
- if (dev->id[0] != '\0') {
+ if (rule->id[0] != '\0') {
if (sysfs_device == NULL) {
dbg("device has no sysfs_device");
goto try_parent;
}
dbg("check " FIELD_ID);
- if (match_id(dev, sysfs_device) != 0) {
+ if (match_id(rule, sysfs_device) != 0) {
dbg(FIELD_ID " is not matching");
goto try_parent;
}
}
/* check for matching sysfs pairs */
- if (dev->sysfs_pair[0].file[0] != '\0') {
+ if (rule->sysfs_pair[0].file[0] != '\0') {
dbg("check " FIELD_SYSFS " pairs");
- if (match_sysfs_pairs(dev, class_dev, sysfs_device) != 0) {
+ if (match_sysfs_pairs(rule, class_dev, sysfs_device) != 0) {
dbg(FIELD_SYSFS " is not matching");
goto try_parent;
}
}
/* execute external program */
- if (dev->program[0] != '\0') {
+ if (rule->program[0] != '\0') {
char program[PATH_SIZE];
dbg("check " FIELD_PROGRAM);
- strlcpy(program, dev->program, sizeof(program));
+ strlcpy(program, rule->program, sizeof(program));
apply_format(udev, program, sizeof(program), class_dev, sysfs_device);
if (execute_program(udev, program, udev->program_result, sizeof(udev->program_result)) != 0) {
dbg(FIELD_PROGRAM " returned nonzero");
}
/* 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) {
+ if (rule->result[0] != '\0') {
+ dbg("check for " FIELD_RESULT "rule->result='%s', udev->program_result='%s'",
+ rule->result, udev->program_result);
+ if (strcmp_pattern(rule->result, udev->program_result) != 0) {
dbg(FIELD_RESULT " is not matching");
goto try_parent;
}
return -1;
}
-int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_dev)
+int udev_rules_get_name(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 udev_rule *rule;
dbg("class_dev->name='%s'", class_dev->name);
dbg("udev->kernel_name='%s'", udev->kernel_name);
/* look for a matching rule to apply */
- list_for_each_entry(dev, &config_device_list, node) {
+ list_for_each_entry(rule, &udev_rule_list, node) {
dbg("process rule");
- if (match_rule(udev, dev, class_dev, sysfs_device) == 0) {
+ if (match_rule(udev, rule, class_dev, sysfs_device) == 0) {
/* apply options */
- if (dev->ignore_device) {
+ if (rule->ignore_device) {
info("configured rule in '%s[%i]' applied, '%s' is ignored",
- dev->config_file, dev->config_line, udev->kernel_name);
+ rule->config_file, rule->config_line, udev->kernel_name);
return -1;
}
- if (dev->ignore_remove) {
+ if (rule->ignore_remove) {
udev->ignore_remove = 1;
- dbg_parse("remove event should be ignored");
+ dbg("remove event should be ignored");
}
/* apply all_partitions option only at a main block device */
- if (dev->partitions && udev->type == DEV_BLOCK && udev->kernel_number[0] == '\0') {
- udev->partitions = dev->partitions;
+ if (rule->partitions && udev->type == DEV_BLOCK && udev->kernel_number[0] == '\0') {
+ udev->partitions = rule->partitions;
dbg("creation of partition nodes requested");
}
/* apply permissions */
- if (dev->mode != 0000) {
- udev->mode = dev->mode;
+ if (rule->mode != 0000) {
+ udev->mode = rule->mode;
dbg("applied mode=%#o to '%s'", udev->mode, udev->kernel_name);
}
- if (dev->owner[0] != '\0') {
- strlcpy(udev->owner, dev->owner, sizeof(udev->owner));
+ if (rule->owner[0] != '\0') {
+ strlcpy(udev->owner, rule->owner, sizeof(udev->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') {
- strlcpy(udev->group, dev->group, sizeof(udev->group));
+ if (rule->group[0] != '\0') {
+ strlcpy(udev->group, rule->group, sizeof(udev->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') {
+ if (rule->symlink[0] != '\0') {
char temp[PATH_SIZE];
char *pos, *next;
info("configured rule in '%s[%i]' applied, added symlink '%s'",
- dev->config_file, dev->config_line, dev->symlink);
- strlcpy(temp, dev->symlink, sizeof(temp));
+ rule->config_file, rule->config_line, rule->symlink);
+ strlcpy(temp, rule->symlink, sizeof(temp));
apply_format(udev, temp, sizeof(temp), class_dev, sysfs_device);
/* add multiple symlinks separated by spaces */
}
/* rule matches */
- if (dev->name[0] != '\0') {
+ if (rule->name[0] != '\0') {
info("configured rule in '%s[%i]' applied, '%s' becomes '%s'",
- dev->config_file, dev->config_line, udev->kernel_name, dev->name);
+ rule->config_file, rule->config_line, udev->kernel_name, rule->name);
- strlcpy(udev->name, dev->name, sizeof(udev->name));
+ strlcpy(udev->name, rule->name, sizeof(udev->name));
apply_format(udev, udev->name, sizeof(udev->name), class_dev, sysfs_device);
- strlcpy(udev->config_file, dev->config_file, sizeof(udev->config_file));
- udev->config_line = dev->config_line;
+ strlcpy(udev->config_file, rule->config_file, sizeof(udev->config_file));
+ udev->config_line = rule->config_line;
if (udev->type != DEV_NET)
dbg("name, '%s' is going to have owner='%s', group='%s', mode=%#o partitions=%i",
/*
- * namedev.h
+ * udev_rules.h
*
* Userspace devfs
*
#ifndef NAMEDEV_H
#define NAMEDEV_H
+#include "libsysfs/sysfs/libsysfs.h"
#include "udev.h"
#include "list.h"
-struct sysfs_class_device;
#define FIELD_KERNEL "KERNEL"
#define FIELD_SUBSYSTEM "SUBSYSTEM"
char value[VALUE_SIZE];
};
-struct config_device {
+struct udev_rule {
struct list_head node;
char kernel[NAME_SIZE];
int config_line;
};
-extern struct list_head config_device_list;
+extern struct list_head udev_rule_list;
-extern int namedev_init(void);
-extern int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_dev);
-extern void namedev_close(void);
+extern int udev_rules_init(void);
+extern int udev_rules_get_name(struct udevice *udev, struct sysfs_class_device *class_dev);
+extern void udev_rules_close(void);
-extern void dump_config_dev(struct config_device *dev);
-extern void dump_config_dev_list(void);
+extern void udev_rule_dump(struct udev_rule *rule);
+extern void udev_rule_list_dump(void);
#endif
/*
- * namedev_parse.c
+ * udev_rules_parse.c
*
* Userspace devfs
*
*
*/
-#ifdef DEBUG
-/* define this to enable parsing debugging also */
-/* #define DEBUG_PARSER */
-#endif
-
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "udev.h"
#include "udev_utils.h"
#include "logging.h"
-#include "namedev.h"
+#include "udev_rules.h"
-LIST_HEAD(config_device_list);
+LIST_HEAD(udev_rule_list);
-static int add_config_dev(struct config_device *new_dev)
+static int add_config_dev(struct udev_rule *new_rule)
{
- struct config_device *tmp_dev;
+ struct udev_rule *tmp_rule;
- tmp_dev = malloc(sizeof(*tmp_dev));
- if (tmp_dev == NULL)
+ tmp_rule = malloc(sizeof(*tmp_rule));
+ if (tmp_rule == NULL)
return -ENOMEM;
- memcpy(tmp_dev, new_dev, sizeof(*tmp_dev));
- list_add_tail(&tmp_dev->node, &config_device_list);
- //dump_config_dev(tmp_dev);
+ memcpy(tmp_rule, new_rule, sizeof(*tmp_rule));
+ list_add_tail(&tmp_rule->node, &udev_rule_list);
+ udev_rule_dump(tmp_rule);
+
return 0;
}
-void dump_config_dev(struct config_device *dev)
+void udev_rule_dump(struct udev_rule *rule)
{
- dbg_parse("name='%s', symlink='%s', bus='%s', id='%s', "
- "sysfs_file[0]='%s', sysfs_value[0]='%s', "
- "kernel='%s', program='%s', result='%s'"
- "owner='%s', group='%s', mode=%#o",
- dev->name, dev->symlink, dev->bus, dev->id,
- dev->sysfs_pair[0].file, dev->sysfs_pair[0].value,
- dev->kernel, dev->program, dev->result,
- dev->owner, dev->group, dev->mode);
+ dbg("name='%s', symlink='%s', bus='%s', id='%s', "
+ "sysfs_file[0]='%s', sysfs_value[0]='%s', "
+ "kernel='%s', program='%s', result='%s'"
+ "owner='%s', group='%s', mode=%#o",
+ rule->name, rule->symlink, rule->bus, rule->id,
+ rule->sysfs_pair[0].file, rule->sysfs_pair[0].value,
+ rule->kernel, rule->program, rule->result,
+ rule->owner, rule->group, rule->mode);
}
-void dump_config_dev_list(void)
+void udev_rule_list_dump(void)
{
- struct config_device *dev;
+ struct udev_rule *rule;
- list_for_each_entry(dev, &config_device_list, node)
- dump_config_dev(dev);
+ list_for_each_entry(rule, &udev_rule_list, node)
+ udev_rule_dump(rule);
}
/* extract possible KEY{attr} */
return NULL;
}
-static int namedev_parse(struct udevice *udev, const char *filename)
+static int rules_parse(struct udevice *udev, const char *filename)
{
char line[LINE_SIZE];
char *bufline;
int program_given = 0;
int valid;
int retval = 0;
- struct config_device dev;
+ struct udev_rule rule;
if (file_map(filename, &buf, &bufsize) == 0) {
dbg("reading '%s' as rules file", filename);
line[j++] = bufline[i];
}
line[j] = '\0';
- dbg_parse("read '%s'", line);
+ dbg("read '%s'", line);
/* get all known keys */
- memset(&dev, 0x00, sizeof(struct config_device));
+ memset(&rule, 0x00, sizeof(struct udev_rule));
temp = line;
valid = 0;
break;
if (strcasecmp(temp2, FIELD_KERNEL) == 0) {
- strlcpy(dev.kernel, temp3, sizeof(dev.kernel));
+ strlcpy(rule.kernel, temp3, sizeof(rule.kernel));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_SUBSYSTEM) == 0) {
- strlcpy(dev.subsystem, temp3, sizeof(dev.subsystem));
+ strlcpy(rule.subsystem, temp3, sizeof(rule.subsystem));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_BUS) == 0) {
- strlcpy(dev.bus, temp3, sizeof(dev.bus));
+ strlcpy(rule.bus, temp3, sizeof(rule.bus));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_ID) == 0) {
- strlcpy(dev.id, temp3, sizeof(dev.id));
+ strlcpy(rule.id, temp3, sizeof(rule.id));
valid = 1;
continue;
}
if (strncasecmp(temp2, FIELD_SYSFS, sizeof(FIELD_SYSFS)-1) == 0) {
- struct sysfs_pair *pair = &dev.sysfs_pair[0];
+ struct sysfs_pair *pair = &rule.sysfs_pair[0];
int sysfs_pair_num = 0;
/* find first unused pair */
}
if (strcasecmp(temp2, FIELD_DRIVER) == 0) {
- strlcpy(dev.driver, temp3, sizeof(dev.driver));
+ strlcpy(rule.driver, temp3, sizeof(rule.driver));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_PROGRAM) == 0) {
program_given = 1;
- strlcpy(dev.program, temp3, sizeof(dev.program));
+ strlcpy(rule.program, temp3, sizeof(rule.program));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_RESULT) == 0) {
- strlcpy(dev.result, temp3, sizeof(dev.result));
+ strlcpy(rule.result, temp3, sizeof(rule.result));
valid = 1;
continue;
}
/* FIXME: remove old style options and make OPTIONS= mandatory */
if (attr != NULL) {
if (strstr(attr, OPTION_PARTITIONS) != NULL) {
- dbg_parse("creation of partition nodes requested");
- dev.partitions = DEFAULT_PARTITIONS_COUNT;
+ dbg("creation of partition nodes requested");
+ rule.partitions = DEFAULT_PARTITIONS_COUNT;
}
if (strstr(attr, OPTION_IGNORE_REMOVE) != NULL) {
- dbg_parse("remove event should be ignored");
- dev.ignore_remove = 1;
+ dbg("remove event should be ignored");
+ rule.ignore_remove = 1;
}
}
if (temp3[0] != '\0')
- strlcpy(dev.name, temp3, sizeof(dev.name));
+ strlcpy(rule.name, temp3, sizeof(rule.name));
else
- dev.ignore_device = 1;
+ rule.ignore_device = 1;
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_SYMLINK) == 0) {
- strlcpy(dev.symlink, temp3, sizeof(dev.symlink));
+ strlcpy(rule.symlink, temp3, sizeof(rule.symlink));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_OWNER) == 0) {
- strlcpy(dev.owner, temp3, sizeof(dev.owner));
+ strlcpy(rule.owner, temp3, sizeof(rule.owner));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_GROUP) == 0) {
- strlcpy(dev.group, temp3, sizeof(dev.group));
+ strlcpy(rule.group, temp3, sizeof(rule.group));
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_MODE) == 0) {
- dev.mode = strtol(temp3, NULL, 8);
+ rule.mode = strtol(temp3, NULL, 8);
valid = 1;
continue;
}
if (strcasecmp(temp2, FIELD_OPTIONS) == 0) {
if (strstr(temp3, OPTION_IGNORE_DEVICE) != NULL) {
- dbg_parse("device should be ignored");
- dev.ignore_device = 1;
+ dbg("device should be ignored");
+ rule.ignore_device = 1;
}
if (strstr(temp3, OPTION_IGNORE_REMOVE) != NULL) {
- dbg_parse("remove event should be ignored");
- dev.ignore_remove = 1;
+ dbg("remove event should be ignored");
+ rule.ignore_remove = 1;
}
if (strstr(temp3, OPTION_PARTITIONS) != NULL) {
- dbg_parse("creation of partition nodes requested");
- dev.partitions = DEFAULT_PARTITIONS_COUNT;
+ dbg("creation of partition nodes requested");
+ rule.partitions = DEFAULT_PARTITIONS_COUNT;
}
valid = 1;
continue;
goto error;
/* simple plausibility checks for given keys */
- if ((dev.sysfs_pair[0].file[0] == '\0') ^
- (dev.sysfs_pair[0].value[0] == '\0')) {
+ if ((rule.sysfs_pair[0].file[0] == '\0') ^
+ (rule.sysfs_pair[0].value[0] == '\0')) {
info("inconsistency in " FIELD_SYSFS " key");
goto error;
}
- if ((dev.result[0] != '\0') && (program_given == 0)) {
+ if ((rule.result[0] != '\0') && (program_given == 0)) {
info(FIELD_RESULT " is only useful when "
FIELD_PROGRAM " is called in any rule before");
goto error;
}
- dev.config_line = lineno;
- strlcpy(dev.config_file, filename, sizeof(dev.config_file));
- retval = add_config_dev(&dev);
+ rule.config_line = lineno;
+ strlcpy(rule.config_file, filename, sizeof(rule.config_file));
+ retval = add_config_dev(&rule);
if (retval) {
dbg("add_config_dev returned with error %d", retval);
continue;
return retval;
}
-int namedev_init(void)
+int udev_rules_init(void)
{
struct stat stats;
int retval;
return -1;
if ((stats.st_mode & S_IFMT) != S_IFDIR)
- retval = namedev_parse(NULL, udev_rules_filename);
+ retval = rules_parse(NULL, udev_rules_filename);
else
- retval = call_foreach_file(namedev_parse, NULL, udev_rules_filename, RULEFILE_SUFFIX);
+ retval = call_foreach_file(rules_parse, NULL, udev_rules_filename, RULEFILE_SUFFIX);
return retval;
}
-void namedev_close(void)
+void udev_rules_close(void)
{
- struct config_device *dev;
- struct config_device *temp_dev;
+ struct udev_rule *rule;
+ struct udev_rule *temp_rule;
- list_for_each_entry_safe(dev, temp_dev, &config_device_list, node) {
- list_del(&dev->node);
- free(dev);
+ list_for_each_entry_safe(rule, temp_rule, &udev_rule_list, node) {
+ list_del(&rule->node);
+ free(rule);
}
}
#include "udev_libc_wrapper.h"
#include "udev.h"
#include "logging.h"
-#include "namedev.h"
+#include "udev_rules.h"
#include "udev_utils.h"
#include "list.h"
setenv("ACTION", "add", 1);
setenv("UDEV_START", "1", 1);
- namedev_init();
+ udev_rules_init();
udev_scan_block();
udev_scan_class();
#include "udev_sysfs.h"
#include "udev_utils.h"
#include "udev_version.h"
-#include "namedev.h"
+#include "udev_rules.h"
#include "logging.h"
info("looking at '%s'", devpath);
/* initialize the naming deamon */
- namedev_init();
+ udev_rules_init();
if (argc == 3)
subsystem = argv[2];
~ianmdlvl / elogind.git / commitdiff