udev/udevd.c

   1 /*
   2  * Copyright (C) 2004-2008 Kay Sievers <kay.sievers@vrfy.org>
   3  * Copyright (C) 2004 Chris Friesen <chris_friesen@sympatico.ca>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <stddef.h>
  20 #include <signal.h>
  21 #include <unistd.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <fcntl.h>
  28 #include <time.h>
  29 #include <getopt.h>
  30 #include <sys/select.h>
  31 #include <sys/wait.h>
  32 #include <sys/stat.h>
  33 #include <sys/ioctl.h>
  34 #ifdef HAVE_INOTIFY
  35 #include <sys/inotify.h>
  36 #endif
  37
  38 #include "udev.h"
  39
  40 #define UDEVD_PRIORITY                  -4
  41 #define UDEV_PRIORITY                   -2
  42
  43 /* maximum limit of forked childs */
  44 #define UDEVD_MAX_CHILDS                256
  45
  46 static int debug;
  47
  48 static void log_fn(struct udev *udev, int priority,
  49                    const char *file, int line, const char *fn,
  50                    const char *format, va_list args)
  51 {
  52         if (debug) {
  53                 fprintf(stderr, "[%d] %s: ", (int) getpid(), fn);
  54                 vfprintf(stderr, format, args);
  55         } else {
  56                 vsyslog(priority, format, args);
  57         }
  58 }
  59
  60 static int debug_trace;
  61 static struct udev_rules *rules;
  62 static struct udev_ctrl *udev_ctrl;
  63 static struct udev_monitor *kernel_monitor;
  64 static int inotify_fd = -1;
  65
  66 static int signal_pipe[2] = {-1, -1};
  67 static volatile int sigchilds_waiting;
  68 static volatile int udev_exit;
  69 static volatile int reload_config;
  70 static int run_exec_q;
  71 static int stop_exec_q;
  72 static int max_childs;
  73
  74 static struct udev_list_node exec_list;
  75 static struct udev_list_node running_list;
  76
  77 enum event_state {
  78         EVENT_QUEUED,
  79         EVENT_FINISHED,
  80         EVENT_FAILED,
  81 };
  82
  83 static struct udev_event *node_to_event(struct udev_list_node *node)
  84 {
  85         char *event;
  86
  87         event = (char *)node;
  88         event -= offsetof(struct udev_event, node);
  89         return (struct udev_event *)event;
  90 }
  91
  92 static void export_event_state(struct udev_event *event, enum event_state state)
  93 {
  94         char filename[UTIL_PATH_SIZE];
  95         char filename_failed[UTIL_PATH_SIZE];
  96         size_t start;
  97
  98         /* location of queue file */
  99         snprintf(filename, sizeof(filename), "%s/.udev/queue/%llu",
 100                  udev_get_dev_path(event->udev), udev_device_get_seqnum(event->dev));
 101
 102         /* location of failed file */
 103         util_strlcpy(filename_failed, udev_get_dev_path(event->udev), sizeof(filename_failed));
 104         util_strlcat(filename_failed, "/", sizeof(filename_failed));
 105         start = util_strlcat(filename_failed, ".udev/failed/", sizeof(filename_failed));
 106         util_strlcat(filename_failed, udev_device_get_devpath(event->dev), sizeof(filename_failed));
 107         util_path_encode(&filename_failed[start], sizeof(filename_failed) - start);
 108
 109         switch (state) {
 110         case EVENT_QUEUED:
 111                 unlink(filename_failed);
 112                 delete_path(event->udev, filename_failed);
 113                 create_path(event->udev, filename);
 114                 udev_selinux_setfscreatecon(event->udev, filename, S_IFLNK);
 115                 symlink(udev_device_get_devpath(event->dev), filename);
 116                 udev_selinux_resetfscreatecon(event->udev);
 117                 break;
 118         case EVENT_FINISHED:
 119                 if (udev_device_get_devpath_old(event->dev) != NULL) {
 120                         /* "move" event - rename failed file to current name, do not delete failed */
 121                         char filename_failed_old[UTIL_PATH_SIZE];
 122
 123                         util_strlcpy(filename_failed_old, udev_get_dev_path(event->udev), sizeof(filename_failed_old));
 124                         util_strlcat(filename_failed_old, "/", sizeof(filename_failed_old));
 125                         start = util_strlcat(filename_failed_old, ".udev/failed/", sizeof(filename_failed_old));
 126                         util_strlcat(filename_failed_old, udev_device_get_devpath_old(event->dev), sizeof(filename_failed_old));
 127                         util_path_encode(&filename_failed_old[start], sizeof(filename) - start);
 128
 129                         if (rename(filename_failed_old, filename_failed) == 0)
 130                                 info(event->udev, "renamed devpath, moved failed state of '%s' to %s'\n",
 131                                      udev_device_get_devpath_old(event->dev), udev_device_get_devpath(event->dev));
 132                 } else {
 133                         unlink(filename_failed);
 134                         delete_path(event->udev, filename_failed);
 135                 }
 136
 137                 unlink(filename);
 138                 delete_path(event->udev, filename);
 139                 break;
 140         case EVENT_FAILED:
 141                 /* move failed event to the failed directory */
 142                 create_path(event->udev, filename_failed);
 143                 rename(filename, filename_failed);
 144
 145                 /* clean up possibly empty queue directory */
 146                 delete_path(event->udev, filename);
 147                 break;
 148         }
 149
 150         return;
 151 }
 152
 153 static void event_queue_delete(struct udev_event *event)
 154 {
 155         udev_list_node_remove(&event->node);
 156
 157         /* mark as failed, if "add" event returns non-zero */
 158         if (event->exitstatus && strcmp(udev_device_get_action(event->dev), "add") == 0)
 159                 export_event_state(event, EVENT_FAILED);
 160         else
 161                 export_event_state(event, EVENT_FINISHED);
 162
 163         udev_device_unref(event->dev);
 164         udev_event_unref(event);
 165 }
 166
 167 static void asmlinkage event_sig_handler(int signum)
 168 {
 169         if (signum == SIGALRM)
 170                 exit(1);
 171 }
 172
 173 static void event_fork(struct udev_event *event)
 174 {
 175         pid_t pid;
 176         struct sigaction act;
 177         int err;
 178
 179         pid = fork();
 180         switch (pid) {
 181         case 0:
 182                 /* child */
 183                 udev_monitor_unref(kernel_monitor);
 184                 udev_ctrl_unref(udev_ctrl);
 185                 if (inotify_fd >= 0)
 186                         close(inotify_fd);
 187                 close(signal_pipe[READ_END]);
 188                 close(signal_pipe[WRITE_END]);
 189                 logging_close();
 190                 logging_init("udevd-event");
 191                 setpriority(PRIO_PROCESS, 0, UDEV_PRIORITY);
 192
 193                 /* set signal handlers */
 194                 memset(&act, 0x00, sizeof(act));
 195                 act.sa_handler = (void (*)(int)) event_sig_handler;
 196                 sigemptyset (&act.sa_mask);
 197                 act.sa_flags = 0;
 198                 sigaction(SIGALRM, &act, NULL);
 199
 200                 /* reset to default */
 201                 act.sa_handler = SIG_DFL;
 202                 sigaction(SIGINT, &act, NULL);
 203                 sigaction(SIGTERM, &act, NULL);
 204                 sigaction(SIGCHLD, &act, NULL);
 205                 sigaction(SIGHUP, &act, NULL);
 206
 207                 /* set timeout to prevent hanging processes */
 208                 alarm(UDEV_EVENT_TIMEOUT);
 209
 210                 /* apply rules, create node, symlinks */
 211                 err = udev_event_run(event, rules);
 212
 213                 /* rules may change/disable the timeout */
 214                 if (udev_device_get_event_timeout(event->dev) >= 0)
 215                         alarm(udev_device_get_event_timeout(event->dev));
 216
 217                 /* execute RUN= */
 218                 if (err == 0 && !event->ignore_device && udev_get_run(event->udev))
 219                         udev_rules_run(event);
 220                 info(event->udev, "seq %llu exit with %i\n", udev_device_get_seqnum(event->dev), err);
 221                 logging_close();
 222                 if (err != 0)
 223                         exit(1);
 224                 exit(0);
 225         case -1:
 226                 err(event->udev, "fork of child failed: %m\n");
 227                 event_queue_delete(event);
 228                 break;
 229         default:
 230                 /* get SIGCHLD in main loop */
 231                 info(event->udev, "seq %llu forked, pid [%d], '%s' '%s', %ld seconds old\n",
 232                      udev_device_get_seqnum(event->dev),
 233                      pid,
 234                      udev_device_get_action(event->dev),
 235                      udev_device_get_subsystem(event->dev),
 236                      time(NULL) - event->queue_time);
 237                 event->pid = pid;
 238         }
 239 }
 240
 241 static void event_queue_insert(struct udev_event *event)
 242 {
 243         char filename[UTIL_PATH_SIZE];
 244         int fd;
 245
 246         event->queue_time = time(NULL);
 247
 248         export_event_state(event, EVENT_QUEUED);
 249         info(event->udev, "seq %llu queued, '%s' '%s'\n", udev_device_get_seqnum(event->dev),
 250              udev_device_get_action(event->dev), udev_device_get_subsystem(event->dev));
 251
 252         util_strlcpy(filename, udev_get_dev_path(event->udev), sizeof(filename));
 253         util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
 254         fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
 255         if (fd >= 0) {
 256                 char str[32];
 257                 int len;
 258
 259                 len = sprintf(str, "%llu\n", udev_device_get_seqnum(event->dev));
 260                 write(fd, str, len);
 261                 close(fd);
 262         }
 263
 264         /* run one event after the other in debug mode */
 265         if (debug_trace) {
 266                 udev_list_node_append(&event->node, &running_list);
 267                 event_fork(event);
 268                 waitpid(event->pid, NULL, 0);
 269                 event_queue_delete(event);
 270                 return;
 271         }
 272
 273         /* run all events with a timeout set immediately */
 274         if (udev_device_get_timeout(event->dev) > 0) {
 275                 udev_list_node_append(&event->node, &running_list);
 276                 event_fork(event);
 277                 return;
 278         }
 279
 280         udev_list_node_append(&event->node, &exec_list);
 281         run_exec_q = 1;
 282 }
 283
 284 static int mem_size_mb(void)
 285 {
 286         FILE* f;
 287         char buf[4096];
 288         long int memsize = -1;
 289
 290         f = fopen("/proc/meminfo", "r");
 291         if (f == NULL)
 292                 return -1;
 293
 294         while (fgets(buf, sizeof(buf), f) != NULL) {
 295                 long int value;
 296
 297                 if (sscanf(buf, "MemTotal: %ld kB", &value) == 1) {
 298                         memsize = value / 1024;
 299                         break;
 300                 }
 301         }
 302
 303         fclose(f);
 304         return memsize;
 305 }
 306
 307 static int compare_devpath(const char *running, const char *waiting)
 308 {
 309         int i;
 310
 311         for (i = 0; i < UTIL_PATH_SIZE; i++) {
 312                 /* identical device event found */
 313                 if (running[i] == '\0' && waiting[i] == '\0')
 314                         return 1;
 315
 316                 /* parent device event found */
 317                 if (running[i] == '\0' && waiting[i] == '/')
 318                         return 2;
 319
 320                 /* child device event found */
 321                 if (running[i] == '/' && waiting[i] == '\0')
 322                         return 3;
 323
 324                 /* no matching event */
 325                 if (running[i] != waiting[i])
 326                         break;
 327         }
 328
 329         return 0;
 330 }
 331
 332 /* lookup event for identical, parent, child, or physical device */
 333 static int devpath_busy(struct udev_event *event, int limit)
 334 {
 335         struct udev_list_node *loop;
 336         int childs_count = 0;
 337
 338         /* check exec-queue which may still contain delayed events we depend on */
 339         udev_list_node_foreach(loop, &exec_list) {
 340                 struct udev_event *loop_event = node_to_event(loop);
 341
 342                 /* skip ourself and all later events */
 343                 if (udev_device_get_seqnum(loop_event->dev) >= udev_device_get_seqnum(event->dev))
 344                         break;
 345
 346                 /* check our old name */
 347                 if (udev_device_get_devpath_old(event->dev) != NULL)
 348                         if (strcmp(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath_old(event->dev)) == 0)
 349                                 return 2;
 350
 351                 /* check identical, parent, or child device event */
 352                 if (compare_devpath(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath(event->dev)) != 0) {
 353                         dbg(event->udev, "%llu, device event still pending %llu (%s)\n",
 354                             udev_device_get_seqnum(event->dev),
 355                             udev_device_get_seqnum(loop_event->dev),
 356                             udev_device_get_devpath(loop_event->dev));
 357                         return 3;
 358                 }
 359
 360                 /* check for our major:minor number */
 361                 if (major(udev_device_get_devnum(event->dev)) > 0 &&
 362                     udev_device_get_devnum(loop_event->dev) == udev_device_get_devnum(event->dev) &&
 363                     strcmp(udev_device_get_subsystem(event->dev), udev_device_get_subsystem(loop_event->dev)) == 0) {
 364                         dbg(event->udev, "%llu, device event still pending %llu (%d:%d)\n",
 365                             udev_device_get_seqnum(event->dev),
 366                             udev_device_get_seqnum(loop_event->dev),
 367                             major(udev_device_get_devnum(loop_event->dev)), minor(udev_device_get_devnum(loop_event->dev)));
 368                         return 4;
 369                 }
 370
 371                 /* check physical device event (special case of parent) */
 372                 if (udev_device_get_physdevpath(event->dev) != NULL &&
 373                     strcmp(udev_device_get_action(event->dev), "add") == 0)
 374                         if (compare_devpath(udev_device_get_devpath(loop_event->dev),
 375                                             udev_device_get_physdevpath(event->dev)) != 0) {
 376                                 dbg(event->udev, "%llu, physical device event still pending %llu (%s)\n",
 377                                     udev_device_get_seqnum(event->dev),
 378                                     udev_device_get_seqnum(loop_event->dev),
 379                                     udev_device_get_devpath(loop_event->dev));
 380                                 return 5;
 381                         }
 382         }
 383
 384         /* check run queue for still running events */
 385         udev_list_node_foreach(loop, &running_list) {
 386                 struct udev_event *loop_event = node_to_event(loop);
 387
 388                 if (childs_count++ >= limit) {
 389                         info(event->udev, "%llu, maximum number (%i) of childs reached\n",
 390                              udev_device_get_seqnum(event->dev), childs_count);
 391                         return 1;
 392                 }
 393
 394                 /* check our old name */
 395                 if (udev_device_get_devpath_old(event->dev) != NULL)
 396                         if (strcmp(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath_old(event->dev)) == 0)
 397                                 return 2;
 398
 399                 /* check identical, parent, or child device event */
 400                 if (compare_devpath(udev_device_get_devpath(loop_event->dev), udev_device_get_devpath(event->dev)) != 0) {
 401                         dbg(event->udev, "%llu, device event still running %llu (%s)\n",
 402                             udev_device_get_seqnum(event->dev),
 403                             udev_device_get_seqnum(loop_event->dev),
 404                             udev_device_get_devpath(loop_event->dev));
 405                         return 3;
 406                 }
 407
 408                 /* check for our major:minor number */
 409                 if (major(udev_device_get_devnum(event->dev)) > 0 &&
 410                     udev_device_get_devnum(loop_event->dev) == udev_device_get_devnum(event->dev) &&
 411                     strcmp(udev_device_get_subsystem(event->dev), udev_device_get_subsystem(loop_event->dev)) == 0) {
 412                         dbg(event->udev, "%llu, device event still pending %llu (%d:%d)\n",
 413                             udev_device_get_seqnum(event->dev),
 414                             udev_device_get_seqnum(loop_event->dev),
 415                             major(udev_device_get_devnum(loop_event->dev)), minor(udev_device_get_devnum(loop_event->dev)));
 416                         return 4;
 417                 }
 418
 419                 /* check physical device event (special case of parent) */
 420                 if (udev_device_get_physdevpath(event->dev) != NULL &&
 421                     strcmp(udev_device_get_action(event->dev), "add") == 0)
 422                         if (compare_devpath(udev_device_get_devpath(loop_event->dev),
 423                                             udev_device_get_physdevpath(event->dev)) != 0) {
 424                                 dbg(event->udev, "%llu, physical device event still pending %llu (%s)\n",
 425                                     udev_device_get_seqnum(event->dev),
 426                                     udev_device_get_seqnum(loop_event->dev),
 427                                     udev_device_get_devpath(loop_event->dev));
 428                                 return 5;
 429                         }
 430         }
 431         return 0;
 432 }
 433
 434 /* serializes events for the identical and parent and child devices */
 435 static void event_queue_manager(struct udev *udev)
 436 {
 437         struct udev_list_node *loop;
 438         struct udev_list_node *tmp;
 439
 440         if (udev_list_is_empty(&exec_list))
 441                 return;
 442
 443         udev_list_node_foreach_safe(loop, tmp, &exec_list) {
 444                 struct udev_event *loop_event = node_to_event(loop);
 445
 446                 /* serialize and wait for parent or child events */
 447                 if (devpath_busy(loop_event, max_childs) != 0) {
 448                         dbg(udev, "delay seq %llu (%s)\n",
 449                             udev_device_get_seqnum(loop_event->dev),
 450                             udev_device_get_devpath(loop_event->dev));
 451                         continue;
 452                 }
 453
 454                 /* move event to run list */
 455                 udev_list_node_remove(&loop_event->node);
 456                 udev_list_node_append(&loop_event->node, &running_list);
 457                 event_fork(loop_event);
 458                 dbg(udev, "moved seq %llu to running list\n", udev_device_get_seqnum(loop_event->dev));
 459         }
 460 }
 461
 462 /* receive the udevd message from userspace */
 463 static void handle_ctrl_msg(struct udev_ctrl *uctrl)
 464 {
 465         struct udev *udev = udev_ctrl_get_udev(uctrl);
 466         struct udev_ctrl_msg *ctrl_msg;
 467         const char *str;
 468         int i;
 469
 470         ctrl_msg = udev_ctrl_receive_msg(uctrl);
 471         if (ctrl_msg == NULL)
 472                 return;
 473
 474         i = udev_ctrl_get_set_log_level(ctrl_msg);
 475         if (i >= 0) {
 476                 info(udev, "udevd message (SET_LOG_PRIORITY) received, log_priority=%i\n", i);
 477                 udev_set_log_priority(udev, i);
 478         }
 479
 480         if (udev_ctrl_get_stop_exec_queue(ctrl_msg) > 0) {
 481                 info(udev, "udevd message (STOP_EXEC_QUEUE) received\n");
 482                 stop_exec_q = 1;
 483         }
 484
 485         if (udev_ctrl_get_start_exec_queue(ctrl_msg) > 0) {
 486                 info(udev, "udevd message (START_EXEC_QUEUE) received\n");
 487                 stop_exec_q = 0;
 488                 event_queue_manager(udev);
 489         }
 490
 491         if (udev_ctrl_get_reload_rules(ctrl_msg) > 0) {
 492                 info(udev, "udevd message (RELOAD_RULES) received\n");
 493                 reload_config = 1;
 494         }
 495
 496         str = udev_ctrl_get_set_env(ctrl_msg);
 497         if (str != NULL) {
 498                 char *key;
 499
 500                 key = strdup(str);
 501                 if (key != NULL) {
 502                         char *val;
 503
 504                         val = strchr(key, '=');
 505                         if (val != NULL) {
 506                                 val[0] = '\0';
 507                                 val = &val[1];
 508                                 if (val[0] == '\0') {
 509                                         info(udev, "udevd message (ENV) received, unset '%s'\n", key);
 510                                         udev_add_property(udev, key, NULL);
 511                                 } else {
 512                                         info(udev, "udevd message (ENV) received, set '%s=%s'\n", key, val);
 513                                         udev_add_property(udev, key, val);
 514                                 }
 515                         } else {
 516                                 err(udev, "wrong key format '%s'\n", key);
 517                         }
 518                         free(key);
 519                 }
 520         }
 521
 522         i = udev_ctrl_get_set_max_childs(ctrl_msg);
 523         if (i >= 0) {
 524                 info(udev, "udevd message (SET_MAX_CHILDS) received, max_childs=%i\n", i);
 525                 max_childs = i;
 526         }
 527
 528         udev_ctrl_msg_unref(ctrl_msg);
 529 }
 530
 531 static void asmlinkage sig_handler(int signum)
 532 {
 533         switch (signum) {
 534                 case SIGINT:
 535                 case SIGTERM:
 536                         udev_exit = 1;
 537                         break;
 538                 case SIGCHLD:
 539                         /* set flag, then write to pipe if needed */
 540                         sigchilds_waiting = 1;
 541                         break;
 542                 case SIGHUP:
 543                         reload_config = 1;
 544                         break;
 545         }
 546
 547         /* write to pipe, which will wakeup select() in our mainloop */
 548         write(signal_pipe[WRITE_END], "", 1);
 549 }
 550
 551 static void udev_done(int pid, int exitstatus)
 552 {
 553         struct udev_list_node *loop;
 554
 555         /* find event associated with pid and delete it */
 556         udev_list_node_foreach(loop, &running_list) {
 557                 struct udev_event *loop_event = node_to_event(loop);
 558
 559                 if (loop_event->pid == pid) {
 560                         info(loop_event->udev, "seq %llu cleanup, pid [%d], status %i, %ld seconds old\n",
 561                              udev_device_get_seqnum(loop_event->dev), loop_event->pid,
 562                              exitstatus, time(NULL) - loop_event->queue_time);
 563                         loop_event->exitstatus = exitstatus;
 564                         event_queue_delete(loop_event);
 565
 566                         /* there may be events waiting with the same devpath */
 567                         run_exec_q = 1;
 568                         return;
 569                 }
 570         }
 571 }
 572
 573 static void reap_sigchilds(void)
 574 {
 575         pid_t pid;
 576         int status;
 577
 578         while (1) {
 579                 pid = waitpid(-1, &status, WNOHANG);
 580                 if (pid <= 0)
 581                         break;
 582                 if (WIFEXITED(status))
 583                         status = WEXITSTATUS(status);
 584                 else if (WIFSIGNALED(status))
 585                         status = WTERMSIG(status) + 128;
 586                 else
 587                         status = 0;
 588                 udev_done(pid, status);
 589         }
 590 }
 591
 592 static void export_initial_seqnum(struct udev *udev)
 593 {
 594         char filename[UTIL_PATH_SIZE];
 595         int fd;
 596         char seqnum[32];
 597         ssize_t len = 0;
 598
 599         util_strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
 600         util_strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
 601         fd = open(filename, O_RDONLY);
 602         if (fd >= 0) {
 603                 len = read(fd, seqnum, sizeof(seqnum)-1);
 604                 close(fd);
 605         }
 606         if (len <= 0) {
 607                 strcpy(seqnum, "0\n");
 608                 len = 3;
 609         }
 610         util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
 611         util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
 612         create_path(udev, filename);
 613         fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
 614         if (fd >= 0) {
 615                 write(fd, seqnum, len);
 616                 close(fd);
 617         }
 618 }
 619
 620 int main(int argc, char *argv[])
 621 {
 622         struct udev *udev;
 623         int err;
 624         int fd;
 625         struct sigaction act;
 626         fd_set readfds;
 627         const char *value;
 628         int daemonize = 0;
 629         static const struct option options[] = {
 630                 { "daemon", no_argument, NULL, 'd' },
 631                 { "debug-trace", no_argument, NULL, 't' },
 632                 { "debug", no_argument, NULL, 'D' },
 633                 { "help", no_argument, NULL, 'h' },
 634                 { "version", no_argument, NULL, 'V' },
 635                 {}
 636         };
 637         int rc = 1;
 638         int maxfd;
 639
 640         udev = udev_new();
 641         if (udev == NULL)
 642                 goto exit;
 643
 644         logging_init("udevd");
 645         udev_set_log_fn(udev, log_fn);
 646         info(udev, "version %s\n", VERSION);
 647         selinux_init(udev);
 648
 649         while (1) {
 650                 int option;
 651
 652                 option = getopt_long(argc, argv, "dDthV", options, NULL);
 653                 if (option == -1)
 654                         break;
 655
 656                 switch (option) {
 657                 case 'd':
 658                         daemonize = 1;
 659                         break;
 660                 case 't':
 661                         debug_trace = 1;
 662                         break;
 663                 case 'D':
 664                         debug = 1;
 665                         if (udev_get_log_priority(udev) < LOG_INFO)
 666                                 udev_set_log_priority(udev, LOG_INFO);
 667                         break;
 668                 case 'h':
 669                         printf("Usage: udevd [--help] [--daemon] [--debug-trace] [--debug] [--version]\n");
 670                         goto exit;
 671                 case 'V':
 672                         printf("%s\n", VERSION);
 673                         goto exit;
 674                 default:
 675                         goto exit;
 676                 }
 677         }
 678
 679         if (getuid() != 0) {
 680                 fprintf(stderr, "root privileges required\n");
 681                 err(udev, "root privileges required\n");
 682                 goto exit;
 683         }
 684
 685         /* make sure std{in,out,err} fd's are in a sane state */
 686         fd = open("/dev/null", O_RDWR);
 687         if (fd < 0) {
 688                 fprintf(stderr, "cannot open /dev/null\n");
 689                 err(udev, "cannot open /dev/null\n");
 690         }
 691         if (fd > STDIN_FILENO)
 692                 dup2(fd, STDIN_FILENO);
 693         if (write(STDOUT_FILENO, 0, 0) < 0)
 694                 dup2(fd, STDOUT_FILENO);
 695         if (write(STDERR_FILENO, 0, 0) < 0)
 696                 dup2(fd, STDERR_FILENO);
 697
 698         /* init control socket, bind() ensures, that only one udevd instance is running */
 699         udev_ctrl = udev_ctrl_new_from_socket(udev, UDEV_CTRL_SOCK_PATH);
 700         if (udev_ctrl == NULL) {
 701                 fprintf(stderr, "error initializing control socket");
 702                 err(udev, "error initializing udevd socket");
 703                 rc = 1;
 704                 goto exit;
 705         }
 706
 707         if (udev_ctrl_enable_receiving(udev_ctrl) < 0) {
 708                 fprintf(stderr, "error binding control socket, seems udevd is already running\n");
 709                 err(udev, "error binding control socket, seems udevd is already running\n");
 710                 rc = 1;
 711                 goto exit;
 712         }
 713
 714         kernel_monitor = udev_monitor_new_from_netlink(udev);
 715         if (kernel_monitor == NULL || udev_monitor_enable_receiving(kernel_monitor) < 0) {
 716                 fprintf(stderr, "error initializing netlink socket\n");
 717                 err(udev, "error initializing netlink socket\n");
 718                 rc = 3;
 719                 goto exit;
 720         }
 721         udev_monitor_set_receive_buffer_size(kernel_monitor, 128*1024*1024);
 722
 723         err = pipe(signal_pipe);
 724         if (err < 0) {
 725                 err(udev, "error getting pipes: %m\n");
 726                 goto exit;
 727         }
 728
 729         err = fcntl(signal_pipe[READ_END], F_GETFL, 0);
 730         if (err < 0) {
 731                 err(udev, "error fcntl on read pipe: %m\n");
 732                 goto exit;
 733         }
 734         err = fcntl(signal_pipe[READ_END], F_SETFL, err | O_NONBLOCK);
 735         if (err < 0) {
 736                 err(udev, "error fcntl on read pipe: %m\n");
 737                 goto exit;
 738         }
 739
 740         err = fcntl(signal_pipe[WRITE_END], F_GETFL, 0);
 741         if (err < 0) {
 742                 err(udev, "error fcntl on write pipe: %m\n");
 743                 goto exit;
 744         }
 745         err = fcntl(signal_pipe[WRITE_END], F_SETFL, err | O_NONBLOCK);
 746         if (err < 0) {
 747                 err(udev, "error fcntl on write pipe: %m\n");
 748                 goto exit;
 749         }
 750
 751         rules = udev_rules_new(udev, 1);
 752         if (rules == NULL) {
 753                 err(udev, "error reading rules\n");
 754                 goto exit;
 755         }
 756         udev_list_init(&running_list);
 757         udev_list_init(&exec_list);
 758         export_initial_seqnum(udev);
 759
 760         if (daemonize) {
 761                 pid_t pid;
 762
 763                 pid = fork();
 764                 switch (pid) {
 765                 case 0:
 766                         dbg(udev, "daemonized fork running\n");
 767                         break;
 768                 case -1:
 769                         err(udev, "fork of daemon failed: %m\n");
 770                         rc = 4;
 771                         goto exit;
 772                 default:
 773                         dbg(udev, "child [%u] running, parent exits\n", pid);
 774                         rc = 0;
 775                         goto exit;
 776                 }
 777         }
 778
 779         /* redirect std{out,err} */
 780         if (!debug) {
 781                 dup2(fd, STDOUT_FILENO);
 782                 dup2(fd, STDERR_FILENO);
 783         }
 784         if (fd > STDERR_FILENO)
 785                 close(fd);
 786
 787         /* set scheduling priority for the daemon */
 788         setpriority(PRIO_PROCESS, 0, UDEVD_PRIORITY);
 789
 790         chdir("/");
 791         umask(022);
 792         setsid();
 793
 794         /* OOM_DISABLE == -17 */
 795         fd = open("/proc/self/oom_adj", O_RDWR);
 796         if (fd < 0)
 797                 err(udev, "error disabling OOM: %m\n");
 798         else {
 799                 write(fd, "-17", 3);
 800                 close(fd);
 801         }
 802
 803         fd = open("/dev/kmsg", O_WRONLY);
 804         if (fd > 0) {
 805                 const char *ver_str = "<6>udev: starting version " VERSION "\n";
 806                 char path[UTIL_PATH_SIZE];
 807                 struct stat statbuf;
 808
 809                 write(fd, ver_str, strlen(ver_str));
 810                 util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
 811                 util_strlcat(path, "/class/mem/null", sizeof(path));
 812                 if (lstat(path, &statbuf) == 0) {
 813                         if (S_ISDIR(statbuf.st_mode)) {
 814                                 const char *depr_str = "<6>udev: deprecated sysfs layout (kernel too old, "
 815                                                         "or CONFIG_SYSFS_DEPRECATED) is unsupported, some "
 816                                                         "udev features may fail\n";
 817
 818                                 write(fd, depr_str, strlen(depr_str));
 819                         }
 820                 }
 821                 close(fd);
 822         }
 823
 824         /* set signal handlers */
 825         memset(&act, 0x00, sizeof(struct sigaction));
 826         act.sa_handler = (void (*)(int)) sig_handler;
 827         sigemptyset(&act.sa_mask);
 828         act.sa_flags = SA_RESTART;
 829         sigaction(SIGINT, &act, NULL);
 830         sigaction(SIGTERM, &act, NULL);
 831         sigaction(SIGCHLD, &act, NULL);
 832         sigaction(SIGHUP, &act, NULL);
 833
 834         /* watch rules directory */
 835         inotify_fd = inotify_init();
 836         if (inotify_fd >= 0) {
 837                 if (udev_get_rules_path(udev) != NULL) {
 838                         inotify_add_watch(inotify_fd, udev_get_rules_path(udev),
 839                                           IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 840                 } else {
 841                         char filename[PATH_MAX];
 842
 843                         inotify_add_watch(inotify_fd, UDEV_PREFIX "/lib/udev/rules.d",
 844                                           IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 845                         inotify_add_watch(inotify_fd, SYSCONFDIR "/udev/rules.d",
 846                                           IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 847
 848                         /* watch dynamic rules directory */
 849                         util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
 850                         util_strlcat(filename, "/.udev/rules.d", sizeof(filename));
 851                         inotify_add_watch(inotify_fd, filename,
 852                                           IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
 853                 }
 854         } else if (errno == ENOSYS)
 855                 err(udev, "the kernel does not support inotify, udevd can't monitor rules file changes\n");
 856         else
 857                 err(udev, "inotify_init failed: %m\n");
 858
 859         /* maximum limit of forked childs */
 860         value = getenv("UDEVD_MAX_CHILDS");
 861         if (value)
 862                 max_childs = strtoul(value, NULL, 10);
 863         else {
 864                 int memsize = mem_size_mb();
 865                 if (memsize > 0)
 866                         max_childs = 128 + (memsize / 4);
 867                 else
 868                         max_childs = UDEVD_MAX_CHILDS;
 869         }
 870         info(udev, "initialize max_childs to %u\n", max_childs);
 871
 872         maxfd = udev_ctrl_get_fd(udev_ctrl);
 873         maxfd = UDEV_MAX(maxfd, udev_monitor_get_fd(kernel_monitor));
 874         maxfd = UDEV_MAX(maxfd, signal_pipe[READ_END]);
 875         maxfd = UDEV_MAX(maxfd, inotify_fd);
 876         while (!udev_exit) {
 877                 int fdcount;
 878
 879                 FD_ZERO(&readfds);
 880                 FD_SET(signal_pipe[READ_END], &readfds);
 881                 FD_SET(udev_ctrl_get_fd(udev_ctrl), &readfds);
 882                 FD_SET(udev_monitor_get_fd(kernel_monitor), &readfds);
 883                 if (inotify_fd >= 0)
 884                         FD_SET(inotify_fd, &readfds);
 885                 fdcount = select(maxfd+1, &readfds, NULL, NULL, NULL);
 886                 if (fdcount < 0) {
 887                         if (errno != EINTR)
 888                                 err(udev, "error in select: %m\n");
 889                         continue;
 890                 }
 891
 892                 /* get control message */
 893                 if (FD_ISSET(udev_ctrl_get_fd(udev_ctrl), &readfds))
 894                         handle_ctrl_msg(udev_ctrl);
 895
 896                 /* get kernel uevent */
 897                 if (FD_ISSET(udev_monitor_get_fd(kernel_monitor), &readfds)) {
 898                         struct udev_device *dev;
 899
 900                         dev = udev_monitor_receive_device(kernel_monitor);
 901                         if (dev != NULL) {
 902                                 struct udev_event *event;
 903
 904                                 event = udev_event_new(dev);
 905                                 if (event != NULL)
 906                                         event_queue_insert(event);
 907                                 else
 908                                         udev_device_unref(dev);
 909                         }
 910                 }
 911
 912                 /* received a signal, clear our notification pipe */
 913                 if (FD_ISSET(signal_pipe[READ_END], &readfds)) {
 914                         char buf[256];
 915
 916                         read(signal_pipe[READ_END], &buf, sizeof(buf));
 917                 }
 918
 919                 /* rules directory inotify watch */
 920                 if ((inotify_fd >= 0) && FD_ISSET(inotify_fd, &readfds)) {
 921                         int nbytes;
 922
 923                         /* discard all possible events, we can just reload the config */
 924                         if ((ioctl(inotify_fd, FIONREAD, &nbytes) == 0) && nbytes > 0) {
 925                                 char *buf;
 926
 927                                 reload_config = 1;
 928                                 buf = malloc(nbytes);
 929                                 if (buf == NULL) {
 930                                         err(udev, "error getting buffer for inotify, disable watching\n");
 931                                         close(inotify_fd);
 932                                         inotify_fd = -1;
 933                                 }
 934                                 read(inotify_fd, buf, nbytes);
 935                                 free(buf);
 936                         }
 937                 }
 938
 939                 /* rules changed, set by inotify or a HUP signal */
 940                 if (reload_config) {
 941                         struct udev_rules *rules_new;
 942
 943                         reload_config = 0;
 944                         rules_new = udev_rules_new(udev, 1);
 945                         if (rules_new != NULL) {
 946                                 udev_rules_unref(rules);
 947                                 rules = rules_new;
 948                         }
 949                 }
 950
 951                 if (sigchilds_waiting) {
 952                         sigchilds_waiting = 0;
 953                         reap_sigchilds();
 954                 }
 955
 956                 if (run_exec_q) {
 957                         run_exec_q = 0;
 958                         if (!stop_exec_q)
 959                                 event_queue_manager(udev);
 960                 }
 961         }
 962         rc = 0;
 963
 964 exit:
 965         udev_rules_unref(rules);
 966
 967         if (signal_pipe[READ_END] >= 0)
 968                 close(signal_pipe[READ_END]);
 969         if (signal_pipe[WRITE_END] >= 0)
 970                 close(signal_pipe[WRITE_END]);
 971
 972         udev_ctrl_unref(udev_ctrl);
 973         if (inotify_fd >= 0)
 974                 close(inotify_fd);
 975         udev_monitor_unref(kernel_monitor);
 976
 977         selinux_exit(udev);
 978         udev_unref(udev);
 979         logging_close();
 980         return rc;
 981 }