/*
* 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
};
};
-#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 {
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;
TK_A_IGNORE_DEVICE,
TK_A_STRING_ESCAPE_NONE,
TK_A_STRING_ESCAPE_REPLACE,
+ TK_A_INOTIFY_WATCH, /* int */
TK_A_NUM_FAKE_PART, /* int */
TK_A_DEVLINK_PRIO, /* int */
TK_A_OWNER, /* val */
union {
unsigned int attr_off;
int ignore_error;
- int i;
unsigned int rule_goto;
mode_t mode;
uid_t uid;
int num_fake_part;
int devlink_prio;
int event_timeout;
+ int watch;
};
} key;
};
[TK_A_IGNORE_DEVICE] = "A IGNORE_DEVICE",
[TK_A_STRING_ESCAPE_NONE] = "A STRING_ESCAPE_NONE",
[TK_A_STRING_ESCAPE_REPLACE] = "A STRING_ESCAPE_REPLACE",
+ [TK_A_INOTIFY_WATCH] = "A INOTIFY_WATCH",
[TK_A_NUM_FAKE_PART] = "A NUM_FAKE_PART",
[TK_A_DEVLINK_PRIO] = "A DEVLINK_PRIO",
[TK_A_OWNER] = "A OWNER",
dbg(rules->udev, "%s %s '%s'(%s) %#o\n",
token_str(type), operation_str(op), value, string_glob_str(glob), token->key.mode);
break;
+ case TK_A_INOTIFY_WATCH:
+ dbg(rules->udev, "%s %u\n", token_str(type), token->key.watch);
+ break;
case TK_A_NUM_FAKE_PART:
dbg(rules->udev, "%s %u\n", token_str(type), token->key.num_fake_part);
break;
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;
+ 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;
}
{
struct udev *udev = udev_device_get_udev(dev);
char **envp;
- char result[2048];
+ char result[4096];
size_t reslen;
char *line;
token->key.value_off = add_string(rule_tmp->rules, value);
token->key.ignore_error = *(int *)data;
break;
+ case TK_A_INOTIFY_WATCH:
case TK_A_NUM_FAKE_PART:
- token->key.num_fake_part = *(int *)data;
- break;
case TK_A_DEVLINK_PRIO:
token->key.devlink_prio = *(int *)data;
break;
static int add_rule(struct udev_rules *rules, char *line,
const char *filename, unsigned int filename_off, unsigned int lineno)
{
- int valid = 0;
char *linepos;
char *attr;
int physdev = 0;
+ int waitfor = 0;
struct rule_tmp rule_tmp;
memset(&rule_tmp, 0x00, sizeof(struct rule_tmp));
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_ACTION, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_DEVPATH, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_KERNEL, op, value, NULL);
- valid = 1;
continue;
}
rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, "subsystem|class|bus", NULL);
} else
rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_DRIVER, op, value, NULL);
- valid = 1;
continue;
}
} else {
rule_add_key(&rule_tmp, TK_A_ATTR, op, value, attr);
}
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_KERNELS, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_SUBSYSTEMS, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_DRIVERS, op, value, NULL);
- valid = 1;
continue;
}
err(rules->udev, "do not reference parent sysfs directories directly, "
"it may break with a future kernel, please fix it in %s:%u", filename, lineno);
rule_add_key(&rule_tmp, TK_M_ATTRS, op, value, attr);
- valid = 1;
continue;
}
if (rule_add_key(&rule_tmp, TK_A_ENV, op, value, attr) != 0)
goto invalid;
}
- valid = 1;
continue;
}
if (strcasecmp(key, "PROGRAM") == 0) {
rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
- valid = 1;
continue;
}
goto invalid;
}
rule_add_key(&rule_tmp, TK_M_RESULT, op, value, NULL);
- valid = 1;
continue;
}
if (attr != NULL && strstr(attr, "program")) {
dbg(rules->udev, "IMPORT will be executed\n");
rule_add_key(&rule_tmp, TK_M_IMPORT_PROG, op, value, NULL);
- valid = 1;
} else if (attr != NULL && strstr(attr, "file")) {
dbg(rules->udev, "IMPORT will be included as file\n");
rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL);
- valid = 1;
} else if (attr != NULL && strstr(attr, "parent")) {
dbg(rules->udev, "IMPORT will include the parent values\n");
rule_add_key(&rule_tmp, TK_M_IMPORT_PARENT, op, value, NULL);
- valid = 1;
} else {
/* figure it out if it is executable */
char file[UTIL_PATH_SIZE];
if (!lstat(file, &statbuf) && (statbuf.st_mode & S_IXUSR)) {
dbg(rules->udev, "IMPORT will be executed (autotype)\n");
rule_add_key(&rule_tmp, TK_M_IMPORT_PROG, op, value, NULL);
- valid = 1;
} else {
dbg(rules->udev, "IMPORT will be included as file (autotype)\n");
rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL);
- valid = 1;
}
}
continue;
} else {
rule_add_key(&rule_tmp, TK_M_TEST, op, value, NULL);
}
- valid = 1;
continue;
}
if (attr != NULL && strstr(attr, "ignore_error"))
flag = 1;
rule_add_key(&rule_tmp, TK_A_RUN, op, value, &flag);
- valid = 1;
continue;
}
if (strcasecmp(key, "WAIT_FOR") == 0 || strcasecmp(key, "WAIT_FOR_SYSFS") == 0) {
rule_add_key(&rule_tmp, TK_M_WAITFOR, 0, value, NULL);
- valid = 1;
+ waitfor = 1;
continue;
}
if (strcasecmp(key, "LABEL") == 0) {
rule_tmp.rule.rule.label_off = add_string(rules, value);
- valid = 1;
continue;
}
if (strcasecmp(key, "GOTO") == 0) {
rule_add_key(&rule_tmp, TK_A_GOTO, 0, value, NULL);
- valid = 1;
continue;
}
rule_add_key(&rule_tmp, TK_M_NAME, op, value, NULL);
} else {
if (value[0] == '\0')
- dbg(rules->udev, "name empty, node creation suppressed\n");
+ info(rules->udev, "name empty, node creation suppressed\n");
rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
attr = get_key_attribute(rules->udev, key + sizeof("NAME")-1);
if (attr != NULL) {
else
rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, NULL);
rule_tmp.rule.rule.flags = 1;
- valid = 1;
continue;
}
uid = strtoul(value, &endptr, 10);
if (endptr[0] == '\0') {
rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
- } else if (rules->resolve_names && strchr("$%", value[0]) == NULL) {
+ } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
uid = add_uid(rules, value);
rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
- } else {
+ } else if (rules->resolve_names == 0) {
rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL);
}
rule_tmp.rule.rule.flags = 1;
- valid = 1;
continue;
}
gid = strtoul(value, &endptr, 10);
if (endptr[0] == '\0') {
rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
- } else if (rules->resolve_names && strchr("$%", value[0]) == NULL) {
+ } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
gid = add_gid(rules, value);
rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
- } else {
+ } else if (rules->resolve_names == 0) {
rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL);
}
rule_tmp.rule.rule.flags = 1;
- valid = 1;
continue;
}
else
rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL);
rule_tmp.rule.rule.flags = 1;
- valid = 1;
continue;
}
rule_add_key(&rule_tmp, TK_A_NUM_FAKE_PART, 0, NULL, &num);
dbg(rules->udev, "creation of partition nodes requested\n");
}
- valid = 1;
+ pos = strstr(value, "nowatch");
+ if (pos != NULL) {
+ const int off = 0;
+
+ rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &off);
+ dbg(rules->udev, "inotify watch of device disabled\n");
+ } else {
+ pos = strstr(value, "watch");
+ if (pos != NULL) {
+ const int on = 1;
+
+ rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, 0, NULL, &on);
+ dbg(rules->udev, "inotify watch of device requested\n");
+ }
+ }
continue;
}
err(rules->udev, "unknown key '%s' in %s:%u\n", key, filename, lineno);
}
- if (physdev)
- err(rules->udev, "PHYSDEV* values are deprecated and not available on recent kernels, \n"
- "please fix it in %s:%u", filename, lineno);
-
- /* skip line if not any valid key was found */
- if (!valid)
- goto invalid;
+ if (physdev && !waitfor)
+ err(rules->udev, "PHYSDEV* values are deprecated and not available on recent kernels, "
+ "please fix it in %s:%u\n", filename, lineno);
/* add rule token */
rule_tmp.rule.rule.token_count = 1 + rule_tmp.token_cur;
dbg(udev, "open directory '%s'\n", dirname);
dir = opendir(dirname);
if (dir == NULL) {
- err(udev, "unable to open '%s': %m\n", dirname);
+ info(udev, "unable to open '%s': %m\n", dirname);
return -1;
}
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");
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);
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);
rule = cur;
/* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */
if (!can_set_name && rule->rule.flags)
- ;//goto nomatch;
+ goto nomatch;
esc = ESCAPE_UNSET;
break;
case TK_M_ACTION:
break;
case TK_M_ENV:
{
- struct udev_list_entry *list_entry;
const char *key_name = &rules->buf[cur->key.attr_off];
const char *value;
- list_entry = udev_device_get_properties_list_entry(event->dev);
- list_entry = udev_list_entry_get_by_name(list_entry, key_name);
- value = udev_list_entry_get_value(list_entry);
+ value = udev_device_get_property_value(event->dev, key_name);
if (value == NULL) {
dbg(event->udev, "ENV{%s} is not set, treat as empty\n", key_name);
value = "";
break;
udev_device_set_num_fake_partitions(event->dev, cur->key.num_fake_part);
break;
+ case TK_A_INOTIFY_WATCH:
+ event->inotify_watch = cur->key.watch;
+ break;
case TK_A_DEVLINK_PRIO:
udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio);
break;
break;
if (cur->key.op == OP_ASSIGN_FINAL)
event->name_final = 1;
- if (name[0] == '\0') {
- free(event->name);
- event->name = NULL;
- break;
- }
util_strlcpy(name_str, name, sizeof(name_str));
udev_event_apply_format(event, name_str, sizeof(name_str));
if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
count = udev_util_replace_chars(name_str, "/");
if (count > 0)
info(event->udev, "%i character(s) replaced\n", count);
- free(event->name);
- event->name = strdup(name_str);
- info(event->udev, "NAME '%s' %s:%u\n",
- event->name,
- &rules->buf[rule->rule.filename_off],
- rule->rule.filename_line);
}
+ free(event->name);
+ event->name = strdup(name_str);
+ info(event->udev, "NAME '%s' %s:%u\n",
+ event->name,
+ &rules->buf[rule->rule.filename_off],
+ rule->rule.filename_line);
break;
}
case TK_A_DEVLINK:
rule->rule.filename_line);
f = fopen(attr, "w");
if (f != NULL) {
- if (!event->test)
- if (fprintf(f, "%s", value) <= 0)
- err(event->udev, "error writing ATTR{%s}: %m\n", attr);
+ if (fprintf(f, "%s", value) <= 0)
+ err(event->udev, "error writing ATTR{%s}: %m\n", attr);
fclose(f);
} else {
err(event->udev, "error opening ATTR{%s} for writing: %m\n", attr);
~ianmdlvl / elogind.git / blobdiff