/* * rc.c * rc - manager for init scripts which control the startup, shutdown * and the running of daemons. * * Also a multicall binary for various commands that can be used in shell * scripts to query service state, mark service state and provide the * einfo family of informational functions. */ /* * Copyright (c) 2007-2009 Roy Marples * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ const char rc_copyright[] = "Copyright (c) 2007-2008 Roy Marples"; #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "builtins.h" #include "einfo.h" #include "rc.h" #include "rc-logger.h" #include "rc-misc.h" #include "rc-plugin.h" #include "version.h" #define INITSH RC_LIBEXECDIR "/sh/init.sh" #define INITEARLYSH RC_LIBEXECDIR "/sh/init-early.sh" #define SHUTDOWN "/sbin/shutdown" #define SULOGIN "/sbin/sulogin" #define INTERACTIVE RC_SVCDIR "/interactive" #define DEVBOOT "/dev/.rcboot" const char *applet = NULL; static char *runlevel; static RC_HOOK hook_out; struct termios *termios_orig = NULL; RC_PIDLIST service_pids; static void clean_failed(void) { DIR *dp; struct dirent *d; size_t l; char *path; /* Clean the failed services state dir now */ if ((dp = opendir(RC_SVCDIR "/failed"))) { while ((d = readdir(dp))) { if (d->d_name[0] == '.' && (d->d_name[1] == '\0' || (d->d_name[1] == '.' && d->d_name[2] == '\0'))) continue; l = strlen(RC_SVCDIR "/failed/") + strlen(d->d_name) + 1; path = xmalloc(sizeof(char) * l); snprintf(path, l, RC_SVCDIR "/failed/%s", d->d_name); if (path) { if (unlink(path)) eerror("%s: unlink `%s': %s", applet, path, strerror(errno)); free(path); } } closedir(dp); } } static void cleanup(void) { #ifdef DEBUG_MEMORY RC_PID *p1 = LIST_FIRST(&service_pids); RC_PID *p2; #endif if (!rc_in_logger && !rc_in_plugin && applet && (strcmp(applet, "rc") == 0 || strcmp(applet, "openrc") == 0)) { if (hook_out) rc_plugin_run(hook_out, runlevel); rc_plugin_unload(); if (termios_orig) { tcsetattr(STDIN_FILENO, TCSANOW, termios_orig); free(termios_orig); } /* Clean runlevel start, stop markers */ rmdir(RC_STARTING); rmdir(RC_STOPPING); clean_failed(); rc_logger_close(); } #ifdef DEBUG_MEMORY while (p1) { p2 = LIST_NEXT(p1, entries); free(p1); p1 = p2; } rc_stringlist_free(hotplugged_services); rc_stringlist_free(stop_services); rc_stringlist_free(start_services); rc_stringlist_free(types_n); rc_stringlist_free(types_nua); rc_deptree_free(deptree); free(runlevel); #endif } static char read_key(bool block) { struct termios termios; char c = 0; int fd = STDIN_FILENO; if (!isatty(fd)) return false; /* Now save our terminal settings. We need to restore them at exit as we will be changing it for non-blocking reads for Interactive */ if (!termios_orig) { termios_orig = xmalloc(sizeof(*termios_orig)); tcgetattr(fd, termios_orig); } tcgetattr(fd, &termios); termios.c_lflag &= ~(ICANON | ECHO); if (block) termios.c_cc[VMIN] = 1; else { termios.c_cc[VMIN] = 0; termios.c_cc[VTIME] = 0; } tcsetattr(fd, TCSANOW, &termios); if (read(fd, &c, 1) == -1) eerror("read: %s", strerror(errno)); tcsetattr(fd, TCSANOW, termios_orig); return c; } static bool want_interactive(void) { char c; static bool gotinteractive; static bool interactive; if (rc_yesno(getenv("EINFO_QUIET"))) return false; if (!gotinteractive) { gotinteractive = true; interactive = rc_conf_yesno("rc_interactive"); } if (!interactive) return false; c = read_key(false); return (c == 'I' || c == 'i') ? true : false; } static void mark_interactive(void) { FILE *fp = fopen(INTERACTIVE, "w"); if (fp) fclose(fp); } static void run_program(const char *prog) { struct sigaction sa; sigset_t full; sigset_t old; pid_t pid; /* We need to block signals until we have forked */ memset(&sa, 0, sizeof(sa)); sa.sa_handler = SIG_DFL; sigemptyset(&sa.sa_mask); sigfillset(&full); sigprocmask(SIG_SETMASK, &full, &old); pid = fork(); if (pid == -1) eerrorx("%s: fork: %s", applet, strerror(errno)); if (pid == 0) { /* Restore default handlers */ sigaction(SIGCHLD, &sa, NULL); sigaction(SIGHUP, &sa, NULL); sigaction(SIGINT, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGUSR1, &sa, NULL); sigaction(SIGWINCH, &sa, NULL); /* Unmask signals */ sigprocmask(SIG_SETMASK, &old, NULL); if (termios_orig) tcsetattr(STDIN_FILENO, TCSANOW, termios_orig); execl(prog, prog, (char *)NULL); eerror("%s: unable to exec `%s': %s", applet, prog, strerror(errno)); _exit(EXIT_FAILURE); } /* Unmask signals and wait for child */ sigprocmask(SIG_SETMASK, &old, NULL); if (rc_waitpid(pid) == -1) eerrorx("%s: failed to exec `%s'", applet, prog); } static void open_shell(void) { const char *shell; struct passwd *pw; #ifdef __linux__ const char *sys = rc_sys(); /* VSERVER and OPENVZ systems cannot really drop to shells */ if (sys && (strcmp(sys, "VSERVER") == 0 || strcmp(sys, "OPENVZ") == 0)) { execl("/sbin/halt", "/sbin/halt", "-f", (char *) NULL); eerrorx("%s: unable to exec `/sbin/halt': %s", applet, strerror(errno)); } #endif shell = rc_conf_value("rc_shell"); /* No shell set, so obey env, then passwd, then default to /bin/sh */ if (shell == NULL) { shell = getenv("SHELL"); if (shell == NULL) { pw = getpwuid(getuid()); if (pw) shell = pw->pw_shell; if (shell == NULL) shell = "/bin/sh"; } } run_program(shell); } static bool set_krunlevel(const char *level) { FILE *fp; if (!level || strcmp(level, getenv ("RC_BOOTLEVEL")) == 0 || strcmp(level, RC_LEVEL_SINGLE) == 0 || strcmp(level, RC_LEVEL_SYSINIT) == 0) { if (exists(RC_KRUNLEVEL) && unlink(RC_KRUNLEVEL) != 0) eerror("unlink `%s': %s", RC_KRUNLEVEL, strerror(errno)); return false; } if (!(fp = fopen(RC_KRUNLEVEL, "w"))) { eerror("fopen `%s': %s", RC_KRUNLEVEL, strerror(errno)); return false; } fprintf(fp, "%s", level); fclose(fp); return true; } static size_t get_krunlevel(char *buffer, int buffer_len) { FILE *fp; size_t i = 0; if (!exists(RC_KRUNLEVEL)) return 0; if (!(fp = fopen(RC_KRUNLEVEL, "r"))) { eerror("fopen `%s': %s", RC_KRUNLEVEL, strerror(errno)); return 0; } if (fgets(buffer, buffer_len, fp)) { i = strlen(buffer); if (buffer[i - 1] == '\n') buffer[i - 1] = 0; } fclose(fp); return i; } static void add_pid(pid_t pid) { RC_PID *p = xmalloc(sizeof(*p)); p->pid = pid; LIST_INSERT_HEAD(&service_pids, p, entries); } static void remove_pid(pid_t pid) { RC_PID *p; LIST_FOREACH(p, &service_pids, entries) if (p->pid == pid) { LIST_REMOVE(p, entries); free(p); return; } } static void wait_for_services(void) { for (;;) { while (waitpid(0, 0, 0) != -1) ; if (errno != EINTR) break; } } static void handle_signal(int sig) { int serrno = errno; char signame[10] = { '\0' }; pid_t pid; RC_PID *pi; int status = 0; struct winsize ws; sigset_t sset; switch (sig) { case SIGCHLD: do { pid = waitpid(-1, &status, WNOHANG); if (pid < 0) { if (errno != ECHILD) eerror("waitpid: %s", strerror(errno)); return; } } while (!WIFEXITED(status) && !WIFSIGNALED(status)); /* Remove that pid from our list */ if (pid > 0) remove_pid(pid); break; case SIGWINCH: if (rc_logger_tty >= 0) { ioctl(STDIN_FILENO, TIOCGWINSZ, &ws); ioctl(rc_logger_tty, TIOCSWINSZ, &ws); } break; case SIGINT: if (!signame[0]) snprintf(signame, sizeof(signame), "SIGINT"); /* FALLTHROUGH */ case SIGTERM: if (!signame[0]) snprintf(signame, sizeof(signame), "SIGTERM"); /* FALLTHROUGH */ case SIGQUIT: if (!signame[0]) snprintf(signame, sizeof(signame), "SIGQUIT"); eerrorx("%s: caught %s, aborting", applet, signame); /* NOTREACHED */ case SIGUSR1: eerror("rc: Aborting!"); /* Block child signals */ sigemptyset(&sset); sigaddset(&sset, SIGCHLD); sigprocmask(SIG_BLOCK, &sset, NULL); /* Kill any running services we have started */ LIST_FOREACH(pi, &service_pids, entries) kill(pi->pid, SIGTERM); /* Notify plugins we are aborting */ rc_plugin_run(RC_HOOK_ABORT, NULL); exit(EXIT_FAILURE); /* NOTREACHED */ default: eerror("%s: caught unknown signal %d", applet, sig); } /* Restore errno */ errno = serrno; } static void do_sysinit() { struct utsname uts; const char *sys; /* exec init-early.sh if it exists * This should just setup the console to use the correct * font. Maybe it should setup the keyboard too? */ if (exists(INITEARLYSH)) run_program(INITEARLYSH); uname(&uts); printf("\n %sOpenRC %s" VERSION "%s is starting up %s", ecolor(ECOLOR_GOOD), ecolor(ECOLOR_HILITE), ecolor(ECOLOR_NORMAL), ecolor(ECOLOR_BRACKET)); #ifdef BRANDING printf(BRANDING " (%s)", uts.machine); #else printf("%s %s (%s)", uts.sysname, uts.release, uts.machine); #endif if ((sys = rc_sys())) printf(" [%s]", sys); printf("%s\n\n", ecolor(ECOLOR_NORMAL)); if (!rc_yesno(getenv ("EINFO_QUIET")) && rc_conf_yesno("rc_interactive")) printf("Press %sI%s to enter interactive boot mode\n\n", ecolor(ECOLOR_GOOD), ecolor(ECOLOR_NORMAL)); setenv("RC_RUNLEVEL", RC_LEVEL_SYSINIT, 1); run_program(INITSH); /* init may have mounted /proc so we can now detect or real * sys */ if ((sys = rc_sys())) setenv("RC_SYS", sys, 1); } static bool runlevel_config(const char *service, const char *level) { char *init = rc_service_resolve(service); char *conf, *dir; size_t l; bool retval; dir = dirname(init); dir = dirname(init); l = strlen(dir) + strlen(level) + strlen(service) + 10; conf = xmalloc(sizeof(char) * l); snprintf(conf, l, "%s/conf.d/%s.%s", dir, service, level); retval = exists(conf); free(conf); free(init); return retval; } static void do_stop_services(const RC_STRINGLIST *types_n, const RC_STRINGLIST *start_services, const RC_STRINGLIST *stop_services, const RC_DEPTREE *deptree, const char *newlevel, bool parallel, bool going_down) { pid_t pid; RC_STRING *service, *svc1, *svc2; RC_STRINGLIST *deporder, *tmplist, *kwords; RC_SERVICE state; RC_STRINGLIST *nostop; bool crashed, nstop; if (!types_n) { types_n = rc_stringlist_new(); rc_stringlist_add(types_n, "needsme"); } crashed = rc_conf_yesno("rc_crashed_stop"); nostop = rc_stringlist_split(rc_conf_value("rc_nostop"), " "); TAILQ_FOREACH_REVERSE(service, stop_services, rc_stringlist, entries) { state = rc_service_state(service->value); if (state & RC_SERVICE_STOPPED || state & RC_SERVICE_FAILED) continue; /* Sometimes we don't ever want to stop a service. */ if (rc_stringlist_find(nostop, service->value)) { rc_service_mark(service->value, RC_SERVICE_FAILED); continue; } kwords = rc_deptree_depend(deptree, service->value, "keyword"); if (rc_stringlist_find(kwords, "-stop") || rc_stringlist_find(kwords, "nostop") || (going_down && (rc_stringlist_find(kwords, "-shutdown") || rc_stringlist_find(kwords, "noshutdown")))) nstop = true; else nstop = false; rc_stringlist_free(kwords); if (nstop) { rc_service_mark(service->value, RC_SERVICE_FAILED); continue; } /* If the service has crashed, skip futher checks and just stop it */ if (crashed && rc_service_daemons_crashed(service->value)) goto stop; /* If we're in the start list then don't bother stopping us */ svc1 = rc_stringlist_find(start_services, service->value); if (svc1) { if (newlevel && strcmp(runlevel, newlevel) != 0) { /* So we're in the start list. But we should * be stopped if we have a runlevel * configuration file for either the current * or next so we use the correct one. */ if (!runlevel_config(service->value,runlevel) && !runlevel_config(service->value,newlevel)) continue; } else continue; } /* We got this far. Last check is to see if any any service * that going to be started depends on us */ if (!svc1) { tmplist = rc_stringlist_new(); rc_stringlist_add(tmplist, service->value); deporder = rc_deptree_depends(deptree, types_n, tmplist, newlevel ? newlevel : runlevel, RC_DEP_STRICT | RC_DEP_TRACE); rc_stringlist_free(tmplist); svc2 = NULL; TAILQ_FOREACH(svc1, deporder, entries) { svc2 = rc_stringlist_find(start_services, svc1->value); if (svc2) break; } rc_stringlist_free(deporder); if (svc2) continue; } stop: /* After all that we can finally stop the blighter! */ pid = service_stop(service->value); if (pid > 0) { add_pid(pid); if (!parallel) { rc_waitpid(pid); remove_pid(pid); } } } rc_stringlist_free(nostop); } static void do_start_services(const RC_STRINGLIST *start_services, bool parallel) { RC_STRING *service; pid_t pid; bool interactive = false; RC_SERVICE state; bool crashed = false; if (!rc_yesno(getenv("EINFO_QUIET"))) interactive = exists(INTERACTIVE); errno = 0; crashed = rc_conf_yesno("rc_crashed_start"); if (errno == ENOENT) crashed = true; TAILQ_FOREACH(service, start_services, entries) { state = rc_service_state(service->value); if (state & RC_SERVICE_FAILED) continue; if (!(state & RC_SERVICE_STOPPED)) { if (crashed && rc_service_daemons_crashed(service->value)) rc_service_mark(service->value, RC_SERVICE_STOPPED); else continue; } if (!interactive) interactive = want_interactive(); if (interactive) { parallel = false; interactive_retry: printf("\n"); einfo("About to start the service %s", service->value); eindent(); einfo("1) Start the service\t\t2) Skip the service"); einfo("3) Continue boot process\t\t4) Exit to shell"); eoutdent(); interactive_option: switch (read_key(true)) { case '1': break; case '2': continue; case '3': interactive = false; break; case '4': open_shell(); goto interactive_retry; default: goto interactive_option; } } pid = service_start(service->value); /* Remember the pid if we're running in parallel */ if (pid > 0) { add_pid(pid); if (!parallel) { rc_waitpid(pid); remove_pid(pid); } } } /* Store our interactive status for boot */ if (interactive && (strcmp(runlevel, RC_LEVEL_SYSINIT) == 0 || strcmp(runlevel, getenv("RC_BOOTLEVEL")) == 0)) mark_interactive(); else { if (exists(INTERACTIVE)) unlink(INTERACTIVE); } } #ifdef RC_DEBUG static void handle_bad_signal(int sig) { char pid[10]; int status; pid_t crashed_pid = getpid(); switch (fork()) { case -1: _exit(sig); /* NOTREACHED */ case 0: sprintf(pid, "%i", crashed_pid); printf("\nAuto launching gdb!\n\n"); _exit(execlp("gdb", "gdb", "--quiet", "--pid", pid, "-ex", "bt full", NULL)); /* NOTREACHED */ default: wait(&status); } _exit(1); /* NOTREACHED */ } #endif #include "_usage.h" #define usagestring "" \ "Usage: openrc [options] []" #define getoptstring "a:no:s:S" getoptstring_COMMON static const struct option longopts[] = { { "applet", 1, NULL, 'a' }, { "no-stop", 0, NULL, 'n' }, { "override", 1, NULL, 'o' }, { "service", 1, NULL, 's' }, { "sys", 0, NULL, 'S' }, longopts_COMMON }; static const char * const longopts_help[] = { "runs the applet specified by the next argument", "do not stop any services", "override the next runlevel to change into\n" "when leaving single user or boot runlevels", "runs the service specified with the rest\nof the arguments", "output the RC system type, if any", longopts_help_COMMON }; #include "_usage.c" int main(int argc, char **argv) { const char *bootlevel = NULL; char *newlevel = NULL; static RC_STRINGLIST *hotplugged_services; static RC_STRINGLIST *stop_services; static RC_STRINGLIST *start_services; static RC_STRINGLIST *types_n; static RC_STRINGLIST *types_nua; static RC_DEPTREE *deptree; RC_STRINGLIST *deporder = NULL; RC_STRINGLIST *tmplist; RC_STRING *service; bool going_down = false; int depoptions = RC_DEP_STRICT | RC_DEP_TRACE; char krunlevel [PATH_MAX]; char pidstr[10]; int opt; bool parallel; int regen = 0; bool nostop = false; #ifdef __linux__ char *proc; char *p; char *token; #endif #ifdef RC_DEBUG signal_setup(SIGBUS, handle_bad_signal); signal_setup(SIGILL, handle_bad_signal); signal_setup(SIGSEGV, handle_bad_signal); #endif applet = basename_c(argv[0]); LIST_INIT(&service_pids); atexit(cleanup); if (!applet) eerrorx("arguments required"); /* Run our built in applets. If we ran one, we don't return. */ run_applets(argc, argv); argc--; argv++; /* Change dir to / to ensure all scripts don't use stuff in pwd */ if (chdir("/") == -1) eerror("chdir: %s", strerror(errno)); /* Ensure our environment is pure * Also, add our configuration to it */ env_filter(); env_config(); /* complain about old configuration settings if they exist */ if (exists(RC_CONF_OLD)) { ewarn("%s still exists on your system and should be removed.", RC_CONF_OLD); ewarn("Please migrate to the appropriate settings in %s", RC_CONF); } argc++; argv--; while ((opt = getopt_long(argc, argv, getoptstring, longopts, (int *) 0)) != -1) { switch (opt) { case 'a': /* Do nothing, actual logic in run_applets, this * is a placeholder */ break; case 'n': nostop = true; break; case 'o': if (*optarg == '\0') optarg = NULL; if (!rc_runlevel_exists(optarg)) { eerror("runlevel `%s' does not exist", optarg); exit(EXIT_FAILURE); } if (!set_krunlevel(optarg)) exit(EXIT_FAILURE); einfo("Overriding next runlevel to %s", optarg); exit(EXIT_SUCCESS); /* NOTREACHED */ case 's': newlevel = rc_service_resolve(optarg); if (!newlevel) eerrorx("%s: service `%s' does not exist", applet, optarg); argv += optind - 1; *argv = newlevel; execv(*argv, argv); eerrorx("%s: %s", applet, strerror(errno)); /* NOTREACHED */ case 'S': bootlevel = rc_sys(); if (bootlevel) printf("%s\n", bootlevel); exit(EXIT_SUCCESS); /* NOTREACHED */ case_RC_COMMON_GETOPT } } newlevel = argv[optind++]; /* To make life easier, we only have the shutdown runlevel as * nothing really needs to know that we're rebooting. * But for those that do, you can test against RC_REBOOT. */ if (newlevel) { if (strcmp(newlevel, "reboot") == 0) { newlevel = UNCONST(RC_LEVEL_SHUTDOWN); setenv("RC_REBOOT", "YES", 1); } } /* Enable logging */ setenv("EINFO_LOG", "openrc", 1); /* Export our PID */ snprintf(pidstr, sizeof(pidstr), "%d", getpid()); setenv("RC_PID", pidstr, 1); /* Create a list of all services which should be started for the new or * current runlevel including those in boot, sysinit and hotplugged * runlevels. Clearly, some of these will already be started so we * won't actually be starting them all. */ bootlevel = getenv("RC_BOOTLEVEL"); runlevel = rc_runlevel_get(); rc_logger_open(newlevel ? newlevel : runlevel); /* Setup a signal handler */ signal_setup(SIGINT, handle_signal); signal_setup(SIGQUIT, handle_signal); signal_setup(SIGTERM, handle_signal); signal_setup(SIGUSR1, handle_signal); signal_setup(SIGWINCH, handle_signal); /* Run any special sysinit foo */ if (newlevel && strcmp(newlevel, RC_LEVEL_SYSINIT) == 0) { do_sysinit(); free(runlevel); runlevel = rc_runlevel_get(); } rc_plugin_load(); /* Now we start handling our children */ signal_setup(SIGCHLD, handle_signal); if (newlevel && (strcmp(newlevel, RC_LEVEL_SHUTDOWN) == 0 || strcmp(newlevel, RC_LEVEL_SINGLE) == 0)) { going_down = true; if (!exists(RC_KRUNLEVEL)) set_krunlevel(runlevel); rc_runlevel_set(newlevel); setenv("RC_RUNLEVEL", newlevel, 1); setenv("RC_GOINGDOWN", "YES", 1); } else { /* We should not use krunevel in sysinit or boot runlevels */ if (!newlevel || (strcmp(newlevel, RC_LEVEL_SYSINIT) != 0 && strcmp(newlevel, getenv("RC_BOOTLEVEL")) != 0)) { if (get_krunlevel(krunlevel, sizeof(krunlevel))) { newlevel = krunlevel; set_krunlevel(NULL); } } if (newlevel) { if (strcmp(runlevel, newlevel) != 0 && !rc_runlevel_exists(newlevel)) eerrorx("%s: not a valid runlevel", newlevel); #ifdef __linux__ if (strcmp(newlevel, RC_LEVEL_SYSINIT) == 0) { /* If we requested a runlevel, save it now */ p = rc_proc_getent("rc_runlevel"); if (p == NULL) p = rc_proc_getent("softlevel"); if (p != NULL) { set_krunlevel(p); free(p); } } #endif } } if (going_down) { #ifdef __FreeBSD__ /* FIXME: we shouldn't have todo this */ /* For some reason, wait_for_services waits for the logger * proccess to finish as well, but only on FreeBSD. * We cannot allow this so we stop logging now. */ rc_logger_close(); #endif rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_IN, newlevel); } else { rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_IN, runlevel); } hook_out = RC_HOOK_RUNLEVEL_STOP_OUT; /* Check if runlevel is valid if we're changing */ if (newlevel && strcmp(runlevel, newlevel) != 0 && !going_down) { if (!rc_runlevel_exists(newlevel)) eerrorx("%s: is not a valid runlevel", newlevel); } /* Load our deptree */ if ((deptree = _rc_deptree_load(0, ®en)) == NULL) eerrorx("failed to load deptree"); if (exists(RC_DEPTREE_SKEWED)) ewarn("WARNING: clock skew detected!"); /* Clean the failed services state dir */ clean_failed(); if (mkdir(RC_STOPPING, 0755) != 0) { if (errno == EACCES) eerrorx("%s: superuser access required", applet); eerrorx("%s: failed to create stopping dir `%s': %s", applet, RC_STOPPING, strerror(errno)); } /* Create a list of all services which we could stop (assuming * they won't be active in the new or current runlevel) including * all those services which have been started, are inactive or * are currently starting. Clearly, some of these will be listed * in the new or current runlevel so we won't actually be stopping * them all. */ stop_services = rc_services_in_state(RC_SERVICE_STARTED); tmplist = rc_services_in_state(RC_SERVICE_INACTIVE); TAILQ_CONCAT(stop_services, tmplist, entries); free(tmplist); tmplist = rc_services_in_state(RC_SERVICE_STARTING); TAILQ_CONCAT(stop_services, tmplist, entries); free(tmplist); if (stop_services) rc_stringlist_sort(&stop_services); types_nua = rc_stringlist_new(); rc_stringlist_add(types_nua, "ineed"); rc_stringlist_add(types_nua, "iuse"); rc_stringlist_add(types_nua, "iafter"); if (stop_services) { tmplist = rc_deptree_depends(deptree, types_nua, stop_services, runlevel, depoptions | RC_DEP_STOP); rc_stringlist_free(stop_services); stop_services = tmplist; } /* Create a list of all services which should be started for the new or * current runlevel including those in boot, sysinit and hotplugged * runlevels. Clearly, some of these will already be started so we * won't actually be starting them all. */ hotplugged_services = rc_services_in_state(RC_SERVICE_HOTPLUGGED); start_services = rc_services_in_runlevel_stacked(newlevel ? newlevel : runlevel); if (strcmp(newlevel ? newlevel : runlevel, RC_LEVEL_SHUTDOWN) != 0 && strcmp(newlevel ? newlevel : runlevel, RC_LEVEL_SYSINIT) != 0) { tmplist = rc_services_in_runlevel(RC_LEVEL_SYSINIT); TAILQ_CONCAT(start_services, tmplist, entries); free(tmplist); /* If we are NOT headed for the single-user runlevel... */ if (strcmp(newlevel ? newlevel : runlevel, RC_LEVEL_SINGLE) != 0) { /* If we are NOT headed for the boot runlevel... */ if (strcmp(newlevel ? newlevel : runlevel, bootlevel) != 0) { tmplist = rc_services_in_runlevel(bootlevel); TAILQ_CONCAT(start_services, tmplist, entries); free(tmplist); } if (hotplugged_services) { TAILQ_FOREACH(service, hotplugged_services, entries) rc_stringlist_addu(start_services, service->value); } } } parallel = rc_conf_yesno("rc_parallel"); /* Now stop the services that shouldn't be running */ if (stop_services && !nostop) do_stop_services(types_n, start_services, stop_services, deptree, newlevel, parallel, going_down); /* Wait for our services to finish */ wait_for_services(); /* Notify the plugins we have finished */ rc_plugin_run(RC_HOOK_RUNLEVEL_STOP_OUT, going_down ? newlevel : runlevel); hook_out = 0; rmdir(RC_STOPPING); /* Store the new runlevel */ if (newlevel) { rc_runlevel_set(newlevel); free(runlevel); runlevel = xstrdup(newlevel); setenv("RC_RUNLEVEL", runlevel, 1); } #ifdef __linux__ /* We can't log beyond this point as the shutdown runlevel * will mount / readonly. */ if (strcmp(runlevel, RC_LEVEL_SHUTDOWN) == 0) rc_logger_close(); #endif mkdir(RC_STARTING, 0755); rc_plugin_run(RC_HOOK_RUNLEVEL_START_IN, runlevel); hook_out = RC_HOOK_RUNLEVEL_START_OUT; /* Re-add our hotplugged services if they stopped */ if (hotplugged_services) TAILQ_FOREACH(service, hotplugged_services, entries) rc_service_mark(service->value, RC_SERVICE_HOTPLUGGED); #ifdef __linux__ /* If the "noinit" parameter was passed on the kernel command line then * mark the specified services as started so they will not be started * by us. */ proc = p = rc_proc_getent("noinit"); if (proc) { while ((token = strsep(&p, ","))) rc_service_mark(token, RC_SERVICE_STARTED); free(proc); } #endif /* If we have a list of services to start then... */ if (start_services) { /* Get a list of the chained runlevels which compose the target runlevel */ RC_STRINGLIST *runlevel_chain = rc_runlevel_stacks(runlevel); /* Loop through them in reverse order. */ RC_STRING *rlevel; TAILQ_FOREACH_REVERSE(rlevel, runlevel_chain, rc_stringlist, entries) { /* Get a list of all the services in that runlevel */ RC_STRINGLIST *run_services = rc_services_in_runlevel(rlevel->value); /* Start those services. */ rc_stringlist_sort(&run_services); deporder = rc_deptree_depends(deptree, types_nua, run_services, rlevel->value, depoptions | RC_DEP_START); rc_stringlist_free(run_services); run_services = deporder; do_start_services(run_services, parallel); /* Wait for our services to finish */ wait_for_services(); /* Free the list of services, we're done with it. */ rc_stringlist_free(run_services); } rc_stringlist_free(runlevel_chain); } #ifdef __linux__ /* If the "noinit" parameter was passed on the kernel command line then * mark the specified services as stopped so that our records reflect * reality. */ proc = p = rc_proc_getent("noinit"); if (proc) { while ((token = strsep(&p, ","))) rc_service_mark(token, RC_SERVICE_STOPPED); free(proc); } #endif rc_plugin_run(RC_HOOK_RUNLEVEL_START_OUT, runlevel); hook_out = 0; /* If we're in the boot runlevel and we regenerated our dependencies * we need to delete them so that they are regenerated again in the * default runlevel as they may depend on things that are now * available */ if (regen && strcmp(runlevel, bootlevel) == 0) unlink(RC_DEPTREE_CACHE); return EXIT_SUCCESS; }