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