]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/main.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
socket: enforce limit on number of concurrent connections
[thirdparty/systemd.git] / src / main.c
CommitLineData
60918275
LP		 1/*-*- Mode: C; c-basic-offset: 8 -*-*/
2
a7334b09
LP		 3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
ea430986
LP		 22#include <dbus/dbus.h>
23
60918275
LP		 24#include <stdio.h>
25#include <errno.h>
26#include <string.h>
16354eff 27#include <unistd.h>
4ade7963
LP		 28#include <sys/types.h>
29#include <sys/stat.h>
f170852a 30#include <getopt.h>
97c4f35c 31#include <signal.h>
4fc935ca 32#include <sys/wait.h>
80876c20 33#include <fcntl.h>
60918275
LP		 34
35#include "manager.h"
16354eff 36#include "log.h"
4ade7963 37#include "mount-setup.h"
302e8c4c 38#include "hostname-setup.h"
af5bc85d 39#include "loopback-setup.h"
11c3a4ee 40#include "kmod-setup.h"
302e8c4c 41#include "load-fragment.h"
a16e1123 42#include "fdset.h"
514f4ef5 43#include "special.h"
60918275 44
f170852a
LP		 45static enum {
46 ACTION_RUN,
e965d56d 47 ACTION_HELP,
e537352b 48 ACTION_TEST,
4288f619
LP		 49 ACTION_DUMP_CONFIGURATION_ITEMS,
50 ACTION_DONE
f170852a
LP		 51} action = ACTION_RUN;
52
53static char *default_unit = NULL;
a5dab5ce 54static ManagerRunningAs running_as = _MANAGER_RUNNING_AS_INVALID;
4fc935ca 55
97c4f35c 56static bool dump_core = true;
601f6a1e
LP		 57static bool crash_shell = false;
58static int crash_chvt = -1;
80876c20 59static bool confirm_spawn = false;
a16e1123 60static FILE* serialization = NULL;
80876c20 61
93a46b0b 62_noreturn_ static void freeze(void) {
97c4f35c
LP		 63 for (;;)
64 pause();
65}
66
6f5e3f35
LP		 67static void nop_handler(int sig) {
68}
69
93a46b0b 70_noreturn_ static void crash(int sig) {
97c4f35c
LP		 71
72 if (!dump_core)
73 log_error("Caught <%s>, not dumping core.", strsignal(sig));
74 else {
6f5e3f35 75 struct sigaction sa;
97c4f35c
LP		 76 pid_t pid;
77
6f5e3f35
LP		 78 /* We want to wait for the core process, hence let's enable SIGCHLD */
79 zero(sa);
80 sa.sa_handler = nop_handler;
81 sa.sa_flags = SA_NOCLDSTOP|SA_RESTART;
82 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
83
97c4f35c 84 if ((pid = fork()) < 0)
4fc935ca 85 log_error("Caught <%s>, cannot fork for core dump: %s", strsignal(sig), strerror(errno));
97c4f35c
LP		 86
87 else if (pid == 0) {
97c4f35c
LP		 88 struct rlimit rl;
89
90 /* Enable default signal handler for core dump */
91 zero(sa);
92 sa.sa_handler = SIG_DFL;
93 assert_se(sigaction(sig, &sa, NULL) == 0);
94
95 /* Don't limit the core dump size */
96 zero(rl);
97 rl.rlim_cur = RLIM_INFINITY;
98 rl.rlim_max = RLIM_INFINITY;
99 setrlimit(RLIMIT_CORE, &rl);
100
101 /* Just to be sure... */
102 assert_se(chdir("/") == 0);
103
104 /* Raise the signal again */
105 raise(sig);
106
107 assert_not_reached("We shouldn't be here...");
108 _exit(1);
4fc935ca
LP		 109
110 } else {
111 int status, r;
112
113 /* Order things nicely. */
114 if ((r = waitpid(pid, &status, 0)) < 0)
115 log_error("Caught <%s>, waitpid() failed: %s", strsignal(sig), strerror(errno));
116 else if (!WCOREDUMP(status))
117 log_error("Caught <%s>, core dump failed.", strsignal(sig));
118 else
119 log_error("Caught <%s>, dumped core as pid %llu.", strsignal(sig), (unsigned long long) pid);
97c4f35c
LP		 120 }
121 }
122
601f6a1e
LP		 123 if (crash_chvt)
124 chvt(crash_chvt);
125
4fc935ca 126 if (crash_shell) {
6f5e3f35
LP		 127 struct sigaction sa;
128 pid_t pid;
8c43883a 129
4fc935ca
LP		 130 log_info("Executing crash shell in 10s...");
131 sleep(10);
132
6f5e3f35
LP		 133 /* Let the kernel reap children for us */
134 zero(sa);
135 sa.sa_handler = SIG_IGN;
136 sa.sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART;
137 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
8c43883a 138
6f5e3f35
LP		 139 if ((pid = fork()) < 0)
140 log_error("Failed to fork off crash shell: %s", strerror(errno));
141 else if (pid == 0) {
843d2643 142 int fd, r;
ea5652c2 143
21de3988 144 if ((fd = acquire_terminal("/dev/console", false, true, true)) < 0)
ea5652c2 145 log_error("Failed to acquire terminal: %s", strerror(-fd));
5b2a0903 146 else if ((r = make_stdio(fd)) < 0)
843d2643 147 log_error("Failed to duplicate terminal fd: %s", strerror(-r));
ea5652c2 148
6f5e3f35
LP		 149 execl("/bin/sh", "/bin/sh", NULL);
150
151 log_error("execl() failed: %s", strerror(errno));
152 _exit(1);
153 }
c99b188e 154
6f5e3f35 155 log_info("Successfully spawned crash shall as pid %llu.", (unsigned long long) pid);
4fc935ca
LP		 156 }
157
158 log_info("Freezing execution.");
97c4f35c
LP		 159 freeze();
160}
161
162static void install_crash_handler(void) {
163 struct sigaction sa;
164
165 zero(sa);
166
167 sa.sa_handler = crash;
168 sa.sa_flags = SA_NODEFER;
169
1b91d3e8 170 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
97c4f35c 171}
f170852a 172
843d2643
LP		 173static int make_null_stdio(void) {
174 int null_fd, r;
80876c20 175
c8513d54 176 if ((null_fd = open("/dev/null", O_RDWR|O_NOCTTY)) < 0) {
80876c20 177 log_error("Failed to open /dev/null: %m");
843d2643 178 return -errno;
80876c20
LP		 179 }
180
843d2643
LP		 181 if ((r = make_stdio(null_fd)) < 0)
182 log_warning("Failed to dup2() device: %s", strerror(-r));
80876c20 183
843d2643
LP		 184 return r;
185}
80876c20 186
843d2643
LP		 187static int console_setup(bool do_reset) {
188 int tty_fd, r;
80876c20 189
843d2643
LP		 190 /* If we are init, we connect stdin/stdout/stderr to /dev/null
191 * and make sure we don't have a controlling tty. */
80876c20 192
843d2643
LP		 193 release_terminal();
194
195 if (!do_reset)
196 return 0;
80876c20 197
843d2643
LP		 198 if ((tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC)) < 0) {
199 log_error("Failed to open /dev/console: %s", strerror(-tty_fd));
200 return -tty_fd;
201 }
80876c20 202
843d2643
LP		 203 if ((r = reset_terminal(tty_fd)) < 0)
204 log_error("Failed to reset /dev/console: %s", strerror(-r));
205
206 close_nointr_nofail(tty_fd);
80876c20
LP		 207 return r;
208}
209
f170852a
LP		 210static int set_default_unit(const char *u) {
211 char *c;
212
213 assert(u);
214
215 if (!(c = strdup(u)))
216 return -ENOMEM;
217
218 free(default_unit);
219 default_unit = c;
220 return 0;
221}
222
223static int parse_proc_cmdline_word(const char *word) {
224
225 static const char * const rlmap[] = {
514f4ef5
LP		 226 "single", SPECIAL_RESCUE_TARGET,
227 "-s", SPECIAL_RESCUE_TARGET,
228 "s", SPECIAL_RESCUE_TARGET,
229 "S", SPECIAL_RESCUE_TARGET,
230 "1", SPECIAL_RESCUE_TARGET,
f170852a
LP		 231 "2", SPECIAL_RUNLEVEL2_TARGET,
232 "3", SPECIAL_RUNLEVEL3_TARGET,
233 "4", SPECIAL_RUNLEVEL4_TARGET,
234 "5", SPECIAL_RUNLEVEL5_TARGET
235 };
236
2f198e2f
LP		 237 if (startswith(word, "systemd.unit="))
238 return set_default_unit(word + 13);
f170852a
LP		 239
240 else if (startswith(word, "systemd.log_target=")) {
241
242 if (log_set_target_from_string(word + 19) < 0)
243 log_warning("Failed to parse log target %s. Ignoring.", word + 19);
244
245 } else if (startswith(word, "systemd.log_level=")) {
246
247 if (log_set_max_level_from_string(word + 18) < 0)
248 log_warning("Failed to parse log level %s. Ignoring.", word + 18);
249
bbe63281
LP		 250 } else if (startswith(word, "systemd.log_color=")) {
251
252 if (log_show_color_from_string(word + 18) < 0)
253 log_warning("Failed to parse log color setting %s. Ignoring.", word + 18);
254
255 } else if (startswith(word, "systemd.log_location=")) {
256
257 if (log_show_location_from_string(word + 21) < 0)
258 log_warning("Failed to parse log location setting %s. Ignoring.", word + 21);
259
4fc935ca
LP		 260 } else if (startswith(word, "systemd.dump_core=")) {
261 int r;
262
263 if ((r = parse_boolean(word + 18)) < 0)
601f6a1e 264 log_warning("Failed to parse dump core switch %s, Ignoring.", word + 18);
4fc935ca
LP		 265 else
266 dump_core = r;
267
268 } else if (startswith(word, "systemd.crash_shell=")) {
269 int r;
270
271 if ((r = parse_boolean(word + 20)) < 0)
601f6a1e 272 log_warning("Failed to parse crash shell switch %s, Ignoring.", word + 20);
4fc935ca
LP		 273 else
274 crash_shell = r;
275
5e7ee61c
LP		 276
277 } else if (startswith(word, "systemd.confirm_spawn=")) {
278 int r;
279
280 if ((r = parse_boolean(word + 22)) < 0)
281 log_warning("Failed to parse confirm spawn switch %s, Ignoring.", word + 22);
282 else
283 confirm_spawn = r;
284
601f6a1e
LP		 285 } else if (startswith(word, "systemd.crash_chvt=")) {
286 int k;
287
288 if (safe_atoi(word + 19, &k) < 0)
289 log_warning("Failed to parse crash chvt switch %s, Ignoring.", word + 19);
290 else
291 crash_chvt = k;
292
4fc935ca
LP		 293 } else if (startswith(word, "systemd.")) {
294
295 log_warning("Unknown kernel switch %s. Ignoring.", word);
296
bbe63281
LP		 297 log_info("Supported kernel switches:\n"
298 "systemd.unit=UNIT Default unit to start\n"
299 "systemd.log_target=console|kmsg|syslog| Log target\n"
300 " syslog-org-kmsg|null\n"
301 "systemd.log_level=LEVEL Log level\n"
302 "systemd.log_color=0|1 Highlight important log messages\n"
303 "systemd.log_location=0|1 Include code location in log messages\n"
304 "systemd.dump_core=0|1 Dump core on crash\n"
305 "systemd.crash_shell=0|1 On crash run shell\n"
306 "systemd.crash_chvt=N Change to VT #N on crash\n"
307 "systemd.confirm_spawn=0|1 Confirm every process spawn");
4fc935ca 308
f170852a
LP		 309 } else {
310 unsigned i;
311
312 /* SysV compatibility */
f170852a
LP		 313 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
314 if (streq(word, rlmap[i]))
315 return set_default_unit(rlmap[i+1]);
316 }
317
318 return 0;
319}
320
321static int parse_proc_cmdline(void) {
322 char *line;
323 int r;
324 char *w;
325 size_t l;
326 char *state;
327
328 if ((r = read_one_line_file("/proc/cmdline", &line)) < 0) {
329 log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(errno));
330 return 0;
331 }
332
333 FOREACH_WORD_QUOTED(w, l, line, state) {
334 char *word;
335
336 if (!(word = strndup(w, l))) {
337 r = -ENOMEM;
338 goto finish;
339 }
340
341 r = parse_proc_cmdline_word(word);
342 free(word);
343
344 if (r < 0)
345 goto finish;
346 }
347
348 r = 0;
349
350finish:
351 free(line);
352 return r;
353}
354
355static int parse_argv(int argc, char *argv[]) {
356
357 enum {
358 ARG_LOG_LEVEL = 0x100,
359 ARG_LOG_TARGET,
bbe63281
LP		 360 ARG_LOG_COLOR,
361 ARG_LOG_LOCATION,
2f198e2f 362 ARG_UNIT,
e965d56d 363 ARG_RUNNING_AS,
e537352b 364 ARG_TEST,
80876c20 365 ARG_DUMP_CONFIGURATION_ITEMS,
a16e1123 366 ARG_CONFIRM_SPAWN,
4288f619
LP		 367 ARG_DESERIALIZE,
368 ARG_INTROSPECT
f170852a
LP		 369 };
370
371 static const struct option options[] = {
a16e1123
LP		 372 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
373 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
bbe63281
LP		 374 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
375 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
2f198e2f 376 { "unit", required_argument, NULL, ARG_UNIT },
a16e1123
LP		 377 { "running-as", required_argument, NULL, ARG_RUNNING_AS },
378 { "test", no_argument, NULL, ARG_TEST },
379 { "help", no_argument, NULL, 'h' },
380 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
381 { "confirm-spawn", no_argument, NULL, ARG_CONFIRM_SPAWN },
382 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
4288f619 383 { "introspect", optional_argument, NULL, ARG_INTROSPECT },
a16e1123 384 { NULL, 0, NULL, 0 }
f170852a
LP		 385 };
386
387 int c, r;
388
389 assert(argc >= 1);
390 assert(argv);
391
392 while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
393
394 switch (c) {
395
396 case ARG_LOG_LEVEL:
397 if ((r = log_set_max_level_from_string(optarg)) < 0) {
398 log_error("Failed to parse log level %s.", optarg);
399 return r;
400 }
401
402 break;
403
404 case ARG_LOG_TARGET:
405
406 if ((r = log_set_target_from_string(optarg)) < 0) {
407 log_error("Failed to parse log target %s.", optarg);
408 return r;
409 }
410
411 break;
412
bbe63281
LP		 413 case ARG_LOG_COLOR:
414
d0b170c8
LP		 415 if (optarg) {
416 if ((r = log_show_color_from_string(optarg)) < 0) {
417 log_error("Failed to parse log color setting %s.", optarg);
418 return r;
419 }
420 } else
421 log_show_color(true);
bbe63281
LP		 422
423 break;
424
425 case ARG_LOG_LOCATION:
426
d0b170c8
LP		 427 if (optarg) {
428 if ((r = log_show_location_from_string(optarg)) < 0) {
429 log_error("Failed to parse log location setting %s.", optarg);
430 return r;
431 }
432 } else
433 log_show_location(true);
bbe63281
LP		 434
435 break;
436
2f198e2f 437 case ARG_UNIT:
f170852a
LP		 438
439 if ((r = set_default_unit(optarg)) < 0) {
440 log_error("Failed to set default unit %s: %s", optarg, strerror(-r));
441 return r;
442 }
443
444 break;
445
a5dab5ce
LP		 446 case ARG_RUNNING_AS: {
447 ManagerRunningAs as;
448
449 if ((as = manager_running_as_from_string(optarg)) < 0) {
450 log_error("Failed to parse running as value %s", optarg);
451 return -EINVAL;
452 }
453
454 running_as = as;
455 break;
456 }
457
e965d56d
LP		 458 case ARG_TEST:
459 action = ACTION_TEST;
460 break;
461
e537352b
LP		 462 case ARG_DUMP_CONFIGURATION_ITEMS:
463 action = ACTION_DUMP_CONFIGURATION_ITEMS;
464 break;
465
80876c20
LP		 466 case ARG_CONFIRM_SPAWN:
467 confirm_spawn = true;
468 break;
469
a16e1123
LP		 470 case ARG_DESERIALIZE: {
471 int fd;
472 FILE *f;
473
474 if ((r = safe_atoi(optarg, &fd)) < 0 || fd < 0) {
475 log_error("Failed to parse deserialize option %s.", optarg);
476 return r;
477 }
478
479 if (!(f = fdopen(fd, "r"))) {
480 log_error("Failed to open serialization fd: %m");
481 return r;
482 }
483
484 if (serialization)
485 fclose(serialization);
486
487 serialization = f;
488
489 break;
490 }
491
4288f619
LP		 492 case ARG_INTROSPECT: {
493 const char * const * i = NULL;
494
495 for (i = bus_interface_table; *i; i += 2)
496 if (!optarg || streq(i[0], optarg)) {
497 fputs(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE
498 "<node>\n", stdout);
499 fputs(i[1], stdout);
500 fputs("</node>\n", stdout);
501
502 if (optarg)
503 break;
504 }
505
506 if (!i[0] && optarg)
507 log_error("Unknown interface %s.", optarg);
508
509 action = ACTION_DONE;
510 break;
511 }
512
f170852a
LP		 513 case 'h':
514 action = ACTION_HELP;
515 break;
516
517 case '?':
518 return -EINVAL;
519
520 default:
521 log_error("Unknown option code %c", c);
522 return -EINVAL;
523 }
524
51f0e189
LP		 525 /* PID 1 will get the kernel arguments as parameters, which we
526 * ignore and unconditionally read from
527 * /proc/cmdline. However, we need to ignore those arguments
528 * here. */
a3d4e06d 529 if (running_as != MANAGER_SYSTEM && optind < argc) {
51f0e189
LP		 530 log_error("Excess arguments.");
531 return -EINVAL;
532 }
533
f170852a
LP		 534 return 0;
535}
536
537static int help(void) {
538
539 printf("%s [options]\n\n"
bbe63281 540 "Starts up and maintains the system or a session.\n\n"
e537352b 541 " -h --help Show this help\n"
41192f6e 542 " --unit=UNIT Set default unit\n"
a3d4e06d 543 " --running-as=AS Set running as (system, session)\n"
e537352b 544 " --test Determine startup sequence, dump it and exit\n"
80876c20 545 " --dump-configuration-items Dump understood unit configuration items\n"
4288f619 546 " --confirm-spawn Ask for confirmation when spawning processes\n"
bbe63281
LP		 547 " --introspect[=INTERFACE] Extract D-Bus interface data\n"
548 " --log-level=LEVEL Set log level\n"
549 " --log-target=TARGET Set log target (console, syslog, kmsg, syslog-or-kmsg, null)\n"
550 " --log-color[=0|1] Highlight import log messages\n"
551 " --log-location[=0|1] Include code location in log messages\n",
5b6319dc 552 program_invocation_short_name);
f170852a
LP		 553
554 return 0;
555}
556
a16e1123
LP		 557static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds) {
558 FILE *f = NULL;
559 FDSet *fds = NULL;
560 int r;
561
562 assert(m);
563 assert(_f);
564 assert(_fds);
565
566 if ((r = manager_open_serialization(&f)) < 0) {
567 log_error("Failed to create serialization faile: %s", strerror(-r));
568 goto fail;
569 }
570
571 if (!(fds = fdset_new())) {
572 r = -ENOMEM;
573 log_error("Failed to allocate fd set: %s", strerror(-r));
574 goto fail;
575 }
576
577 if ((r = manager_serialize(m, f, fds)) < 0) {
578 log_error("Failed to serialize state: %s", strerror(-r));
579 goto fail;
580 }
581
582 if (fseeko(f, 0, SEEK_SET) < 0) {
583 log_error("Failed to rewind serialization fd: %m");
584 goto fail;
585 }
586
587 if ((r = fd_cloexec(fileno(f), false)) < 0) {
588 log_error("Failed to disable O_CLOEXEC for serialization: %s", strerror(-r));
589 goto fail;
590 }
591
592 if ((r = fdset_cloexec(fds, false)) < 0) {
593 log_error("Failed to disable O_CLOEXEC for serialization fds: %s", strerror(-r));
594 goto fail;
595 }
596
597 *_f = f;
598 *_fds = fds;
599
600 return 0;
601
602fail:
603 fdset_free(fds);
604
605 if (f)
606 fclose(f);
607
608 return r;
609}
610
60918275
LP		 611int main(int argc, char *argv[]) {
612 Manager *m = NULL;
87f0e418 613 Unit *target = NULL;
60918275
LP		 614 Job *job = NULL;
615 int r, retval = 1;
a16e1123
LP		 616 FDSet *fds = NULL;
617 bool reexecute = false;
27b14a22 618
2cb1a60d
LP		 619 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
620 /* This is compatbility support for SysV, where
621 * calling init as a user is identical to telinit. */
622
623 errno = -ENOENT;
624 execv(SYSTEMCTL_BINARY_PATH, argv);
625 log_error("Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
626 return 1;
627 }
628
bbe63281
LP		 629 log_show_color(true);
630 log_show_location(false);
631 log_set_max_level(LOG_DEBUG);
632
843d2643 633 if (getpid() == 1) {
a3d4e06d 634 running_as = MANAGER_SYSTEM;
843d2643 635 log_set_target(LOG_TARGET_SYSLOG_OR_KMSG);
bbe63281 636 } else {
a5dab5ce 637 running_as = MANAGER_SESSION;
bbe63281
LP		 638 log_set_target(LOG_TARGET_CONSOLE);
639 }
a5dab5ce 640
f170852a
LP		 641 if (set_default_unit(SPECIAL_DEFAULT_TARGET) < 0)
642 goto finish;
60918275 643
f170852a
LP		 644 /* Mount /proc, /sys and friends, so that /proc/cmdline and
645 * /proc/$PID/fd is available. */
8efe3c01
LP		 646 if (geteuid() == 0)
647 if (mount_setup() < 0)
648 goto finish;
4ade7963
LP		 649
650 /* Reset all signal handlers. */
651 assert_se(reset_all_signal_handlers() == 0);
652
078e4539 653 /* If we are init, we can block sigkill. Yay. */
9a34ec5f 654 ignore_signals(SIGNALS_IGNORE, -1);
078e4539 655
a3d4e06d 656 if (running_as == MANAGER_SYSTEM)
a5dab5ce
LP		 657 if (parse_proc_cmdline() < 0)
658 goto finish;
f170852a
LP		 659
660 log_parse_environment();
661
662 if (parse_argv(argc, argv) < 0)
663 goto finish;
664
665 if (action == ACTION_HELP) {
666 retval = help();
667 goto finish;
e537352b
LP		 668 } else if (action == ACTION_DUMP_CONFIGURATION_ITEMS) {
669 unit_dump_config_items(stdout);
670 retval = 0;
671 goto finish;
4288f619
LP		 672 } else if (action == ACTION_DONE) {
673 retval = 0;
674 goto finish;
f170852a
LP		 675 }
676
e965d56d 677 assert_se(action == ACTION_RUN || action == ACTION_TEST);
f170852a 678
a16e1123
LP		 679 /* Remember open file descriptors for later deserialization */
680 if (serialization) {
681 if ((r = fdset_new_fill(&fds)) < 0) {
682 log_error("Failed to allocate fd set: %s", strerror(-r));
683 goto finish;
684 }
685
686 assert_se(fdset_remove(fds, fileno(serialization)) >= 0);
687 } else
688 close_all_fds(NULL, 0);
689
09082a94 690 /* Set up PATH unless it is already set */
e537352b
LP		 691 setenv("PATH",
692 "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
a3d4e06d 693 running_as == MANAGER_SYSTEM);
09082a94 694
f170852a
LP		 695 /* Move out of the way, so that we won't block unmounts */
696 assert_se(chdir("/") == 0);
697
a3d4e06d 698 if (running_as == MANAGER_SYSTEM) {
80876c20
LP		 699 /* Become a session leader if we aren't one yet. */
700 setsid();
4ade7963 701
80876c20
LP		 702 /* Disable the umask logic */
703 umask(0);
704 }
705
843d2643
LP		 706 /* Make sure D-Bus doesn't fiddle with the SIGPIPE handlers */
707 dbus_connection_set_change_sigpipe(FALSE);
708
2146621b
LP		 709 /* Reset the console, but only if this is really init and we
710 * are freshly booted */
a3d4e06d 711 if (running_as == MANAGER_SYSTEM && action == ACTION_RUN) {
2146621b 712 console_setup(getpid() == 1 && !serialization);
843d2643
LP		 713 make_null_stdio();
714 }
4ade7963 715
18149b9f 716 /* Open the logging devices, if possible and necessary */
843d2643 717 log_open();
4ade7963 718
5373d602
LP		 719 /* Make sure we leave a core dump without panicing the
720 * kernel. */
4fc935ca
LP		 721 if (getpid() == 1)
722 install_crash_handler();
97c4f35c 723
a5dab5ce
LP		 724 log_debug("systemd running in %s mode.", manager_running_as_to_string(running_as));
725
a3d4e06d 726 if (running_as == MANAGER_SYSTEM) {
11c3a4ee 727 kmod_setup();
e537352b 728 hostname_setup();
af5bc85d
LP		 729 loopback_setup();
730 }
302e8c4c 731
80876c20 732 if ((r = manager_new(running_as, confirm_spawn, &m)) < 0) {
8e274523 733 log_error("Failed to allocate manager object: %s", strerror(-r));
60918275
LP		 734 goto finish;
735 }
736
a16e1123 737 if ((r = manager_startup(m, serialization, fds)) < 0)
6e2ef85b 738 log_error("Failed to fully start up daemon: %s", strerror(-r));
a16e1123
LP		 739
740 if (fds) {
741 /* This will close all file descriptors that were opened, but
742 * not claimed by any unit. */
743
744 fdset_free(fds);
745 fds = NULL;
f50e0a01
LP		 746 }
747
a16e1123
LP		 748 if (serialization) {
749 fclose(serialization);
750 serialization = NULL;
751 } else {
752 log_debug("Activating default unit: %s", default_unit);
753
754 if ((r = manager_load_unit(m, default_unit, NULL, &target)) < 0) {
755 log_error("Failed to load default target: %s", strerror(-r));
27b14a22 756
a16e1123
LP		 757 log_info("Trying to load rescue target...");
758 if ((r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &target)) < 0) {
759 log_error("Failed to load rescue target: %s", strerror(-r));
760 goto finish;
761 }
762 }
37d88da7 763
a16e1123 764 if (action == ACTION_TEST) {
40d50879 765 printf("-> By units:\n");
a16e1123
LP		 766 manager_dump_units(m, stdout, "\t");
767 }
768
769 if ((r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &job)) < 0) {
770 log_error("Failed to start default target: %s", strerror(-r));
37d88da7
LP		 771 goto finish;
772 }
60918275 773
a16e1123 774 if (action == ACTION_TEST) {
40d50879 775 printf("-> By jobs:\n");
a16e1123
LP		 776 manager_dump_jobs(m, stdout, "\t");
777 retval = 0;
778 goto finish;
779 }
e965d56d 780 }
d46de8a1 781
a16e1123
LP		 782 for (;;) {
783 if ((r = manager_loop(m)) < 0) {
784 log_error("Failed to run mainloop: %s", strerror(-r));
785 goto finish;
786 }
11dd41ce 787
a16e1123 788 switch (m->exit_code) {
e965d56d 789
a16e1123
LP		 790 case MANAGER_EXIT:
791 retval = 0;
792 log_debug("Exit.");
793 goto finish;
e965d56d 794
a16e1123
LP		 795 case MANAGER_RELOAD:
796 if ((r = manager_reload(m)) < 0)
797 log_error("Failed to reload: %s", strerror(-r));
798 break;
cea8e32e 799
a16e1123 800 case MANAGER_REEXECUTE:
a16e1123
LP		 801 if (prepare_reexecute(m, &serialization, &fds) < 0)
802 goto finish;
60918275 803
a16e1123
LP		 804 reexecute = true;
805 log_debug("Reexecuting.");
806 goto finish;
807
808 default:
809 assert_not_reached("Unknown exit code.");
810 }
811 }
f170852a 812
60918275
LP		 813finish:
814 if (m)
815 manager_free(m);
816
f170852a 817 free(default_unit);
b9cd2ec1 818
ea430986
LP		 819 dbus_shutdown();
820
a16e1123
LP		 821 if (reexecute) {
822 const char *args[11];
823 unsigned i = 0;
824 char sfd[16];
825
826 assert(serialization);
827 assert(fds);
828
829 args[i++] = SYSTEMD_BINARY_PATH;
830
831 args[i++] = "--log-level";
832 args[i++] = log_level_to_string(log_get_max_level());
833
834 args[i++] = "--log-target";
835 args[i++] = log_target_to_string(log_get_target());
836
837 args[i++] = "--running-as";
838 args[i++] = manager_running_as_to_string(running_as);
839
840 snprintf(sfd, sizeof(sfd), "%i", fileno(serialization));
841 char_array_0(sfd);
842
843 args[i++] = "--deserialize";
844 args[i++] = sfd;
845
846 if (confirm_spawn)
847 args[i++] = "--confirm-spawn";
848
849 args[i++] = NULL;
850
851 assert(i <= ELEMENTSOF(args));
852
853 execv(args[0], (char* const*) args);
854
855 log_error("Failed to reexecute: %m");
856 }
857
858 if (serialization)
859 fclose(serialization);
860
861 if (fds)
862 fdset_free(fds);
863
c3b3c274
LP		 864 if (getpid() == 1)
865 freeze();
866
60918275
LP		 867 return retval;
868}
Unnamed repository; edit this file 'description' to name the repository.