string index - split nodes and childs to allow and unlimited number of childs

diff --git a/test/udev-test.pl b/test/udev-test.pl
index 95f9af0e2b86e151722d28cdcfdd6a8aadbe77cc..61e91c48b66e9ec5381ea72b87cee7beb5bfd900 100755 (executable)
--- a/test/udev-test.pl
+++ b/test/udev-test.pl
@@ -30,6 +30,14 @@ my $udev_conf                = "udev-test.conf";
 my $udev_rules         = "udev-test.rules";
 
 my @tests = (
+       {
+               desc            => "no rules",
+               subsys          => "block",
+               devpath         => "/devices/pci0000:00/0000:00:1f.2/host0/target0:0:0/0:0:0:0/block/sda",
+               exp_name        => "sda" ,
+               rules           => <<EOF
+EOF
+       },
        {
                desc            => "label test of scsi disc (old key names)",
                subsys          => "block",

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index dc4009f74aefeb29a2bfa1bb4896c5c130ba720a..efd8310cd0896bfa63265a3fdf657e7255bbe072 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -41,14 +41,17 @@ struct uid_gid {
        };
 };
 
-#define TRIE_CHILD_MAX 10
+struct trie_child {
+       unsigned int next_idx;
+       unsigned int node_idx;
+       unsigned char key;
+};
 
 struct trie_node {
+       unsigned int child_idx;
+       unsigned int last_child_idx;
        unsigned int value_off;
-       size_t value_len;
-       unsigned char child_cur;
-       unsigned char child_key[TRIE_CHILD_MAX];
-       unsigned short child[TRIE_CHILD_MAX];
+       unsigned short value_len;
 };
 
 struct udev_rules {
@@ -66,13 +69,16 @@ struct udev_rules {
        size_t buf_max;
        unsigned int buf_count;
 
-       /* key strings are indexed to avoid wasting space with duplicates */
-       struct trie_node *trie;
-       unsigned short trie_cur;
-       unsigned short trie_max;
-       unsigned short *trie_root;
+       /* during rule parsing, strings are indexed to find duplicates */
+       unsigned int *trie_root;
+       struct trie_node *trie_nodes;
+       unsigned int trie_nodes_cur;
+       unsigned int trie_nodes_max;
+       struct trie_child *trie_childs;
+       unsigned int trie_childs_cur;
+       unsigned int trie_childs_max;
 
-       /* during rule parsing, we cache uid/gid lookup results */
+       /* during rule parsing, uid/gid lookup results are cached */
        struct uid_gid *uids;
        unsigned int uids_cur;
        unsigned int uids_max;
@@ -438,25 +444,13 @@ static int add_new_string(struct udev_rules *rules, const char *str, size_t byte
        return off;
 }
 
-static unsigned char trie_child_slot(struct trie_node *node, char key)
-{
-       unsigned char child_slot;
-
-       for (child_slot = 0; child_slot < node->child_cur; child_slot++) {
-               if (node->child_key[child_slot] == key)
-                       break;
-       }
-
-       return child_slot;
-}
-
 static int add_string(struct udev_rules *rules, const char *str)
 {
-       struct trie_node *child;
-       unsigned short child_off;
-       unsigned short node_off;
+       unsigned int node_idx;
+       struct trie_node *new_node;
+       unsigned int new_node_idx;
        unsigned char key;
-       size_t len;
+       unsigned short len;
        unsigned int depth;
        unsigned int off;
 
@@ -466,89 +460,118 @@ static int add_string(struct udev_rules *rules, const char *str)
        if (len == 0)
                return 0;
 
-       /* strings with spaces are probably commands e.g. modprobe,
-          with unique arguments. */
-       if (strchr(str, ' ') != NULL)
-               return add_new_string(rules, str, len + 1);
-
        /* descend root - start from last character of str */
        key = str[len - 1];
-       node_off = rules->trie_root[key];
+       node_idx = rules->trie_root[key];
        depth = 0;
 
        /* descend suffix trie */
-       if (node_off != 0) {
+       if (node_idx > 0) {
                while (1) {
-                       struct trie_node *node = &rules->trie[node_off];
-                       unsigned char child_slot;
+                       struct trie_node *node;
+                       unsigned int child_idx;
 
+                       node = &rules->trie_nodes[node_idx];
                        depth++;
                        off = node->value_off + node->value_len - len;
 
                        /* match against current node */
-                       if (depth == len ||
-                           (node->value_len >= len &&
-                           memcmp(&rules->buf[off], str, len) == 0))
-                       {
+                       if (depth == len || (node->value_len >= len && memcmp(&rules->buf[off], str, len) == 0))
                                return off;
-                       }
 
                        /* lookup child node */
                        key = str[len - 1 - depth];
-                       child_slot = trie_child_slot(node, key);
-
-                       if(child_slot == node->child_cur)
+                       child_idx = node->child_idx;
+                       while (child_idx > 0) {
+                               if (rules->trie_childs[child_idx].key == key)
+                                       break;
+                               child_idx = rules->trie_childs[child_idx].next_idx;
+                       }
+                       if (child_idx == 0)
                                break;
-
-                       node_off = node->child[child_slot];
+                       node_idx = rules->trie_childs[child_idx].node_idx;
                }
        }
 
        /* string not found, add it */
        off = add_new_string(rules, str, len + 1);
 
-       /* grow trie storage if needed */
-       if (rules->trie_cur >= rules->trie_max) {
-               struct trie_node *trie;
-               unsigned short add;
+       /* grow trie nodes if needed */
+       if (rules->trie_nodes_cur >= rules->trie_nodes_max) {
+               struct trie_node *nodes;
+               unsigned int add;
 
                /* double the buffer size */
-               add = rules->trie_max;
+               add = rules->trie_nodes_max;
                if (add < 8)
                        add = 8;
 
-               trie = realloc(rules->trie, (rules->trie_max + add) * sizeof(struct trie_node));
-               if (trie == NULL)
+               nodes = realloc(rules->trie_nodes, (rules->trie_nodes_max + add) * sizeof(struct trie_node));
+               if (nodes == NULL)
                        return -1;
-               dbg(rules->udev, "extend string index nodes from %u to %u\n", rules->trie_max, rules->trie_max + add);
-               rules->trie = trie;
-               rules->trie_max += add;
+               dbg(rules->udev, "extend trie nodes from %u to %u\n",
+                   rules->trie_nodes_max, rules->trie_nodes_max + add);
+               rules->trie_nodes = nodes;
+               rules->trie_nodes_max += add;
        }
 
-       /* insert new child node */
-       child_off = rules->trie_cur;
-       if (depth == 0) {
-               rules->trie_root[key] = child_off;
-       } else {
-               struct trie_node *parent = &rules->trie[node_off];
-               unsigned char child_slot = parent->child_cur;
+       /* grow trie childs if needed */
+       if (rules->trie_childs_cur >= rules->trie_childs_max) {
+               struct trie_child *childs;
+               unsigned int add;
 
-               /* no space in parent, we can't index this string, nevermind */
-               if (child_slot == TRIE_CHILD_MAX)
-                       return off;
+               /* double the buffer size */
+               add = rules->trie_childs_max;
+               if (add < 8)
+                       add = 8;
 
-               parent->child[child_slot] = child_off;
-               parent->child_key[child_slot] = key;
-               parent->child_cur = child_slot + 1;
+               childs = realloc(rules->trie_childs, (rules->trie_childs_max + add) * sizeof(struct trie_child));
+               if (childs == NULL)
+                       return -1;
+               dbg(rules->udev, "extend trie childs from %u to %u\n",
+                   rules->trie_childs_max, rules->trie_childs_max + add);
+               rules->trie_childs = childs;
+               rules->trie_childs_max += add;
        }
 
-       /* allocate and construct the child node */
-       rules->trie_cur++;
-       child = &rules->trie[child_off];
-       memset(child, 0x00, sizeof(struct trie_node));
-       child->value_off = off;
-       child->value_len = len;
+       /* get new node */
+       new_node_idx = rules->trie_nodes_cur;
+       rules->trie_nodes_cur++;
+       new_node = &rules->trie_nodes[new_node_idx];
+       new_node->value_off = off;
+       new_node->value_len = len;
+       new_node->child_idx = 0;
+       new_node->last_child_idx = 0;
 
+       if (depth == 0) {
+               /* add node to root */
+               rules->trie_root[key] = new_node_idx;
+       } else {
+               /* add node to parent */
+               struct trie_node *parent;
+               struct trie_child *new_child;
+               unsigned int new_child_idx;
+
+               /* get new child link for list of childs of parent */
+               new_child_idx = rules->trie_childs_cur;
+               rules->trie_childs_cur++;
+               new_child = &rules->trie_childs[new_child_idx];
+               new_child->next_idx = 0;
+               new_child->node_idx = new_node_idx;
+               new_child->key = key;
+
+               /* append child link to list of childs of parent */
+               parent = &rules->trie_nodes[node_idx];
+               if (parent->child_idx == 0) {
+                       parent->child_idx = new_child_idx;
+               } else {
+                       struct trie_child *last_child;
+
+                       last_child = &rules->trie_childs[parent->last_child_idx];
+                       last_child->next_idx = new_child_idx;
+               }
+               parent->last_child_idx = new_child_idx;
+       }
        return off;
 }
 
@@ -1728,23 +1751,31 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
        if (rules->tokens == NULL)
                return NULL;
        rules->token_max = PREALLOC_TOKEN;
+
        rules->buf = malloc(PREALLOC_STRBUF);
        if (rules->buf == NULL)
                return NULL;
        rules->buf_max = PREALLOC_STRBUF;
-       rules->trie = malloc(PREALLOC_TRIE * sizeof(struct trie_node));
-       if (rules->trie == NULL)
-               return NULL;
-       rules->trie_max = PREALLOC_TRIE;
-       rules->trie_root = calloc(UCHAR_MAX + 1, sizeof(unsigned short));
        /* offset 0 is always '\0' */
        rules->buf[0] = '\0';
        rules->buf_cur = 1;
-       /* offset 0 is reserved for the null trie node */
-       rules->trie_cur = 1;
        dbg(udev, "prealloc %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n",
            rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max);
 
+       rules->trie_nodes = malloc(PREALLOC_TRIE * sizeof(struct trie_node));
+       if (rules->trie_nodes == NULL)
+               return NULL;
+       rules->trie_nodes_max = PREALLOC_TRIE;
+       /* offset 0 is reserved for the null trie node */
+       rules->trie_nodes_cur = 1;
+
+       rules->trie_childs = malloc(PREALLOC_TRIE * sizeof(struct trie_child));
+       if (rules->trie_childs == NULL)
+               return NULL;
+       rules->trie_childs_max = PREALLOC_TRIE;
+
+       rules->trie_root = calloc(UCHAR_MAX + 1, sizeof(unsigned short));
+
        if (udev_get_rules_path(udev) != NULL) {
                /* custom rules location for testing */
                add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules");
@@ -1857,14 +1888,20 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
        }
        info(udev, "shrunk to %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n",
             rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max);
-       info(udev, "used %zu bytes of string index nodes (%hu * %zu bytes)\n",
-            rules->trie_cur * sizeof(struct trie_node), rules->trie_cur, sizeof(struct trie_node));
+       info(udev, "used %zu bytes for index (%u * %zu bytes nodes, %u * %zu bytes child links)\n",
+            rules->trie_nodes_cur * sizeof(struct trie_node) + rules->trie_childs_cur * sizeof(struct trie_child),
+            rules->trie_nodes_cur, sizeof(struct trie_node),
+            rules->trie_childs_cur, sizeof(struct trie_child));
 
        /* cleanup trie */
-       free(rules->trie);
-       rules->trie = NULL;
-       rules->trie_cur = 0;
-       rules->trie_max = 0;
+       free(rules->trie_nodes);
+       rules->trie_nodes = NULL;
+       rules->trie_nodes_cur = 0;
+       rules->trie_nodes_max = 0;
+       free(rules->trie_childs);
+       rules->trie_childs = NULL;
+       rules->trie_childs_cur = 0;
+       rules->trie_childs_max = 0;
        free(rules->trie_root);
        rules->trie_root = NULL;
 
@@ -1888,7 +1925,8 @@ void udev_rules_unref(struct udev_rules *rules)
                return;
        free(rules->tokens);
        free(rules->buf);
-       free(rules->trie);
+       free(rules->trie_nodes);
+       free(rules->trie_childs);
        free(rules->trie_root);
        free(rules->uids);
        free(rules->gids);