]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/main.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
treewide: another round of simplifications
[thirdparty/systemd.git] / src / core / main.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
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 Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <stdio.h>
23 #include <errno.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <getopt.h>
29 #include <signal.h>
30 #include <sys/wait.h>
31 #include <fcntl.h>
32 #include <sys/prctl.h>
33 #include <sys/mount.h>
34
35 #ifdef HAVE_VALGRIND_VALGRIND_H
36 #include <valgrind/valgrind.h>
37 #endif
38 #ifdef HAVE_SECCOMP
39 #include <seccomp.h>
40 #endif
41
42 #include "sd-daemon.h"
43 #include "sd-messages.h"
44 #include "sd-bus.h"
45 #include "manager.h"
46 #include "log.h"
47 #include "load-fragment.h"
48 #include "fdset.h"
49 #include "special.h"
50 #include "conf-parser.h"
51 #include "missing.h"
52 #include "label.h"
53 #include "pager.h"
54 #include "build.h"
55 #include "strv.h"
56 #include "def.h"
57 #include "virt.h"
58 #include "architecture.h"
59 #include "watchdog.h"
60 #include "path-util.h"
61 #include "switch-root.h"
62 #include "capability.h"
63 #include "killall.h"
64 #include "env-util.h"
65 #include "clock-util.h"
66 #include "fileio.h"
67 #include "dbus-manager.h"
68 #include "bus-error.h"
69 #include "bus-util.h"
70
71 #include "mount-setup.h"
72 #include "loopback-setup.h"
73 #include "hostname-setup.h"
74 #include "machine-id-setup.h"
75 #include "selinux-setup.h"
76 #include "ima-setup.h"
77 #include "smack-setup.h"
78 #include "kmod-setup.h"
79
80 static enum {
81 ACTION_RUN,
82 ACTION_HELP,
83 ACTION_VERSION,
84 ACTION_TEST,
85 ACTION_DUMP_CONFIGURATION_ITEMS,
86 ACTION_DONE
87 } arg_action = ACTION_RUN;
88 static char *arg_default_unit = NULL;
89 static SystemdRunningAs arg_running_as = _SYSTEMD_RUNNING_AS_INVALID;
90 static bool arg_dump_core = true;
91 static bool arg_crash_shell = false;
92 static int arg_crash_chvt = -1;
93 static bool arg_confirm_spawn = false;
94 static ShowStatus arg_show_status = _SHOW_STATUS_UNSET;
95 static bool arg_switched_root = false;
96 static int arg_no_pager = -1;
97 static char ***arg_join_controllers = NULL;
98 static ExecOutput arg_default_std_output = EXEC_OUTPUT_JOURNAL;
99 static ExecOutput arg_default_std_error = EXEC_OUTPUT_INHERIT;
100 static usec_t arg_default_restart_usec = DEFAULT_RESTART_USEC;
101 static usec_t arg_default_timeout_start_usec = DEFAULT_TIMEOUT_USEC;
102 static usec_t arg_default_timeout_stop_usec = DEFAULT_TIMEOUT_USEC;
103 static usec_t arg_default_start_limit_interval = DEFAULT_START_LIMIT_INTERVAL;
104 static unsigned arg_default_start_limit_burst = DEFAULT_START_LIMIT_BURST;
105 static usec_t arg_runtime_watchdog = 0;
106 static usec_t arg_shutdown_watchdog = 10 * USEC_PER_MINUTE;
107 static char **arg_default_environment = NULL;
108 static struct rlimit *arg_default_rlimit[_RLIMIT_MAX] = {};
109 static uint64_t arg_capability_bounding_set_drop = 0;
110 static nsec_t arg_timer_slack_nsec = NSEC_INFINITY;
111 static usec_t arg_default_timer_accuracy_usec = 1 * USEC_PER_MINUTE;
112 static Set* arg_syscall_archs = NULL;
113 static FILE* arg_serialization = NULL;
114 static bool arg_default_cpu_accounting = false;
115 static bool arg_default_blockio_accounting = false;
116 static bool arg_default_memory_accounting = false;
117
118 static void nop_handler(int sig) {}
119
120 static void pager_open_if_enabled(void) {
121
122 if (arg_no_pager <= 0)
123 return;
124
125 pager_open(false);
126 }
127
128 noreturn static void crash(int sig) {
129
130 if (getpid() != 1)
131 /* Pass this on immediately, if this is not PID 1 */
132 raise(sig);
133 else if (!arg_dump_core)
134 log_emergency("Caught <%s>, not dumping core.", signal_to_string(sig));
135 else {
136 struct sigaction sa = {
137 .sa_handler = nop_handler,
138 .sa_flags = SA_NOCLDSTOP|SA_RESTART,
139 };
140 pid_t pid;
141
142 /* We want to wait for the core process, hence let's enable SIGCHLD */
143 sigaction(SIGCHLD, &sa, NULL);
144
145 pid = fork();
146 if (pid < 0)
147 log_emergency_errno(errno, "Caught <%s>, cannot fork for core dump: %m", signal_to_string(sig));
148
149 else if (pid == 0) {
150 struct rlimit rl = {};
151
152 /* Enable default signal handler for core dump */
153 zero(sa);
154 sa.sa_handler = SIG_DFL;
155 sigaction(sig, &sa, NULL);
156
157 /* Don't limit the core dump size */
158 rl.rlim_cur = RLIM_INFINITY;
159 rl.rlim_max = RLIM_INFINITY;
160 setrlimit(RLIMIT_CORE, &rl);
161
162 /* Just to be sure... */
163 chdir("/");
164
165 /* Raise the signal again */
166 raise(sig);
167
168 assert_not_reached("We shouldn't be here...");
169 _exit(1);
170
171 } else {
172 siginfo_t status;
173 int r;
174
175 /* Order things nicely. */
176 r = wait_for_terminate(pid, &status);
177 if (r < 0)
178 log_emergency_errno(r, "Caught <%s>, waitpid() failed: %m", signal_to_string(sig));
179 else if (status.si_code != CLD_DUMPED)
180 log_emergency("Caught <%s>, core dump failed.", signal_to_string(sig));
181 else
182 log_emergency("Caught <%s>, dumped core as pid "PID_FMT".", signal_to_string(sig), pid);
183 }
184 }
185
186 if (arg_crash_chvt)
187 chvt(arg_crash_chvt);
188
189 if (arg_crash_shell) {
190 struct sigaction sa = {
191 .sa_handler = SIG_IGN,
192 .sa_flags = SA_NOCLDSTOP|SA_NOCLDWAIT|SA_RESTART,
193 };
194 pid_t pid;
195
196 log_info("Executing crash shell in 10s...");
197 sleep(10);
198
199 /* Let the kernel reap children for us */
200 assert_se(sigaction(SIGCHLD, &sa, NULL) == 0);
201
202 pid = fork();
203 if (pid < 0)
204 log_emergency_errno(errno, "Failed to fork off crash shell: %m");
205 else if (pid == 0) {
206 make_console_stdio();
207 execl("/bin/sh", "/bin/sh", NULL);
208
209 log_emergency_errno(errno, "execl() failed: %m");
210 _exit(1);
211 }
212
213 log_info("Successfully spawned crash shell as pid "PID_FMT".", pid);
214 }
215
216 log_emergency("Freezing execution.");
217 freeze();
218 }
219
220 static void install_crash_handler(void) {
221 struct sigaction sa = {
222 .sa_handler = crash,
223 .sa_flags = SA_NODEFER,
224 };
225
226 sigaction_many(&sa, SIGNALS_CRASH_HANDLER, -1);
227 }
228
229 static int console_setup(void) {
230 _cleanup_close_ int tty_fd = -1;
231 int r;
232
233 tty_fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
234 if (tty_fd < 0)
235 return log_error_errno(tty_fd, "Failed to open /dev/console: %m");
236
237 /* We don't want to force text mode. plymouth may be showing
238 * pictures already from initrd. */
239 r = reset_terminal_fd(tty_fd, false);
240 if (r < 0)
241 return log_error_errno(r, "Failed to reset /dev/console: %m");
242
243 return 0;
244 }
245
246 static int set_default_unit(const char *u) {
247 char *c;
248
249 assert(u);
250
251 c = strdup(u);
252 if (!c)
253 return -ENOMEM;
254
255 free(arg_default_unit);
256 arg_default_unit = c;
257
258 return 0;
259 }
260
261 static int parse_proc_cmdline_item(const char *key, const char *value) {
262
263 static const char * const rlmap[] = {
264 "emergency", SPECIAL_EMERGENCY_TARGET,
265 "-b", SPECIAL_EMERGENCY_TARGET,
266 "rescue", SPECIAL_RESCUE_TARGET,
267 "single", SPECIAL_RESCUE_TARGET,
268 "-s", SPECIAL_RESCUE_TARGET,
269 "s", SPECIAL_RESCUE_TARGET,
270 "S", SPECIAL_RESCUE_TARGET,
271 "1", SPECIAL_RESCUE_TARGET,
272 "2", SPECIAL_RUNLEVEL2_TARGET,
273 "3", SPECIAL_RUNLEVEL3_TARGET,
274 "4", SPECIAL_RUNLEVEL4_TARGET,
275 "5", SPECIAL_RUNLEVEL5_TARGET,
276 };
277 int r;
278
279 assert(key);
280
281 if (streq(key, "systemd.unit") && value) {
282
283 if (!in_initrd())
284 return set_default_unit(value);
285
286 } else if (streq(key, "rd.systemd.unit") && value) {
287
288 if (in_initrd())
289 return set_default_unit(value);
290
291 } else if (streq(key, "systemd.dump_core") && value) {
292
293 r = parse_boolean(value);
294 if (r < 0)
295 log_warning("Failed to parse dump core switch %s. Ignoring.", value);
296 else
297 arg_dump_core = r;
298
299 } else if (streq(key, "systemd.crash_shell") && value) {
300
301 r = parse_boolean(value);
302 if (r < 0)
303 log_warning("Failed to parse crash shell switch %s. Ignoring.", value);
304 else
305 arg_crash_shell = r;
306
307 } else if (streq(key, "systemd.crash_chvt") && value) {
308
309 if (safe_atoi(value, &r) < 0)
310 log_warning("Failed to parse crash chvt switch %s. Ignoring.", value);
311 else
312 arg_crash_chvt = r;
313
314 } else if (streq(key, "systemd.confirm_spawn") && value) {
315
316 r = parse_boolean(value);
317 if (r < 0)
318 log_warning("Failed to parse confirm spawn switch %s. Ignoring.", value);
319 else
320 arg_confirm_spawn = r;
321
322 } else if (streq(key, "systemd.show_status") && value) {
323
324 r = parse_show_status(value, &arg_show_status);
325 if (r < 0)
326 log_warning("Failed to parse show status switch %s. Ignoring.", value);
327
328 } else if (streq(key, "systemd.default_standard_output") && value) {
329
330 r = exec_output_from_string(value);
331 if (r < 0)
332 log_warning("Failed to parse default standard output switch %s. Ignoring.", value);
333 else
334 arg_default_std_output = r;
335
336 } else if (streq(key, "systemd.default_standard_error") && value) {
337
338 r = exec_output_from_string(value);
339 if (r < 0)
340 log_warning("Failed to parse default standard error switch %s. Ignoring.", value);
341 else
342 arg_default_std_error = r;
343
344 } else if (streq(key, "systemd.setenv") && value) {
345
346 if (env_assignment_is_valid(value)) {
347 char **env;
348
349 env = strv_env_set(arg_default_environment, value);
350 if (env)
351 arg_default_environment = env;
352 else
353 log_warning_errno(ENOMEM, "Setting environment variable '%s' failed, ignoring: %m", value);
354 } else
355 log_warning("Environment variable name '%s' is not valid. Ignoring.", value);
356
357 } else if (streq(key, "quiet") && !value) {
358
359 log_set_max_level(LOG_NOTICE);
360
361 if (arg_show_status == _SHOW_STATUS_UNSET)
362 arg_show_status = SHOW_STATUS_AUTO;
363
364 } else if (streq(key, "debug") && !value) {
365
366 /* Note that log_parse_environment() handles 'debug'
367 * too, and sets the log level to LOG_DEBUG. */
368
369 if (detect_container(NULL) > 0)
370 log_set_target(LOG_TARGET_CONSOLE);
371
372 } else if (!in_initrd() && !value) {
373 unsigned i;
374
375 /* SysV compatibility */
376 for (i = 0; i < ELEMENTSOF(rlmap); i += 2)
377 if (streq(key, rlmap[i]))
378 return set_default_unit(rlmap[i+1]);
379 }
380
381 return 0;
382 }
383
384 #define DEFINE_SETTER(name, func, descr) \
385 static int name(const char *unit, \
386 const char *filename, \
387 unsigned line, \
388 const char *section, \
389 unsigned section_line, \
390 const char *lvalue, \
391 int ltype, \
392 const char *rvalue, \
393 void *data, \
394 void *userdata) { \
395 \
396 int r; \
397 \
398 assert(filename); \
399 assert(lvalue); \
400 assert(rvalue); \
401 \
402 r = func(rvalue); \
403 if (r < 0) \
404 log_syntax(unit, LOG_ERR, filename, line, -r, \
405 "Invalid " descr "'%s': %s", \
406 rvalue, strerror(-r)); \
407 \
408 return 0; \
409 }
410
411 DEFINE_SETTER(config_parse_level2, log_set_max_level_from_string, "log level")
412 DEFINE_SETTER(config_parse_target, log_set_target_from_string, "target")
413 DEFINE_SETTER(config_parse_color, log_show_color_from_string, "color" )
414 DEFINE_SETTER(config_parse_location, log_show_location_from_string, "location")
415
416 static int config_parse_cpu_affinity2(
417 const char *unit,
418 const char *filename,
419 unsigned line,
420 const char *section,
421 unsigned section_line,
422 const char *lvalue,
423 int ltype,
424 const char *rvalue,
425 void *data,
426 void *userdata) {
427
428 const char *word, *state;
429 size_t l;
430 cpu_set_t *c = NULL;
431 unsigned ncpus = 0;
432
433 assert(filename);
434 assert(lvalue);
435 assert(rvalue);
436
437 FOREACH_WORD_QUOTED(word, l, rvalue, state) {
438 char *t;
439 int r;
440 unsigned cpu;
441
442 if (!(t = strndup(word, l)))
443 return log_oom();
444
445 r = safe_atou(t, &cpu);
446 free(t);
447
448 if (!c)
449 if (!(c = cpu_set_malloc(&ncpus)))
450 return log_oom();
451
452 if (r < 0 || cpu >= ncpus) {
453 log_syntax(unit, LOG_ERR, filename, line, -r,
454 "Failed to parse CPU affinity '%s'", rvalue);
455 CPU_FREE(c);
456 return -EBADMSG;
457 }
458
459 CPU_SET_S(cpu, CPU_ALLOC_SIZE(ncpus), c);
460 }
461 if (!isempty(state))
462 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
463 "Trailing garbage, ignoring.");
464
465 if (c) {
466 if (sched_setaffinity(0, CPU_ALLOC_SIZE(ncpus), c) < 0)
467 log_unit_warning(unit, "Failed to set CPU affinity: %m");
468
469 CPU_FREE(c);
470 }
471
472 return 0;
473 }
474
475 static int config_parse_show_status(
476 const char* unit,
477 const char *filename,
478 unsigned line,
479 const char *section,
480 unsigned section_line,
481 const char *lvalue,
482 int ltype,
483 const char *rvalue,
484 void *data,
485 void *userdata) {
486
487 int k;
488 ShowStatus *b = data;
489
490 assert(filename);
491 assert(lvalue);
492 assert(rvalue);
493 assert(data);
494
495 k = parse_show_status(rvalue, b);
496 if (k < 0) {
497 log_syntax(unit, LOG_ERR, filename, line, -k,
498 "Failed to parse show status setting, ignoring: %s", rvalue);
499 return 0;
500 }
501
502 return 0;
503 }
504
505 static void strv_free_free(char ***l) {
506 char ***i;
507
508 if (!l)
509 return;
510
511 for (i = l; *i; i++)
512 strv_free(*i);
513
514 free(l);
515 }
516
517 static void free_join_controllers(void) {
518 strv_free_free(arg_join_controllers);
519 arg_join_controllers = NULL;
520 }
521
522 static int config_parse_join_controllers(const char *unit,
523 const char *filename,
524 unsigned line,
525 const char *section,
526 unsigned section_line,
527 const char *lvalue,
528 int ltype,
529 const char *rvalue,
530 void *data,
531 void *userdata) {
532
533 unsigned n = 0;
534 const char *word, *state;
535 size_t length;
536
537 assert(filename);
538 assert(lvalue);
539 assert(rvalue);
540
541 free_join_controllers();
542
543 FOREACH_WORD_QUOTED(word, length, rvalue, state) {
544 char *s, **l;
545
546 s = strndup(word, length);
547 if (!s)
548 return log_oom();
549
550 l = strv_split(s, ",");
551 free(s);
552
553 strv_uniq(l);
554
555 if (strv_length(l) <= 1) {
556 strv_free(l);
557 continue;
558 }
559
560 if (!arg_join_controllers) {
561 arg_join_controllers = new(char**, 2);
562 if (!arg_join_controllers) {
563 strv_free(l);
564 return log_oom();
565 }
566
567 arg_join_controllers[0] = l;
568 arg_join_controllers[1] = NULL;
569
570 n = 1;
571 } else {
572 char ***a;
573 char ***t;
574
575 t = new0(char**, n+2);
576 if (!t) {
577 strv_free(l);
578 return log_oom();
579 }
580
581 n = 0;
582
583 for (a = arg_join_controllers; *a; a++) {
584
585 if (strv_overlap(*a, l)) {
586 if (strv_extend_strv(&l, *a) < 0) {
587 strv_free(l);
588 strv_free_free(t);
589 return log_oom();
590 }
591
592 } else {
593 char **c;
594
595 c = strv_copy(*a);
596 if (!c) {
597 strv_free(l);
598 strv_free_free(t);
599 return log_oom();
600 }
601
602 t[n++] = c;
603 }
604 }
605
606 t[n++] = strv_uniq(l);
607
608 strv_free_free(arg_join_controllers);
609 arg_join_controllers = t;
610 }
611 }
612 if (!isempty(state))
613 log_syntax(unit, LOG_ERR, filename, line, EINVAL,
614 "Trailing garbage, ignoring.");
615
616 return 0;
617 }
618
619 static int parse_config_file(void) {
620
621 const ConfigTableItem items[] = {
622 { "Manager", "LogLevel", config_parse_level2, 0, NULL },
623 { "Manager", "LogTarget", config_parse_target, 0, NULL },
624 { "Manager", "LogColor", config_parse_color, 0, NULL },
625 { "Manager", "LogLocation", config_parse_location, 0, NULL },
626 { "Manager", "DumpCore", config_parse_bool, 0, &arg_dump_core },
627 { "Manager", "CrashShell", config_parse_bool, 0, &arg_crash_shell },
628 { "Manager", "ShowStatus", config_parse_show_status, 0, &arg_show_status },
629 { "Manager", "CrashChVT", config_parse_int, 0, &arg_crash_chvt },
630 { "Manager", "CPUAffinity", config_parse_cpu_affinity2, 0, NULL },
631 { "Manager", "JoinControllers", config_parse_join_controllers, 0, &arg_join_controllers },
632 { "Manager", "RuntimeWatchdogSec", config_parse_sec, 0, &arg_runtime_watchdog },
633 { "Manager", "ShutdownWatchdogSec", config_parse_sec, 0, &arg_shutdown_watchdog },
634 { "Manager", "CapabilityBoundingSet", config_parse_bounding_set, 0, &arg_capability_bounding_set_drop },
635 #ifdef HAVE_SECCOMP
636 { "Manager", "SystemCallArchitectures", config_parse_syscall_archs, 0, &arg_syscall_archs },
637 #endif
638 { "Manager", "TimerSlackNSec", config_parse_nsec, 0, &arg_timer_slack_nsec },
639 { "Manager", "DefaultTimerAccuracySec", config_parse_sec, 0, &arg_default_timer_accuracy_usec },
640 { "Manager", "DefaultStandardOutput", config_parse_output, 0, &arg_default_std_output },
641 { "Manager", "DefaultStandardError", config_parse_output, 0, &arg_default_std_error },
642 { "Manager", "DefaultTimeoutStartSec", config_parse_sec, 0, &arg_default_timeout_start_usec },
643 { "Manager", "DefaultTimeoutStopSec", config_parse_sec, 0, &arg_default_timeout_stop_usec },
644 { "Manager", "DefaultRestartSec", config_parse_sec, 0, &arg_default_restart_usec },
645 { "Manager", "DefaultStartLimitInterval", config_parse_sec, 0, &arg_default_start_limit_interval },
646 { "Manager", "DefaultStartLimitBurst", config_parse_unsigned, 0, &arg_default_start_limit_burst },
647 { "Manager", "DefaultEnvironment", config_parse_environ, 0, &arg_default_environment },
648 { "Manager", "DefaultLimitCPU", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CPU] },
649 { "Manager", "DefaultLimitFSIZE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_FSIZE] },
650 { "Manager", "DefaultLimitDATA", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_DATA] },
651 { "Manager", "DefaultLimitSTACK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_STACK] },
652 { "Manager", "DefaultLimitCORE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_CORE] },
653 { "Manager", "DefaultLimitRSS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RSS] },
654 { "Manager", "DefaultLimitNOFILE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NOFILE] },
655 { "Manager", "DefaultLimitAS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_AS] },
656 { "Manager", "DefaultLimitNPROC", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NPROC] },
657 { "Manager", "DefaultLimitMEMLOCK", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MEMLOCK] },
658 { "Manager", "DefaultLimitLOCKS", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_LOCKS] },
659 { "Manager", "DefaultLimitSIGPENDING", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_SIGPENDING] },
660 { "Manager", "DefaultLimitMSGQUEUE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_MSGQUEUE] },
661 { "Manager", "DefaultLimitNICE", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_NICE] },
662 { "Manager", "DefaultLimitRTPRIO", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTPRIO] },
663 { "Manager", "DefaultLimitRTTIME", config_parse_limit, 0, &arg_default_rlimit[RLIMIT_RTTIME] },
664 { "Manager", "DefaultCPUAccounting", config_parse_bool, 0, &arg_default_cpu_accounting },
665 { "Manager", "DefaultBlockIOAccounting", config_parse_bool, 0, &arg_default_blockio_accounting },
666 { "Manager", "DefaultMemoryAccounting", config_parse_bool, 0, &arg_default_memory_accounting },
667 {}
668 };
669
670 const char *fn;
671
672 fn = arg_running_as == SYSTEMD_SYSTEM ? PKGSYSCONFDIR "/system.conf" : PKGSYSCONFDIR "/user.conf";
673 config_parse(NULL, fn, NULL,
674 "Manager\0",
675 config_item_table_lookup, items,
676 false, false, true, NULL);
677
678 return 0;
679 }
680
681 static int parse_argv(int argc, char *argv[]) {
682
683 enum {
684 ARG_LOG_LEVEL = 0x100,
685 ARG_LOG_TARGET,
686 ARG_LOG_COLOR,
687 ARG_LOG_LOCATION,
688 ARG_UNIT,
689 ARG_SYSTEM,
690 ARG_USER,
691 ARG_TEST,
692 ARG_NO_PAGER,
693 ARG_VERSION,
694 ARG_DUMP_CONFIGURATION_ITEMS,
695 ARG_DUMP_CORE,
696 ARG_CRASH_SHELL,
697 ARG_CONFIRM_SPAWN,
698 ARG_SHOW_STATUS,
699 ARG_DESERIALIZE,
700 ARG_SWITCHED_ROOT,
701 ARG_DEFAULT_STD_OUTPUT,
702 ARG_DEFAULT_STD_ERROR
703 };
704
705 static const struct option options[] = {
706 { "log-level", required_argument, NULL, ARG_LOG_LEVEL },
707 { "log-target", required_argument, NULL, ARG_LOG_TARGET },
708 { "log-color", optional_argument, NULL, ARG_LOG_COLOR },
709 { "log-location", optional_argument, NULL, ARG_LOG_LOCATION },
710 { "unit", required_argument, NULL, ARG_UNIT },
711 { "system", no_argument, NULL, ARG_SYSTEM },
712 { "user", no_argument, NULL, ARG_USER },
713 { "test", no_argument, NULL, ARG_TEST },
714 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
715 { "help", no_argument, NULL, 'h' },
716 { "version", no_argument, NULL, ARG_VERSION },
717 { "dump-configuration-items", no_argument, NULL, ARG_DUMP_CONFIGURATION_ITEMS },
718 { "dump-core", optional_argument, NULL, ARG_DUMP_CORE },
719 { "crash-shell", optional_argument, NULL, ARG_CRASH_SHELL },
720 { "confirm-spawn", optional_argument, NULL, ARG_CONFIRM_SPAWN },
721 { "show-status", optional_argument, NULL, ARG_SHOW_STATUS },
722 { "deserialize", required_argument, NULL, ARG_DESERIALIZE },
723 { "switched-root", no_argument, NULL, ARG_SWITCHED_ROOT },
724 { "default-standard-output", required_argument, NULL, ARG_DEFAULT_STD_OUTPUT, },
725 { "default-standard-error", required_argument, NULL, ARG_DEFAULT_STD_ERROR, },
726 {}
727 };
728
729 int c, r;
730
731 assert(argc >= 1);
732 assert(argv);
733
734 if (getpid() == 1)
735 opterr = 0;
736
737 while ((c = getopt_long(argc, argv, "hDbsz:", options, NULL)) >= 0)
738
739 switch (c) {
740
741 case ARG_LOG_LEVEL:
742 r = log_set_max_level_from_string(optarg);
743 if (r < 0) {
744 log_error("Failed to parse log level %s.", optarg);
745 return r;
746 }
747
748 break;
749
750 case ARG_LOG_TARGET:
751 r = log_set_target_from_string(optarg);
752 if (r < 0) {
753 log_error("Failed to parse log target %s.", optarg);
754 return r;
755 }
756
757 break;
758
759 case ARG_LOG_COLOR:
760
761 if (optarg) {
762 r = log_show_color_from_string(optarg);
763 if (r < 0) {
764 log_error("Failed to parse log color setting %s.", optarg);
765 return r;
766 }
767 } else
768 log_show_color(true);
769
770 break;
771
772 case ARG_LOG_LOCATION:
773 if (optarg) {
774 r = log_show_location_from_string(optarg);
775 if (r < 0) {
776 log_error("Failed to parse log location setting %s.", optarg);
777 return r;
778 }
779 } else
780 log_show_location(true);
781
782 break;
783
784 case ARG_DEFAULT_STD_OUTPUT:
785 r = exec_output_from_string(optarg);
786 if (r < 0) {
787 log_error("Failed to parse default standard output setting %s.", optarg);
788 return r;
789 } else
790 arg_default_std_output = r;
791 break;
792
793 case ARG_DEFAULT_STD_ERROR:
794 r = exec_output_from_string(optarg);
795 if (r < 0) {
796 log_error("Failed to parse default standard error output setting %s.", optarg);
797 return r;
798 } else
799 arg_default_std_error = r;
800 break;
801
802 case ARG_UNIT:
803
804 r = set_default_unit(optarg);
805 if (r < 0)
806 return log_error_errno(r, "Failed to set default unit %s: %m", optarg);
807
808 break;
809
810 case ARG_SYSTEM:
811 arg_running_as = SYSTEMD_SYSTEM;
812 break;
813
814 case ARG_USER:
815 arg_running_as = SYSTEMD_USER;
816 break;
817
818 case ARG_TEST:
819 arg_action = ACTION_TEST;
820 if (arg_no_pager < 0)
821 arg_no_pager = true;
822 break;
823
824 case ARG_NO_PAGER:
825 arg_no_pager = true;
826 break;
827
828 case ARG_VERSION:
829 arg_action = ACTION_VERSION;
830 break;
831
832 case ARG_DUMP_CONFIGURATION_ITEMS:
833 arg_action = ACTION_DUMP_CONFIGURATION_ITEMS;
834 break;
835
836 case ARG_DUMP_CORE:
837 r = optarg ? parse_boolean(optarg) : 1;
838 if (r < 0) {
839 log_error("Failed to parse dump core boolean %s.", optarg);
840 return r;
841 }
842 arg_dump_core = r;
843 break;
844
845 case ARG_CRASH_SHELL:
846 r = optarg ? parse_boolean(optarg) : 1;
847 if (r < 0) {
848 log_error("Failed to parse crash shell boolean %s.", optarg);
849 return r;
850 }
851 arg_crash_shell = r;
852 break;
853
854 case ARG_CONFIRM_SPAWN:
855 r = optarg ? parse_boolean(optarg) : 1;
856 if (r < 0) {
857 log_error("Failed to parse confirm spawn boolean %s.", optarg);
858 return r;
859 }
860 arg_confirm_spawn = r;
861 break;
862
863 case ARG_SHOW_STATUS:
864 if (optarg) {
865 r = parse_show_status(optarg, &arg_show_status);
866 if (r < 0) {
867 log_error("Failed to parse show status boolean %s.", optarg);
868 return r;
869 }
870 } else
871 arg_show_status = SHOW_STATUS_YES;
872 break;
873
874 case ARG_DESERIALIZE: {
875 int fd;
876 FILE *f;
877
878 r = safe_atoi(optarg, &fd);
879 if (r < 0 || fd < 0) {
880 log_error("Failed to parse deserialize option %s.", optarg);
881 return r < 0 ? r : -EINVAL;
882 }
883
884 fd_cloexec(fd, true);
885
886 f = fdopen(fd, "r");
887 if (!f)
888 return log_error_errno(errno, "Failed to open serialization fd: %m");
889
890 if (arg_serialization)
891 fclose(arg_serialization);
892
893 arg_serialization = f;
894
895 break;
896 }
897
898 case ARG_SWITCHED_ROOT:
899 arg_switched_root = true;
900 break;
901
902 case 'h':
903 arg_action = ACTION_HELP;
904 if (arg_no_pager < 0)
905 arg_no_pager = true;
906 break;
907
908 case 'D':
909 log_set_max_level(LOG_DEBUG);
910 break;
911
912 case 'b':
913 case 's':
914 case 'z':
915 /* Just to eat away the sysvinit kernel
916 * cmdline args without getopt() error
917 * messages that we'll parse in
918 * parse_proc_cmdline_word() or ignore. */
919
920 case '?':
921 if (getpid() != 1)
922 return -EINVAL;
923 else
924 return 0;
925
926 default:
927 assert_not_reached("Unhandled option code.");
928 }
929
930 if (optind < argc && getpid() != 1) {
931 /* Hmm, when we aren't run as init system
932 * let's complain about excess arguments */
933
934 log_error("Excess arguments.");
935 return -EINVAL;
936 }
937
938 return 0;
939 }
940
941 static int help(void) {
942
943 printf("%s [OPTIONS...]\n\n"
944 "Starts up and maintains the system or user services.\n\n"
945 " -h --help Show this help\n"
946 " --test Determine startup sequence, dump it and exit\n"
947 " --no-pager Do not pipe output into a pager\n"
948 " --dump-configuration-items Dump understood unit configuration items\n"
949 " --unit=UNIT Set default unit\n"
950 " --system Run a system instance, even if PID != 1\n"
951 " --user Run a user instance\n"
952 " --dump-core[=0|1] Dump core on crash\n"
953 " --crash-shell[=0|1] Run shell on crash\n"
954 " --confirm-spawn[=0|1] Ask for confirmation when spawning processes\n"
955 " --show-status[=0|1] Show status updates on the console during bootup\n"
956 " --log-target=TARGET Set log target (console, journal, kmsg, journal-or-kmsg, null)\n"
957 " --log-level=LEVEL Set log level (debug, info, notice, warning, err, crit, alert, emerg)\n"
958 " --log-color[=0|1] Highlight important log messages\n"
959 " --log-location[=0|1] Include code location in log messages\n"
960 " --default-standard-output= Set default standard output for services\n"
961 " --default-standard-error= Set default standard error output for services\n",
962 program_invocation_short_name);
963
964 return 0;
965 }
966
967 static int version(void) {
968 puts(PACKAGE_STRING);
969 puts(SYSTEMD_FEATURES);
970
971 return 0;
972 }
973
974 static int prepare_reexecute(Manager *m, FILE **_f, FDSet **_fds, bool switching_root) {
975 FILE *f = NULL;
976 FDSet *fds = NULL;
977 int r;
978
979 assert(m);
980 assert(_f);
981 assert(_fds);
982
983 r = manager_open_serialization(m, &f);
984 if (r < 0) {
985 log_error_errno(r, "Failed to create serialization file: %m");
986 goto fail;
987 }
988
989 /* Make sure nothing is really destructed when we shut down */
990 m->n_reloading ++;
991 bus_manager_send_reloading(m, true);
992
993 fds = fdset_new();
994 if (!fds) {
995 r = -ENOMEM;
996 log_error_errno(r, "Failed to allocate fd set: %m");
997 goto fail;
998 }
999
1000 r = manager_serialize(m, f, fds, switching_root);
1001 if (r < 0) {
1002 log_error_errno(r, "Failed to serialize state: %m");
1003 goto fail;
1004 }
1005
1006 if (fseeko(f, 0, SEEK_SET) < 0) {
1007 log_error_errno(errno, "Failed to rewind serialization fd: %m");
1008 goto fail;
1009 }
1010
1011 r = fd_cloexec(fileno(f), false);
1012 if (r < 0) {
1013 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization: %m");
1014 goto fail;
1015 }
1016
1017 r = fdset_cloexec(fds, false);
1018 if (r < 0) {
1019 log_error_errno(r, "Failed to disable O_CLOEXEC for serialization fds: %m");
1020 goto fail;
1021 }
1022
1023 *_f = f;
1024 *_fds = fds;
1025
1026 return 0;
1027
1028 fail:
1029 fdset_free(fds);
1030
1031 if (f)
1032 fclose(f);
1033
1034 return r;
1035 }
1036
1037 static int bump_rlimit_nofile(struct rlimit *saved_rlimit) {
1038 struct rlimit nl;
1039 int r;
1040
1041 assert(saved_rlimit);
1042
1043 /* Save the original RLIMIT_NOFILE so that we can reset it
1044 * later when transitioning from the initrd to the main
1045 * systemd or suchlike. */
1046 if (getrlimit(RLIMIT_NOFILE, saved_rlimit) < 0)
1047 return log_error_errno(errno, "Reading RLIMIT_NOFILE failed: %m");
1048
1049 /* Make sure forked processes get the default kernel setting */
1050 if (!arg_default_rlimit[RLIMIT_NOFILE]) {
1051 struct rlimit *rl;
1052
1053 rl = newdup(struct rlimit, saved_rlimit, 1);
1054 if (!rl)
1055 return log_oom();
1056
1057 arg_default_rlimit[RLIMIT_NOFILE] = rl;
1058 }
1059
1060 /* Bump up the resource limit for ourselves substantially */
1061 nl.rlim_cur = nl.rlim_max = 64*1024;
1062 r = setrlimit_closest(RLIMIT_NOFILE, &nl);
1063 if (r < 0)
1064 return log_error_errno(r, "Setting RLIMIT_NOFILE failed: %m");
1065
1066 return 0;
1067 }
1068
1069 static void test_mtab(void) {
1070
1071 static const char ok[] =
1072 "/proc/self/mounts\0"
1073 "/proc/mounts\0"
1074 "../proc/self/mounts\0"
1075 "../proc/mounts\0";
1076
1077 _cleanup_free_ char *p = NULL;
1078 int r;
1079
1080 /* Check that /etc/mtab is a symlink to the right place or
1081 * non-existing. But certainly not a file, or a symlink to
1082 * some weird place... */
1083
1084 r = readlink_malloc("/etc/mtab", &p);
1085 if (r == -ENOENT)
1086 return;
1087 if (r >= 0 && nulstr_contains(ok, p))
1088 return;
1089
1090 log_warning("/etc/mtab is not a symlink or not pointing to /proc/self/mounts. "
1091 "This is not supported anymore. "
1092 "Please make sure to replace this file by a symlink to avoid incorrect or misleading mount(8) output.");
1093 }
1094
1095 static void test_usr(void) {
1096
1097 /* Check that /usr is not a separate fs */
1098
1099 if (dir_is_empty("/usr") <= 0)
1100 return;
1101
1102 log_warning("/usr appears to be on its own filesytem and is not already mounted. This is not a supported setup. "
1103 "Some things will probably break (sometimes even silently) in mysterious ways. "
1104 "Consult http://freedesktop.org/wiki/Software/systemd/separate-usr-is-broken for more information.");
1105 }
1106
1107 static int initialize_join_controllers(void) {
1108 /* By default, mount "cpu" + "cpuacct" together, and "net_cls"
1109 * + "net_prio". We'd like to add "cpuset" to the mix, but
1110 * "cpuset" does't really work for groups with no initialized
1111 * attributes. */
1112
1113 arg_join_controllers = new(char**, 3);
1114 if (!arg_join_controllers)
1115 return -ENOMEM;
1116
1117 arg_join_controllers[0] = strv_new("cpu", "cpuacct", NULL);
1118 arg_join_controllers[1] = strv_new("net_cls", "net_prio", NULL);
1119 arg_join_controllers[2] = NULL;
1120
1121 if (!arg_join_controllers[0] || !arg_join_controllers[1]) {
1122 free_join_controllers();
1123 return -ENOMEM;
1124 }
1125
1126 return 0;
1127 }
1128
1129 static int enforce_syscall_archs(Set *archs) {
1130 #ifdef HAVE_SECCOMP
1131 scmp_filter_ctx *seccomp;
1132 Iterator i;
1133 void *id;
1134 int r;
1135
1136 seccomp = seccomp_init(SCMP_ACT_ALLOW);
1137 if (!seccomp)
1138 return log_oom();
1139
1140 SET_FOREACH(id, arg_syscall_archs, i) {
1141 r = seccomp_arch_add(seccomp, PTR_TO_UINT32(id) - 1);
1142 if (r == -EEXIST)
1143 continue;
1144 if (r < 0) {
1145 log_error_errno(r, "Failed to add architecture to seccomp: %m");
1146 goto finish;
1147 }
1148 }
1149
1150 r = seccomp_attr_set(seccomp, SCMP_FLTATR_CTL_NNP, 0);
1151 if (r < 0) {
1152 log_error_errno(r, "Failed to unset NO_NEW_PRIVS: %m");
1153 goto finish;
1154 }
1155
1156 r = seccomp_load(seccomp);
1157 if (r < 0)
1158 log_error_errno(r, "Failed to add install architecture seccomp: %m");
1159
1160 finish:
1161 seccomp_release(seccomp);
1162 return r;
1163 #else
1164 return 0;
1165 #endif
1166 }
1167
1168 static int status_welcome(void) {
1169 _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
1170 int r;
1171
1172 r = parse_env_file("/etc/os-release", NEWLINE,
1173 "PRETTY_NAME", &pretty_name,
1174 "ANSI_COLOR", &ansi_color,
1175 NULL);
1176 if (r == -ENOENT) {
1177 r = parse_env_file("/usr/lib/os-release", NEWLINE,
1178 "PRETTY_NAME", &pretty_name,
1179 "ANSI_COLOR", &ansi_color,
1180 NULL);
1181 }
1182
1183 if (r < 0 && r != -ENOENT)
1184 log_warning_errno(r, "Failed to read os-release file: %m");
1185
1186 return status_printf(NULL, false, false,
1187 "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
1188 isempty(ansi_color) ? "1" : ansi_color,
1189 isempty(pretty_name) ? "Linux" : pretty_name);
1190 }
1191
1192 static int write_container_id(void) {
1193 const char *c;
1194
1195 c = getenv("container");
1196 if (isempty(c))
1197 return 0;
1198
1199 return write_string_file("/run/systemd/container", c);
1200 }
1201
1202 int main(int argc, char *argv[]) {
1203 Manager *m = NULL;
1204 int r, retval = EXIT_FAILURE;
1205 usec_t before_startup, after_startup;
1206 char timespan[FORMAT_TIMESPAN_MAX];
1207 FDSet *fds = NULL;
1208 bool reexecute = false;
1209 const char *shutdown_verb = NULL;
1210 dual_timestamp initrd_timestamp = { 0ULL, 0ULL };
1211 dual_timestamp userspace_timestamp = { 0ULL, 0ULL };
1212 dual_timestamp kernel_timestamp = { 0ULL, 0ULL };
1213 dual_timestamp security_start_timestamp = { 0ULL, 0ULL };
1214 dual_timestamp security_finish_timestamp = { 0ULL, 0ULL };
1215 static char systemd[] = "systemd";
1216 bool skip_setup = false;
1217 unsigned j;
1218 bool loaded_policy = false;
1219 bool arm_reboot_watchdog = false;
1220 bool queue_default_job = false;
1221 bool empty_etc = false;
1222 char *switch_root_dir = NULL, *switch_root_init = NULL;
1223 static struct rlimit saved_rlimit_nofile = { 0, 0 };
1224 const char *error_message = NULL;
1225
1226 #ifdef HAVE_SYSV_COMPAT
1227 if (getpid() != 1 && strstr(program_invocation_short_name, "init")) {
1228 /* This is compatibility support for SysV, where
1229 * calling init as a user is identical to telinit. */
1230
1231 errno = -ENOENT;
1232 execv(SYSTEMCTL_BINARY_PATH, argv);
1233 log_error_errno(errno, "Failed to exec " SYSTEMCTL_BINARY_PATH ": %m");
1234 return 1;
1235 }
1236 #endif
1237
1238 dual_timestamp_from_monotonic(&kernel_timestamp, 0);
1239 dual_timestamp_get(&userspace_timestamp);
1240
1241 /* Determine if this is a reexecution or normal bootup. We do
1242 * the full command line parsing much later, so let's just
1243 * have a quick peek here. */
1244 if (strv_find(argv+1, "--deserialize"))
1245 skip_setup = true;
1246
1247 /* If we have switched root, do all the special setup
1248 * things */
1249 if (strv_find(argv+1, "--switched-root"))
1250 skip_setup = false;
1251
1252 /* If we get started via the /sbin/init symlink then we are
1253 called 'init'. After a subsequent reexecution we are then
1254 called 'systemd'. That is confusing, hence let's call us
1255 systemd right-away. */
1256 program_invocation_short_name = systemd;
1257 prctl(PR_SET_NAME, systemd);
1258
1259 saved_argv = argv;
1260 saved_argc = argc;
1261
1262 log_show_color(isatty(STDERR_FILENO) > 0);
1263 log_set_upgrade_syslog_to_journal(true);
1264
1265 /* Disable the umask logic */
1266 if (getpid() == 1)
1267 umask(0);
1268
1269 if (getpid() == 1 && detect_container(NULL) <= 0) {
1270
1271 /* Running outside of a container as PID 1 */
1272 arg_running_as = SYSTEMD_SYSTEM;
1273 make_null_stdio();
1274 log_set_target(LOG_TARGET_KMSG);
1275 log_open();
1276
1277 if (in_initrd())
1278 initrd_timestamp = userspace_timestamp;
1279
1280 if (!skip_setup) {
1281 mount_setup_early();
1282 dual_timestamp_get(&security_start_timestamp);
1283 if (mac_selinux_setup(&loaded_policy) < 0) {
1284 error_message = "Failed to load SELinux policy";
1285 goto finish;
1286 } else if (ima_setup() < 0) {
1287 error_message = "Failed to load IMA policy";
1288 goto finish;
1289 } else if (mac_smack_setup(&loaded_policy) < 0) {
1290 error_message = "Failed to load SMACK policy";
1291 goto finish;
1292 }
1293 dual_timestamp_get(&security_finish_timestamp);
1294 }
1295
1296 if (mac_selinux_init(NULL) < 0) {
1297 error_message = "Failed to initialize SELinux policy";
1298 goto finish;
1299 }
1300
1301 if (!skip_setup) {
1302 if (clock_is_localtime() > 0) {
1303 int min;
1304
1305 /*
1306 * The very first call of settimeofday() also does a time warp in the kernel.
1307 *
1308 * In the rtc-in-local time mode, we set the kernel's timezone, and rely on
1309 * external tools to take care of maintaining the RTC and do all adjustments.
1310 * This matches the behavior of Windows, which leaves the RTC alone if the
1311 * registry tells that the RTC runs in UTC.
1312 */
1313 r = clock_set_timezone(&min);
1314 if (r < 0)
1315 log_error_errno(r, "Failed to apply local time delta, ignoring: %m");
1316 else
1317 log_info("RTC configured in localtime, applying delta of %i minutes to system time.", min);
1318 } else if (!in_initrd()) {
1319 /*
1320 * Do a dummy very first call to seal the kernel's time warp magic.
1321 *
1322 * Do not call this this from inside the initrd. The initrd might not
1323 * carry /etc/adjtime with LOCAL, but the real system could be set up
1324 * that way. In such case, we need to delay the time-warp or the sealing
1325 * until we reach the real system.
1326 *
1327 * Do no set the kernel's timezone. The concept of local time cannot
1328 * be supported reliably, the time will jump or be incorrect at every daylight
1329 * saving time change. All kernel local time concepts will be treated
1330 * as UTC that way.
1331 */
1332 clock_reset_timewarp();
1333 }
1334 }
1335
1336 /* Set the default for later on, but don't actually
1337 * open the logs like this for now. Note that if we
1338 * are transitioning from the initrd there might still
1339 * be journal fd open, and we shouldn't attempt
1340 * opening that before we parsed /proc/cmdline which
1341 * might redirect output elsewhere. */
1342 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1343
1344 } else if (getpid() == 1) {
1345 /* Running inside a container, as PID 1 */
1346 arg_running_as = SYSTEMD_SYSTEM;
1347 log_set_target(LOG_TARGET_CONSOLE);
1348 log_close_console(); /* force reopen of /dev/console */
1349 log_open();
1350
1351 /* For the later on, see above... */
1352 log_set_target(LOG_TARGET_JOURNAL);
1353
1354 /* clear the kernel timestamp,
1355 * because we are in a container */
1356 kernel_timestamp.monotonic = 0ULL;
1357 kernel_timestamp.realtime = 0ULL;
1358
1359 } else {
1360 /* Running as user instance */
1361 arg_running_as = SYSTEMD_USER;
1362 log_set_target(LOG_TARGET_AUTO);
1363 log_open();
1364
1365 /* clear the kernel timestamp,
1366 * because we are not PID 1 */
1367 kernel_timestamp.monotonic = 0ULL;
1368 kernel_timestamp.realtime = 0ULL;
1369 }
1370
1371 /* Initialize default unit */
1372 r = set_default_unit(SPECIAL_DEFAULT_TARGET);
1373 if (r < 0) {
1374 log_emergency_errno(r, "Failed to set default unit %s: %m", SPECIAL_DEFAULT_TARGET);
1375 error_message = "Failed to set default unit";
1376 goto finish;
1377 }
1378
1379 r = initialize_join_controllers();
1380 if (r < 0) {
1381 error_message = "Failed to initalize cgroup controllers";
1382 goto finish;
1383 }
1384
1385 /* Mount /proc, /sys and friends, so that /proc/cmdline and
1386 * /proc/$PID/fd is available. */
1387 if (getpid() == 1) {
1388
1389 /* Load the kernel modules early, so that we kdbus.ko is loaded before kdbusfs shall be mounted */
1390 if (!skip_setup)
1391 kmod_setup();
1392
1393 r = mount_setup(loaded_policy);
1394 if (r < 0) {
1395 error_message = "Failed to mount API filesystems";
1396 goto finish;
1397 }
1398 }
1399
1400 /* Reset all signal handlers. */
1401 assert_se(reset_all_signal_handlers() == 0);
1402
1403 ignore_signals(SIGNALS_IGNORE, -1);
1404
1405 if (parse_config_file() < 0) {
1406 error_message = "Failed to parse config file";
1407 goto finish;
1408 }
1409
1410 if (arg_running_as == SYSTEMD_SYSTEM) {
1411 r = parse_proc_cmdline(parse_proc_cmdline_item);
1412 if (r < 0)
1413 log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
1414 }
1415
1416 /* Note that this also parses bits from the kernel command
1417 * line, including "debug". */
1418 log_parse_environment();
1419
1420 if (parse_argv(argc, argv) < 0) {
1421 error_message = "Failed to parse commandline arguments";
1422 goto finish;
1423 }
1424
1425 if (arg_action == ACTION_TEST &&
1426 geteuid() == 0) {
1427 log_error("Don't run test mode as root.");
1428 goto finish;
1429 }
1430
1431 if (arg_running_as == SYSTEMD_USER &&
1432 arg_action == ACTION_RUN &&
1433 sd_booted() <= 0) {
1434 log_error("Trying to run as user instance, but the system has not been booted with systemd.");
1435 goto finish;
1436 }
1437
1438 if (arg_running_as == SYSTEMD_SYSTEM &&
1439 arg_action == ACTION_RUN &&
1440 running_in_chroot() > 0) {
1441 log_error("Cannot be run in a chroot() environment.");
1442 goto finish;
1443 }
1444
1445 if (arg_action == ACTION_TEST)
1446 skip_setup = true;
1447
1448 pager_open_if_enabled();
1449
1450 if (arg_action == ACTION_HELP) {
1451 retval = help();
1452 goto finish;
1453 } else if (arg_action == ACTION_VERSION) {
1454 retval = version();
1455 goto finish;
1456 } else if (arg_action == ACTION_DUMP_CONFIGURATION_ITEMS) {
1457 unit_dump_config_items(stdout);
1458 retval = EXIT_SUCCESS;
1459 goto finish;
1460 } else if (arg_action == ACTION_DONE) {
1461 retval = EXIT_SUCCESS;
1462 goto finish;
1463 }
1464
1465 if (arg_running_as == SYSTEMD_USER &&
1466 !getenv("XDG_RUNTIME_DIR")) {
1467 log_error("Trying to run as user instance, but $XDG_RUNTIME_DIR is not set.");
1468 goto finish;
1469 }
1470
1471 assert_se(arg_action == ACTION_RUN || arg_action == ACTION_TEST);
1472
1473 /* Close logging fds, in order not to confuse fdset below */
1474 log_close();
1475
1476 /* Remember open file descriptors for later deserialization */
1477 r = fdset_new_fill(&fds);
1478 if (r < 0) {
1479 log_emergency_errno(r, "Failed to allocate fd set: %m");
1480 error_message = "Failed to allocate fd set";
1481 goto finish;
1482 } else
1483 fdset_cloexec(fds, true);
1484
1485 if (arg_serialization)
1486 assert_se(fdset_remove(fds, fileno(arg_serialization)) >= 0);
1487
1488 if (arg_running_as == SYSTEMD_SYSTEM)
1489 /* Become a session leader if we aren't one yet. */
1490 setsid();
1491
1492 /* Move out of the way, so that we won't block unmounts */
1493 assert_se(chdir("/") == 0);
1494
1495 /* Reset the console, but only if this is really init and we
1496 * are freshly booted */
1497 if (arg_running_as == SYSTEMD_SYSTEM && arg_action == ACTION_RUN) {
1498
1499 /* If we are init, we connect stdin/stdout/stderr to
1500 * /dev/null and make sure we don't have a controlling
1501 * tty. */
1502 release_terminal();
1503
1504 if (getpid() == 1 && !skip_setup)
1505 console_setup();
1506 }
1507
1508 /* Open the logging devices, if possible and necessary */
1509 log_open();
1510
1511 if (arg_show_status == _SHOW_STATUS_UNSET)
1512 arg_show_status = SHOW_STATUS_YES;
1513
1514 /* Make sure we leave a core dump without panicing the
1515 * kernel. */
1516 if (getpid() == 1) {
1517 install_crash_handler();
1518
1519 r = mount_cgroup_controllers(arg_join_controllers);
1520 if (r < 0)
1521 goto finish;
1522 }
1523
1524 if (arg_running_as == SYSTEMD_SYSTEM) {
1525 const char *virtualization = NULL;
1526
1527 log_info(PACKAGE_STRING " running in %ssystem mode. (" SYSTEMD_FEATURES ")",
1528 arg_action == ACTION_TEST ? "test " : "" );
1529
1530 detect_virtualization(&virtualization);
1531 if (virtualization)
1532 log_info("Detected virtualization '%s'.", virtualization);
1533
1534 write_container_id();
1535
1536 log_info("Detected architecture '%s'.", architecture_to_string(uname_architecture()));
1537
1538 if (in_initrd())
1539 log_info("Running in initial RAM disk.");
1540
1541 /* Let's check whether /etc is already populated. We
1542 * don't actually really check for that, but use
1543 * /etc/machine-id as flag file. This allows container
1544 * managers and installers to provision a couple of
1545 * files already. If the container manager wants to
1546 * provision the machine ID itself it should pass
1547 * $container_uuid to PID 1.*/
1548
1549 empty_etc = access("/etc/machine-id", F_OK) < 0;
1550 if (empty_etc)
1551 log_info("Running with unpopulated /etc.");
1552 } else {
1553 _cleanup_free_ char *t;
1554
1555 t = uid_to_name(getuid());
1556 log_debug(PACKAGE_STRING " running in %suser mode for user "UID_FMT"/%s. (" SYSTEMD_FEATURES ")",
1557 arg_action == ACTION_TEST ? " test" : "", getuid(), t);
1558 }
1559
1560 if (arg_running_as == SYSTEMD_SYSTEM && !skip_setup) {
1561 if (arg_show_status > 0 || plymouth_running())
1562 status_welcome();
1563
1564 hostname_setup();
1565 machine_id_setup(NULL);
1566 loopback_setup();
1567
1568 test_mtab();
1569 test_usr();
1570 }
1571
1572 if (arg_running_as == SYSTEMD_SYSTEM && arg_runtime_watchdog > 0)
1573 watchdog_set_timeout(&arg_runtime_watchdog);
1574
1575 if (arg_timer_slack_nsec != NSEC_INFINITY)
1576 if (prctl(PR_SET_TIMERSLACK, arg_timer_slack_nsec) < 0)
1577 log_error_errno(errno, "Failed to adjust timer slack: %m");
1578
1579 if (arg_capability_bounding_set_drop) {
1580 r = capability_bounding_set_drop_usermode(arg_capability_bounding_set_drop);
1581 if (r < 0) {
1582 log_emergency_errno(r, "Failed to drop capability bounding set of usermode helpers: %m");
1583 error_message = "Failed to drop capability bounding set of usermode helpers";
1584 goto finish;
1585 }
1586 r = capability_bounding_set_drop(arg_capability_bounding_set_drop, true);
1587 if (r < 0) {
1588 log_emergency_errno(r, "Failed to drop capability bounding set: %m");
1589 error_message = "Failed to drop capability bounding set";
1590 goto finish;
1591 }
1592 }
1593
1594 if (arg_syscall_archs) {
1595 r = enforce_syscall_archs(arg_syscall_archs);
1596 if (r < 0) {
1597 error_message = "Failed to set syscall architectures";
1598 goto finish;
1599 }
1600 }
1601
1602 if (arg_running_as == SYSTEMD_USER) {
1603 /* Become reaper of our children */
1604 if (prctl(PR_SET_CHILD_SUBREAPER, 1) < 0) {
1605 log_warning_errno(errno, "Failed to make us a subreaper: %m");
1606 if (errno == EINVAL)
1607 log_info("Perhaps the kernel version is too old (< 3.4?)");
1608 }
1609 }
1610
1611 if (arg_running_as == SYSTEMD_SYSTEM) {
1612 bump_rlimit_nofile(&saved_rlimit_nofile);
1613
1614 if (empty_etc) {
1615 r = unit_file_preset_all(UNIT_FILE_SYSTEM, false, NULL, UNIT_FILE_PRESET_FULL, false, NULL, 0);
1616 if (r < 0)
1617 log_warning_errno(r, "Failed to populate /etc with preset unit settings, ignoring: %m");
1618 else
1619 log_info("Populated /etc with preset unit settings.");
1620 }
1621 }
1622
1623 r = manager_new(arg_running_as, arg_action == ACTION_TEST, &m);
1624 if (r < 0) {
1625 log_emergency_errno(r, "Failed to allocate manager object: %m");
1626 error_message = "Failed to allocate manager object";
1627 goto finish;
1628 }
1629
1630 m->confirm_spawn = arg_confirm_spawn;
1631 m->default_timer_accuracy_usec = arg_default_timer_accuracy_usec;
1632 m->default_std_output = arg_default_std_output;
1633 m->default_std_error = arg_default_std_error;
1634 m->default_restart_usec = arg_default_restart_usec;
1635 m->default_timeout_start_usec = arg_default_timeout_start_usec;
1636 m->default_timeout_stop_usec = arg_default_timeout_stop_usec;
1637 m->default_start_limit_interval = arg_default_start_limit_interval;
1638 m->default_start_limit_burst = arg_default_start_limit_burst;
1639 m->default_cpu_accounting = arg_default_cpu_accounting;
1640 m->default_blockio_accounting = arg_default_blockio_accounting;
1641 m->default_memory_accounting = arg_default_memory_accounting;
1642 m->runtime_watchdog = arg_runtime_watchdog;
1643 m->shutdown_watchdog = arg_shutdown_watchdog;
1644
1645 m->userspace_timestamp = userspace_timestamp;
1646 m->kernel_timestamp = kernel_timestamp;
1647 m->initrd_timestamp = initrd_timestamp;
1648 m->security_start_timestamp = security_start_timestamp;
1649 m->security_finish_timestamp = security_finish_timestamp;
1650
1651 manager_set_default_rlimits(m, arg_default_rlimit);
1652 manager_environment_add(m, NULL, arg_default_environment);
1653 manager_set_show_status(m, arg_show_status);
1654 manager_set_first_boot(m, empty_etc);
1655
1656 /* Remember whether we should queue the default job */
1657 queue_default_job = !arg_serialization || arg_switched_root;
1658
1659 before_startup = now(CLOCK_MONOTONIC);
1660
1661 r = manager_startup(m, arg_serialization, fds);
1662 if (r < 0)
1663 log_error_errno(r, "Failed to fully start up daemon: %m");
1664
1665 /* This will close all file descriptors that were opened, but
1666 * not claimed by any unit. */
1667 fdset_free(fds);
1668 fds = NULL;
1669
1670 if (arg_serialization) {
1671 fclose(arg_serialization);
1672 arg_serialization = NULL;
1673 }
1674
1675 if (queue_default_job) {
1676 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1677 Unit *target = NULL;
1678 Job *default_unit_job;
1679
1680 log_debug("Activating default unit: %s", arg_default_unit);
1681
1682 r = manager_load_unit(m, arg_default_unit, NULL, &error, &target);
1683 if (r < 0)
1684 log_error("Failed to load default target: %s", bus_error_message(&error, r));
1685 else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND)
1686 log_error_errno(target->load_error, "Failed to load default target: %m");
1687 else if (target->load_state == UNIT_MASKED)
1688 log_error("Default target masked.");
1689
1690 if (!target || target->load_state != UNIT_LOADED) {
1691 log_info("Trying to load rescue target...");
1692
1693 r = manager_load_unit(m, SPECIAL_RESCUE_TARGET, NULL, &error, &target);
1694 if (r < 0) {
1695 log_emergency("Failed to load rescue target: %s", bus_error_message(&error, r));
1696 error_message = "Failed to load rescue target";
1697 goto finish;
1698 } else if (target->load_state == UNIT_ERROR || target->load_state == UNIT_NOT_FOUND) {
1699 log_emergency_errno(target->load_error, "Failed to load rescue target: %m");
1700 error_message = "Failed to load rescue target";
1701 goto finish;
1702 } else if (target->load_state == UNIT_MASKED) {
1703 log_emergency("Rescue target masked.");
1704 error_message = "Rescue target masked";
1705 goto finish;
1706 }
1707 }
1708
1709 assert(target->load_state == UNIT_LOADED);
1710
1711 if (arg_action == ACTION_TEST) {
1712 printf("-> By units:\n");
1713 manager_dump_units(m, stdout, "\t");
1714 }
1715
1716 r = manager_add_job(m, JOB_START, target, JOB_ISOLATE, false, &error, &default_unit_job);
1717 if (r == -EPERM) {
1718 log_debug("Default target could not be isolated, starting instead: %s", bus_error_message(&error, r));
1719
1720 r = manager_add_job(m, JOB_START, target, JOB_REPLACE, false, &error, &default_unit_job);
1721 if (r < 0) {
1722 log_emergency("Failed to start default target: %s", bus_error_message(&error, r));
1723 error_message = "Failed to start default target";
1724 goto finish;
1725 }
1726 } else if (r < 0) {
1727 log_emergency("Failed to isolate default target: %s", bus_error_message(&error, r));
1728 error_message = "Failed to isolate default target";
1729 goto finish;
1730 }
1731
1732 m->default_unit_job_id = default_unit_job->id;
1733
1734 after_startup = now(CLOCK_MONOTONIC);
1735 log_full(arg_action == ACTION_TEST ? LOG_INFO : LOG_DEBUG,
1736 "Loaded units and determined initial transaction in %s.",
1737 format_timespan(timespan, sizeof(timespan), after_startup - before_startup, 100 * USEC_PER_MSEC));
1738
1739 if (arg_action == ACTION_TEST) {
1740 printf("-> By jobs:\n");
1741 manager_dump_jobs(m, stdout, "\t");
1742 retval = EXIT_SUCCESS;
1743 goto finish;
1744 }
1745 }
1746
1747 for (;;) {
1748 r = manager_loop(m);
1749 if (r < 0) {
1750 log_emergency_errno(r, "Failed to run main loop: %m");
1751 error_message = "Failed to run main loop";
1752 goto finish;
1753 }
1754
1755 switch (m->exit_code) {
1756
1757 case MANAGER_EXIT:
1758 retval = EXIT_SUCCESS;
1759 log_debug("Exit.");
1760 goto finish;
1761
1762 case MANAGER_RELOAD:
1763 log_info("Reloading.");
1764 r = manager_reload(m);
1765 if (r < 0)
1766 log_error_errno(r, "Failed to reload: %m");
1767 break;
1768
1769 case MANAGER_REEXECUTE:
1770
1771 if (prepare_reexecute(m, &arg_serialization, &fds, false) < 0) {
1772 error_message = "Failed to prepare for reexection";
1773 goto finish;
1774 }
1775
1776 reexecute = true;
1777 log_notice("Reexecuting.");
1778 goto finish;
1779
1780 case MANAGER_SWITCH_ROOT:
1781 /* Steal the switch root parameters */
1782 switch_root_dir = m->switch_root;
1783 switch_root_init = m->switch_root_init;
1784 m->switch_root = m->switch_root_init = NULL;
1785
1786 if (!switch_root_init)
1787 if (prepare_reexecute(m, &arg_serialization, &fds, true) < 0) {
1788 error_message = "Failed to prepare for reexection";
1789 goto finish;
1790 }
1791
1792 reexecute = true;
1793 log_notice("Switching root.");
1794 goto finish;
1795
1796 case MANAGER_REBOOT:
1797 case MANAGER_POWEROFF:
1798 case MANAGER_HALT:
1799 case MANAGER_KEXEC: {
1800 static const char * const table[_MANAGER_EXIT_CODE_MAX] = {
1801 [MANAGER_REBOOT] = "reboot",
1802 [MANAGER_POWEROFF] = "poweroff",
1803 [MANAGER_HALT] = "halt",
1804 [MANAGER_KEXEC] = "kexec"
1805 };
1806
1807 assert_se(shutdown_verb = table[m->exit_code]);
1808 arm_reboot_watchdog = m->exit_code == MANAGER_REBOOT;
1809
1810 log_notice("Shutting down.");
1811 goto finish;
1812 }
1813
1814 default:
1815 assert_not_reached("Unknown exit code.");
1816 }
1817 }
1818
1819 finish:
1820 pager_close();
1821
1822 m = manager_free(m);
1823
1824 for (j = 0; j < ELEMENTSOF(arg_default_rlimit); j++) {
1825 free(arg_default_rlimit[j]);
1826 arg_default_rlimit[j] = NULL;
1827 }
1828
1829 free(arg_default_unit);
1830 arg_default_unit = NULL;
1831
1832 free_join_controllers();
1833
1834 strv_free(arg_default_environment);
1835 arg_default_environment = NULL;
1836
1837 set_free(arg_syscall_archs);
1838 arg_syscall_archs = NULL;
1839
1840 mac_selinux_finish();
1841
1842 if (reexecute) {
1843 const char **args;
1844 unsigned i, args_size;
1845
1846 /* Close and disarm the watchdog, so that the new
1847 * instance can reinitialize it, but doesn't get
1848 * rebooted while we do that */
1849 watchdog_close(true);
1850
1851 /* Reset the RLIMIT_NOFILE to the kernel default, so
1852 * that the new systemd can pass the kernel default to
1853 * its child processes */
1854 if (saved_rlimit_nofile.rlim_cur > 0)
1855 setrlimit(RLIMIT_NOFILE, &saved_rlimit_nofile);
1856
1857 if (switch_root_dir) {
1858 /* Kill all remaining processes from the
1859 * initrd, but don't wait for them, so that we
1860 * can handle the SIGCHLD for them after
1861 * deserializing. */
1862 broadcast_signal(SIGTERM, false, true);
1863
1864 /* And switch root with MS_MOVE, because we remove the old directory afterwards and detach it. */
1865 r = switch_root(switch_root_dir, "/mnt", true, MS_MOVE);
1866 if (r < 0)
1867 log_error_errno(r, "Failed to switch root, trying to continue: %m");
1868 }
1869
1870 args_size = MAX(6, argc+1);
1871 args = newa(const char*, args_size);
1872
1873 if (!switch_root_init) {
1874 char sfd[16];
1875
1876 /* First try to spawn ourselves with the right
1877 * path, and with full serialization. We do
1878 * this only if the user didn't specify an
1879 * explicit init to spawn. */
1880
1881 assert(arg_serialization);
1882 assert(fds);
1883
1884 snprintf(sfd, sizeof(sfd), "%i", fileno(arg_serialization));
1885 char_array_0(sfd);
1886
1887 i = 0;
1888 args[i++] = SYSTEMD_BINARY_PATH;
1889 if (switch_root_dir)
1890 args[i++] = "--switched-root";
1891 args[i++] = arg_running_as == SYSTEMD_SYSTEM ? "--system" : "--user";
1892 args[i++] = "--deserialize";
1893 args[i++] = sfd;
1894 args[i++] = NULL;
1895
1896 /* do not pass along the environment we inherit from the kernel or initrd */
1897 if (switch_root_dir)
1898 clearenv();
1899
1900 assert(i <= args_size);
1901 execv(args[0], (char* const*) args);
1902 }
1903
1904 /* Try the fallback, if there is any, without any
1905 * serialization. We pass the original argv[] and
1906 * envp[]. (Well, modulo the ordering changes due to
1907 * getopt() in argv[], and some cleanups in envp[],
1908 * but let's hope that doesn't matter.) */
1909
1910 if (arg_serialization) {
1911 fclose(arg_serialization);
1912 arg_serialization = NULL;
1913 }
1914
1915 if (fds) {
1916 fdset_free(fds);
1917 fds = NULL;
1918 }
1919
1920 /* Reopen the console */
1921 make_console_stdio();
1922
1923 for (j = 1, i = 1; j < (unsigned) argc; j++)
1924 args[i++] = argv[j];
1925 args[i++] = NULL;
1926 assert(i <= args_size);
1927
1928 /* Reenable any blocked signals, especially important
1929 * if we switch from initial ramdisk to init=... */
1930 reset_all_signal_handlers();
1931 reset_signal_mask();
1932
1933 if (switch_root_init) {
1934 args[0] = switch_root_init;
1935 execv(args[0], (char* const*) args);
1936 log_warning_errno(errno, "Failed to execute configured init, trying fallback: %m");
1937 }
1938
1939 args[0] = "/sbin/init";
1940 execv(args[0], (char* const*) args);
1941
1942 if (errno == ENOENT) {
1943 log_warning("No /sbin/init, trying fallback");
1944
1945 args[0] = "/bin/sh";
1946 args[1] = NULL;
1947 execv(args[0], (char* const*) args);
1948 log_error_errno(errno, "Failed to execute /bin/sh, giving up: %m");
1949 } else
1950 log_warning_errno(errno, "Failed to execute /sbin/init, giving up: %m");
1951 }
1952
1953 if (arg_serialization) {
1954 fclose(arg_serialization);
1955 arg_serialization = NULL;
1956 }
1957
1958 if (fds) {
1959 fdset_free(fds);
1960 fds = NULL;
1961 }
1962
1963 #ifdef HAVE_VALGRIND_VALGRIND_H
1964 /* If we are PID 1 and running under valgrind, then let's exit
1965 * here explicitly. valgrind will only generate nice output on
1966 * exit(), not on exec(), hence let's do the former not the
1967 * latter here. */
1968 if (getpid() == 1 && RUNNING_ON_VALGRIND)
1969 return 0;
1970 #endif
1971
1972 if (shutdown_verb) {
1973 char log_level[DECIMAL_STR_MAX(int) + 1];
1974 const char* command_line[9] = {
1975 SYSTEMD_SHUTDOWN_BINARY_PATH,
1976 shutdown_verb,
1977 "--log-level", log_level,
1978 "--log-target",
1979 };
1980 unsigned pos = 5;
1981 _cleanup_strv_free_ char **env_block = NULL;
1982
1983 assert(command_line[pos] == NULL);
1984 env_block = strv_copy(environ);
1985
1986 snprintf(log_level, sizeof(log_level), "%d", log_get_max_level());
1987
1988 switch (log_get_target()) {
1989 case LOG_TARGET_KMSG:
1990 case LOG_TARGET_JOURNAL_OR_KMSG:
1991 case LOG_TARGET_SYSLOG_OR_KMSG:
1992 command_line[pos++] = "kmsg";
1993 break;
1994
1995 case LOG_TARGET_CONSOLE:
1996 default:
1997 command_line[pos++] = "console";
1998 break;
1999 };
2000
2001 if (log_get_show_color())
2002 command_line[pos++] = "--log-color";
2003
2004 if (log_get_show_location())
2005 command_line[pos++] = "--log-location";
2006
2007 assert(pos < ELEMENTSOF(command_line));
2008
2009 if (arm_reboot_watchdog && arg_shutdown_watchdog > 0) {
2010 char *e;
2011
2012 /* If we reboot let's set the shutdown
2013 * watchdog and tell the shutdown binary to
2014 * repeatedly ping it */
2015 watchdog_set_timeout(&arg_shutdown_watchdog);
2016 watchdog_close(false);
2017
2018 /* Tell the binary how often to ping, ignore failure */
2019 if (asprintf(&e, "WATCHDOG_USEC="USEC_FMT, arg_shutdown_watchdog) > 0)
2020 strv_push(&env_block, e);
2021 } else
2022 watchdog_close(true);
2023
2024 /* Avoid the creation of new processes forked by the
2025 * kernel; at this point, we will not listen to the
2026 * signals anyway */
2027 if (detect_container(NULL) <= 0)
2028 cg_uninstall_release_agent(SYSTEMD_CGROUP_CONTROLLER);
2029
2030 execve(SYSTEMD_SHUTDOWN_BINARY_PATH, (char **) command_line, env_block);
2031 log_error_errno(errno, "Failed to execute shutdown binary, %s: %m",
2032 getpid() == 1 ? "freezing" : "quitting");
2033 }
2034
2035 if (getpid() == 1) {
2036 if (error_message)
2037 manager_status_printf(NULL, STATUS_TYPE_EMERGENCY,
2038 ANSI_HIGHLIGHT_RED_ON "!!!!!!" ANSI_HIGHLIGHT_OFF,
2039 "%s, freezing.", error_message);
2040 freeze();
2041 }
2042
2043 return retval;
2044 }
Unnamed repository; edit this file 'description' to name the repository.