AuxXxilium/eudev
1
0
Fork 0
mirror of https://github.com/AuxXxilium/eudev.git synced 2024-11-24 07:20:56 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

[PATCH] rename namedev_dev to udev_rule

Browse Source
This commit is contained in:
kay.sievers@vrfy.org 2005-03-12 22:36:32 +01:00 committed by Greg KH
parent e6764498e7
commit e5e322bc62
12 changed files with 149 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile
View File

@ -117,7 +117,7 @@ CFLAGS := -pipe
HEADERS = \
udev.h \
udev_utils.h \
namedev.h \
udev_rules.h \
udev_version.h \
udev_db.h \
udev_sysfs.h \
@ -142,8 +142,8 @@ UDEV_OBJS = \
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 = \

2
README
View File

@ -65,7 +65,7 @@ To use:
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.

10
logging.h
View File

@ -26,7 +26,6 @@
#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)
@ -49,15 +48,6 @@
} 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)));

4
udev.c
View File

@ -37,7 +37,7 @@
#include "udev_utils.h"
#include "udev_sysfs.h"
#include "udev_version.h"
#include "namedev.h"
#include "udev_rules.h"
#include "logging.h"
@ -177,7 +177,7 @@ int main(int argc, char *argv[], char *envp[])
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);

4
udev_add.c
View File

@ -42,7 +42,7 @@
#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"
@ -276,7 +276,7 @@ int udev_add_device(struct udevice *udev, struct sysfs_class_device *class_dev)
}
}
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);

9
udev_config.c
View File

@ -21,9 +21,6 @@
*
*/
/* define this to enable parsing debugging */
/* #define DEBUG_PARSER */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
@ -38,7 +35,7 @@
#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];
@ -134,14 +131,14 @@ static int parse_config_file(void)
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));

1
udev_remove.c
View File

@ -34,7 +34,6 @@
#include "udev.h"
#include "udev_utils.h"
#include "udev_version.h"
#include "namedev.h"
#include "udev_db.h"
#include "logging.h"

116
namedev.c → udev_rules.c
View File

@ -1,5 +1,5 @@
/*
* namedev.c
* udev_rules.c
*
* Userspace devfs
*
@ -40,7 +40,7 @@
#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);
@ -498,13 +498,13 @@ static int compare_sysfs_attribute(struct sysfs_class_device *class_dev, struct
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) {
@ -516,7 +516,7 @@ static int match_sysfs_pairs(struct config_device *dev, struct sysfs_class_devic
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;
@ -524,30 +524,30 @@ static int match_id(struct config_device *dev, struct sysfs_device *sysfs_device
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;
}
@ -557,14 +557,14 @@ static int match_rule(struct udevice *udev, struct config_device *dev,
/* 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;
}
@ -572,14 +572,14 @@ static int match_rule(struct udevice *udev, struct config_device *dev,
}
/* 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;
}
@ -587,13 +587,13 @@ static int match_rule(struct udevice *udev, struct config_device *dev,
}
/* 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;
}
@ -601,9 +601,9 @@ static int match_rule(struct udevice *udev, struct config_device *dev,
}
/* 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;
}
@ -622,11 +622,11 @@ 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");
@ -636,10 +636,10 @@ try_parent:
}
/* 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;
}
@ -653,11 +653,11 @@ exit:
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);
@ -683,50 +683,50 @@ int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_d
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 */
@ -744,14 +744,14 @@ int namedev_name_device(struct udevice *udev, struct sysfs_class_device *class_d
}
/* 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",

18
namedev.h → udev_rules.h
View File

@ -1,5 +1,5 @@
/*
* namedev.h
* udev_rules.h
*
* Userspace devfs
*
@ -23,10 +23,10 @@
#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"
@ -56,7 +56,7 @@ struct sysfs_pair {
char value[VALUE_SIZE];
};
struct config_device {
struct udev_rule {
struct list_head node;
char kernel[NAME_SIZE];
@ -82,13 +82,13 @@ struct config_device {
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

138
namedev_parse.c → udev_rules_parse.c
View File

@ -1,5 +1,5 @@
/*
* namedev_parse.c
* udev_rules_parse.c
*
* Userspace devfs
*
@ -22,11 +22,6 @@
*
*/
#ifdef DEBUG
/* define this to enable parsing debugging also */
/* #define DEBUG_PARSER */
#endif
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
@ -40,41 +35,42 @@
#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} */
@ -99,7 +95,7 @@ static char *get_key_attribute(char *str)
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;
@ -115,7 +111,7 @@ static int namedev_parse(struct udevice *udev, const char *filename)
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);
@ -160,10 +156,10 @@ static int namedev_parse(struct udevice *udev, const char *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;
@ -173,31 +169,31 @@ static int namedev_parse(struct udevice *udev, const char *filename)
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 */
@ -223,20 +219,20 @@ static int namedev_parse(struct udevice *udev, const char *filename)
}
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;
}
@ -246,58 +242,58 @@ static int namedev_parse(struct udevice *udev, const char *filename)
/* 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;
@ -312,21 +308,21 @@ static int namedev_parse(struct udevice *udev, const char *filename)
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;
@ -340,7 +336,7 @@ error:
return retval;
}
int namedev_init(void)
int udev_rules_init(void)
{
struct stat stats;
int retval;
@ -349,21 +345,21 @@ int namedev_init(void)
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);
}
}

4
udevstart.c
View File

@ -39,7 +39,7 @@
#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"
@ -317,7 +317,7 @@ int main(int argc, char *argv[], char *envp[])
setenv("ACTION", "add", 1);
setenv("UDEV_START", "1", 1);
namedev_init();
udev_rules_init();
udev_scan_block();
udev_scan_class();

4
udevtest.c
View File

@ -32,7 +32,7 @@
#include "udev_sysfs.h"
#include "udev_utils.h"
#include "udev_version.h"
#include "namedev.h"
#include "udev_rules.h"
#include "logging.h"
@ -83,7 +83,7 @@ int main(int argc, char *argv[], char *envp[])
info("looking at '%s'", devpath);
/* initialize the naming deamon */
namedev_init();
udev_rules_init();
if (argc == 3)
subsystem = argv[2];