chiark / gitweb /
[PATCH] rename namedev_dev to udev_rule
authorkay.sievers@vrfy.org <kay.sievers@vrfy.org>
Sat, 12 Mar 2005 21:36:32 +0000 (22:36 +0100)
committerGreg KH <gregkh@suse.de>
Wed, 27 Apr 2005 06:53:17 +0000 (23:53 -0700)
12 files changed:
Makefile
README
logging.h
udev.c
udev_add.c
udev_config.c
udev_remove.c
udev_rules.c [moved from namedev.c with 85% similarity]
udev_rules.h [moved from namedev.h with 85% similarity]
udev_rules_parse.c [moved from namedev_parse.c with 66% similarity]
udevstart.c
udevtest.c

index 8e29f24..556298a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -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 = \
diff --git a/README b/README
index c0475dc..54cee65 100644 (file)
--- a/README
+++ b/README
@@ -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.
 
index 3ff54ec..e7653ee 100644 (file)
--- a/logging.h
+++ b/logging.h
@@ -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)
 
        } 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)));
 
diff --git a/udev.c b/udev.c
index 8ce813f..069cecf 100644 (file)
--- a/udev.c
+++ b/udev.c
@@ -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);
index bf5feb1..8443f65 100644 (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);
index 26ecf62..77ac38a 100644 (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));
index a81d20c..0a9996d 100644 (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"
 
similarity index 85%
rename from namedev.c
rename to udev_rules.c
index fd1cf04..cbdf7de 100644 (file)
--- a/namedev.c
@@ -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",
similarity index 85%
rename from namedev.h
rename to udev_rules.h
index d023599..71c510b 100644 (file)
--- a/namedev.h
@@ -1,5 +1,5 @@
 /*
- * 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"
@@ -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
similarity index 66%
rename from namedev_parse.c
rename to udev_rules_parse.c
index 3be4089..4f431de 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * 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} */
@@ -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);
        }
 }
 
index 7564c3d..7765661 100644 (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();
index 1e00379..006d555 100644 (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];