X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=udev%2Fudev-rules.c;h=df9fc7877da2c2d7bfa46f0ebb81e5a7b9d0f5da;hp=df5ed5360e377caa7fd0fcd1bd6cce27eb2c1b75;hb=949075dbbdbc2a10b38e5022a4f51d39e391deca;hpb=1449a55ded1e54ed8cb81c17296344d5905ea9d6

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index df5ed5360..df9fc7877 100644
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,14 +42,16 @@ struct uid_gid {
 	};
 };
 
-#define TRIE_CHILD_MAX 10
-
 struct trie_node {
+	/* this node's first child */
+	unsigned int child_idx;
+	/* the next child of our parent node's child list */
+	unsigned int next_child_idx;
+	/* this node's last child (shortcut for append) */
+	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;
+	unsigned char key;
 };
 
 struct udev_rules {
@@ -66,13 +69,12 @@ 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 */
+	struct trie_node *trie_nodes;
+	unsigned int trie_nodes_cur;
+	unsigned int trie_nodes_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,117 +440,90 @@ 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;
-	int depth;
+	unsigned short len;
+	unsigned int depth;
 	unsigned int off;
+	struct trie_node *parent;
 
+	/* walk trie, start from last character of str to find matching tails */
 	len = strlen(str);
+	key = str[len-1];
+	node_idx = 0;
+	for (depth = 0; depth <= len; depth++) {
+		struct trie_node *node;
+		unsigned int child_idx;
 
-	/* offset 0 is always '\0' */
-	if (len == 0)
-		return 0;
+		node = &rules->trie_nodes[node_idx];
+		off = node->value_off + node->value_len - len;
 
-	/* 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];
-	depth = 0;
-
-	/* descend suffix trie */
-	if (node_off != 0) {
-		while (1) {
-			struct trie_node *node = &rules->trie[node_off];
-			unsigned char child_slot;
-
-			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))
-			{
-				return off;
-			}
+		/* match against current node */
+		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);
+		/* lookup child node */
+		key = str[len - 1 - depth];
+		child_idx = node->child_idx;
+		while (child_idx > 0) {
+			struct trie_node *child;
 
-			if(child_slot == node->child_cur)
+			child = &rules->trie_nodes[child_idx];
+			if (child->key == key)
 				break;
-
-			node_off = node->child[child_slot];
+			child_idx = child->next_child_idx;
 		}
+		if (child_idx == 0)
+			break;
+		node_idx = child_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;
+	/* get a new node */
+	new_node_idx = rules->trie_nodes_cur;
+	rules->trie_nodes_cur++;
+	new_node = &rules->trie_nodes[new_node_idx];
+	memset(new_node, 0x00, sizeof(struct trie_node));
+	new_node->value_off = off;
+	new_node->value_len = len;
+	new_node->key = key;
+
+	/* join the parent's child list */
+	parent = &rules->trie_nodes[node_idx];
+	if (parent->child_idx == 0) {
+		parent->child_idx = new_node_idx;
 	} else {
-		struct trie_node *parent = &rules->trie[node_off];
-		unsigned char child_slot = parent->child_cur;
-
-		/* no space in parent, we can't index this string, nevermind */
-		if (child_slot == TRIE_CHILD_MAX)
-			return off;
+		struct trie_node *last_child;
 
-		parent->child[child_slot] = child_off;
-		parent->child_key[child_slot] = key;
-		parent->child_cur = child_slot + 1;
+		last_child = &rules->trie_nodes[parent->last_child_idx];
+		last_child->next_child_idx = new_node_idx;
 	}
-
-	/* 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;
-
+	parent->last_child_idx = new_node_idx;
 	return off;
 }
 
@@ -1728,23 +1703,25 @@ 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 the trie root, with an empty string */
+	memset(rules->trie_nodes, 0x00, sizeof(struct trie_node));
+	rules->trie_nodes_cur = 1;
+
 	if (udev_get_rules_path(udev) != NULL) {
 		/* custom rules location for testing */
 		add_matching_files(udev, &file_list, udev_get_rules_path(udev), ".rules");
@@ -1855,18 +1832,17 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 			rules->buf_max = rules->buf_cur;
 		}
 	}
-	info(udev, "shrunk to %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n",
+	info(udev, "rules use %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, "temporary index used %zu bytes (%u * %zu bytes)\n",
+	     rules->trie_nodes_cur * sizeof(struct trie_node),
+	     rules->trie_nodes_cur, sizeof(struct trie_node));
 
 	/* cleanup trie */
-	free(rules->trie);
-	rules->trie = NULL;
-	rules->trie_cur = 0;
-	rules->trie_max = 0;
-	free(rules->trie_root);
-	rules->trie_root = NULL;
+	free(rules->trie_nodes);
+	rules->trie_nodes = NULL;
+	rules->trie_nodes_cur = 0;
+	rules->trie_nodes_max = 0;
 
 	/* cleanup uid/gid cache */
 	free(rules->uids);
@@ -1888,8 +1864,7 @@ void udev_rules_unref(struct udev_rules *rules)
 		return;
 	free(rules->tokens);
 	free(rules->buf);
-	free(rules->trie);
-	free(rules->trie_root);
+	free(rules->trie_nodes);
 	free(rules->uids);
 	free(rules->gids);
 	free(rules);