#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/inotify.h>
+#include <sys/utsname.h>
#include "udev.h"
}
}
-static bool debug_trace;
static struct udev_rules *rules;
static struct udev_queue_export *udev_queue_export;
static struct udev_ctrl *udev_ctrl;
static pid_t settle_pid;
static bool stop_exec_queue;
static bool reload_config;
-static int max_childs;
-static int childs;
+static int children;
+static int children_max;
+static int exec_delay;
static sigset_t orig_sigmask;
static struct udev_list_node event_list;
static struct udev_list_node worker_list;
udev_list_node_remove(&worker->node);
udev_monitor_unref(worker->monitor);
- childs--;
+ children--;
info(worker->udev, "worker [%u] cleaned up\n", worker->pid);
free(worker);
}
/* set timeout to prevent hanging processes */
alarm(UDEV_EVENT_TIMEOUT);
+ if (exec_delay > 0)
+ udev_event->exec_delay = exec_delay;
+
/* apply rules, create node, symlinks */
err = udev_event_execute_rules(udev_event, rules);
worker->event = event;
event->state = EVENT_RUNNING;
udev_list_node_append(&worker->node, &worker_list);
- childs++;
+ children++;
info(event->udev, "seq %llu forked new worker [%u]\n", udev_device_get_seqnum(event->dev), pid);
break;
}
return;
}
- if (!force && childs >= max_childs) {
- info(event->udev, "maximum number (%i) of childs reached\n", childs);
+ if (!force && children >= children_max) {
+ if (children_max > 1)
+ info(event->udev, "maximum number (%i) of children reached\n", children);
return;
}
struct udev_list_node *loop;
int max;
- if (childs <= retain)
+ if (children <= retain)
return;
- max = childs - retain;
+ max = children - retain;
udev_list_node_foreach(loop, &worker_list) {
struct worker *worker = node_to_worker(loop);
static void worker_returned(void)
{
- while (1) {
+ for (;;) {
struct worker_message msg;
ssize_t size;
struct udev_list_node *loop;
worker_kill(udev, 0);
}
- i = udev_ctrl_get_set_max_childs(ctrl_msg);
+ i = udev_ctrl_get_set_children_max(ctrl_msg);
if (i >= 0) {
- info(udev, "udevd message (SET_MAX_CHILDS) received, max_childs=%i\n", i);
- max_childs = i;
+ info(udev, "udevd message (SET_MAX_CHILDREN) received, children_max=%i\n", i);
+ children_max = i;
}
settle_pid = udev_ctrl_get_settle(ctrl_msg);
udev_exit = true;
break;
case SIGCHLD:
- while (1) {
+ for (;;) {
pid_t pid;
int status;
struct udev_list_node *loop, *tmp;
}
}
+static void static_dev_create_from_modules(struct udev *udev)
+{
+ struct utsname kernel;
+ char modules[UTIL_PATH_SIZE];
+ char buf[4096];
+ FILE *f;
+
+ uname(&kernel);
+ util_strscpyl(modules, sizeof(modules), "/lib/modules/", kernel.release, "/modules.devname", NULL);
+ f = fopen(modules, "r");
+ if (f == NULL)
+ return;
+
+ while (fgets(buf, sizeof(buf), f) != NULL) {
+ char *s;
+ const char *modname;
+ const char *devname;
+ const char *devno;
+ int maj, min;
+ char type;
+ mode_t mode;
+ char filename[UTIL_PATH_SIZE];
+
+ if (buf[0] == '#')
+ continue;
+
+ modname = buf;
+ s = strchr(modname, ' ');
+ if (s == NULL)
+ continue;
+ s[0] = '\0';
+
+ devname = &s[1];
+ s = strchr(devname, ' ');
+ if (s == NULL)
+ continue;
+ s[0] = '\0';
+
+ devno = &s[1];
+ s = strchr(devno, ' ');
+ if (s == NULL)
+ s = strchr(devno, '\n');
+ if (s != NULL)
+ s[0] = '\0';
+ if (sscanf(devno, "%c%u:%u", &type, &maj, &min) != 3)
+ continue;
+
+ if (type == 'c')
+ mode = 0600 | S_IFCHR;
+ else if (type == 'b')
+ mode = 0600 | S_IFBLK;
+ else
+ continue;
+
+ util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/", devname, NULL);
+ util_create_path(udev, filename);
+ udev_selinux_setfscreatecon(udev, filename, mode);
+ info(udev, "mknod '%s' %c%u:%u\n", filename, type, maj, min);
+ if (mknod(filename, mode, makedev(maj, min)) < 0 && errno == EEXIST)
+ utimensat(AT_FDCWD, filename, NULL, 0);
+ udev_selinux_resetfscreatecon(udev);
+ }
+
+ fclose(f);
+}
+
static int copy_dir(struct udev *udev, DIR *dir_from, DIR *dir_to, int maxdepth)
{
struct dirent *dent;
return 0;
}
-static void prepare_dev(struct udev *udev)
+static void static_dev_create_links(struct udev *udev, DIR *dir)
{
struct stdlinks {
const char *link;
};
static const struct stdlinks stdlinks[] = {
{ "core", "/proc/kcore" },
- { "fd", "/proc/fd" },
+ { "fd", "/proc/self/fd" },
{ "stdin", "/proc/self/fd/0" },
{ "stdout", "/proc/self/fd/1" },
{ "stderr", "/proc/self/fd/2" },
};
unsigned int i;
- DIR *dir_from, *dir_to;
-
- dir_to = opendir(udev_get_dev_path(udev));
- if (dir_to == NULL)
- return;
- /* create standard symlinks to /proc */
for (i = 0; i < ARRAY_SIZE(stdlinks); i++) {
- udev_selinux_setfscreateconat(udev, dirfd(dir_to), stdlinks[i].link, S_IFLNK);
- if (symlinkat(stdlinks[i].target, dirfd(dir_to), stdlinks[i].link) < 0 && errno == EEXIST)
- utimensat(dirfd(dir_to), stdlinks[i].link, NULL, AT_SYMLINK_NOFOLLOW);
+ udev_selinux_setfscreateconat(udev, dirfd(dir), stdlinks[i].link, S_IFLNK);
+ if (symlinkat(stdlinks[i].target, dirfd(dir), stdlinks[i].link) < 0 && errno == EEXIST)
+ utimensat(dirfd(dir), stdlinks[i].link, NULL, AT_SYMLINK_NOFOLLOW);
udev_selinux_resetfscreatecon(udev);
}
+}
+
+static void static_dev_create_from_devices(struct udev *udev, DIR *dir)
+{
+ DIR *dir_from;
- /* copy content from /lib/udev/devices to /dev */
dir_from = opendir(LIBEXECDIR "/devices");
- if (dir_from != NULL) {
- copy_dir(udev, dir_from, dir_to, 8);
- closedir(dir_from);
- }
+ if (dir_from == NULL)
+ return;
+ copy_dir(udev, dir_from, dir, 8);
+ closedir(dir_from);
+}
+
+static void static_dev_create(struct udev *udev)
+{
+ DIR *dir;
+
+ dir = opendir(udev_get_dev_path(udev));
+ if (dir == NULL)
+ return;
+
+ static_dev_create_links(udev, dir);
+ static_dev_create_from_devices(udev, dir);
- closedir(dir_to);
+ closedir(dir);
}
static int mem_size_mb(void)
int fd;
FILE *f;
sigset_t mask;
- const char *value;
int daemonize = false;
int resolve_names = 1;
static const struct option options[] = {
{ "daemon", no_argument, NULL, 'd' },
- { "debug-trace", no_argument, NULL, 't' },
{ "debug", no_argument, NULL, 'D' },
+ { "children-max", required_argument, NULL, 'c' },
+ { "exec-delay", required_argument, NULL, 'e' },
+ { "resolve-names", required_argument, NULL, 'N' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
- { "resolve-names", required_argument, NULL, 'N' },
{}
};
int rc = 1;
info(udev, "version %s\n", VERSION);
udev_selinux_init(udev);
- while (1) {
+ for (;;) {
int option;
- option = getopt_long(argc, argv, "dDthV", options, NULL);
+ option = getopt_long(argc, argv, "cdeDthV", options, NULL);
if (option == -1)
break;
case 'd':
daemonize = true;
break;
- case 't':
- debug_trace = true;
+ case 'c':
+ children_max = strtoul(optarg, NULL, 0);
+ break;
+ case 'e':
+ exec_delay = strtoul(optarg, NULL, 0);
break;
case 'D':
debug = true;
}
break;
case 'h':
- printf("Usage: udevd [--help] [--daemon] [--debug-trace] [--debug] "
- "[--resolve-names=early|late|never] [--version]\n");
+ printf("Usage: udevd OPTIONS\n"
+ " --daemon\n"
+ " --debug\n"
+ " --children-max=<maximum number of workers>\n"
+ " --exec-delay=<seconds to wait before executing RUN=>\n"
+ " --resolve-names=early|late|never\n"
+ " --version\n"
+ " --help\n"
+ "\n");
goto exit;
case 'V':
printf("%s\n", VERSION);
goto exit;
}
- /* make sure std{in,out,err} fd's are in a sane state */
+ /*
+ * read the kernel commandline, in case we need to get into debug mode
+ * udev.log-priority=<level> syslog priority
+ * udev.children-max=<number of workers> events are fully serialized if set to 1
+ *
+ */
+ f = fopen("/proc/cmdline", "r");
+ if (f != NULL) {
+ char cmdline[4096];
+
+ if (fgets(cmdline, sizeof(cmdline), f) != NULL) {
+ char *pos;
+
+ pos = strstr(cmdline, "udev.log-priority=");
+ if (pos != NULL) {
+ pos += strlen("udev.log-priority=");
+ udev_set_log_priority(udev, util_log_priority(pos));
+ }
+
+ pos = strstr(cmdline, "udev.children-max=");
+ if (pos != NULL) {
+ pos += strlen("udev.children-max=");
+ children_max = strtoul(pos, NULL, 0);
+ }
+
+ pos = strstr(cmdline, "udev.exec-delay=");
+ if (pos != NULL) {
+ pos += strlen("udev.exec-delay=");
+ exec_delay = strtoul(pos, NULL, 0);
+ }
+ }
+ fclose(f);
+ }
+
+ /* make sure std{in,out,err} fds are in a sane state */
fd = open("/dev/null", O_RDWR);
if (fd < 0) {
fprintf(stderr, "cannot open /dev/null\n");
if (write(STDERR_FILENO, 0, 0) < 0)
dup2(fd, STDERR_FILENO);
- prepare_dev(udev);
-
- /* init control socket, bind() ensures, that only one udevd instance is running */
udev_ctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
if (udev_ctrl == NULL) {
fprintf(stderr, "error initializing control socket");
fclose(f);
}
- /* redirect std{out,err} */
- if (!debug && !debug_trace) {
+ if (!debug) {
dup2(fd, STDIN_FILENO);
dup2(fd, STDOUT_FILENO);
dup2(fd, STDERR_FILENO);
if (fd > STDERR_FILENO)
close(fd);
- /* set scheduling priority for the daemon */
+ /* set scheduling priority for the main daemon process */
setpriority(PRIO_PROCESS, 0, UDEVD_PRIORITY);
chdir("/");
close(fd);
}
- /* in trace mode run one event after the other */
- if (debug_trace) {
- max_childs = 1;
- } else {
+ if (children_max <= 0) {
int memsize = mem_size_mb();
+ /* set value depending on the amount of RAM */
if (memsize > 0)
- max_childs = 128 + (memsize / 8);
+ children_max = 128 + (memsize / 8);
else
- max_childs = 128;
+ children_max = 128;
}
+ info(udev, "set children_max to %u\n", children_max);
- /* possibly overwrite maximum limit of executed events */
- value = getenv("UDEVD_MAX_CHILDS");
- if (value)
- max_childs = strtoul(value, NULL, 10);
- info(udev, "initialize max_childs to %u\n", max_childs);
+ static_dev_create(udev);
+ static_dev_create_from_modules(udev);
+ udev_rules_apply_static_dev_perms(rules);
udev_list_init(&event_list);
udev_list_init(&worker_list);
int timeout;
/* set timeout to kill idle workers */
- if (udev_list_is_empty(&event_list) && childs > 2)
+ if (udev_list_is_empty(&event_list) && children > 2)
timeout = 3 * 1000;
else
timeout = -1;