2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Donn Seeley at Berkeley Software Design, Inc.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * @(#) Copyright (c) 1991, 1993 The Regents of the University of California. All rights reserved.
33 * @(#)init.c 8.1 (Berkeley) 7/15/93
34 * $FreeBSD: src/sbin/init/init.c,v 1.38.2.8 2001/10/22 11:27:32 des Exp $
37 #include <sys/param.h>
38 #include <sys/ioctl.h>
39 #include <sys/mount.h>
40 #include <sys/sysctl.h>
58 #include <sys/reboot.h>
68 #include <login_cap.h>
71 #include "pathnames.h"
74 * Sleep times; used to prevent thrashing.
76 #define GETTY_SPACING 5 /* N secs minimum getty spacing */
77 #define GETTY_SLEEP 30 /* sleep N secs after spacing problem */
78 #define GETTY_NSPACE 3 /* max. spacing count to bring reaction */
79 #define WINDOW_WAIT 3 /* wait N secs after starting window */
80 #define STALL_TIMEOUT 30 /* wait N secs after warning */
81 #define DEATH_WATCH 10 /* wait N secs for procs to die */
82 #define DEATH_SCRIPT 120 /* wait for 2min for /etc/rc.shutdown */
85 * User-based resource limits.
87 #define RESOURCE_RC "daemon"
88 #define RESOURCE_WINDOW "default"
89 #define RESOURCE_GETTY "default"
92 #define DEFAULT_STATE runcom
105 typedef state_t (*state_func_t
)(void);
107 static state_t
f_single_user(void);
108 static state_t
f_runcom(void);
109 static state_t
f_read_ttys(void);
110 static state_t
f_multi_user(void);
111 static state_t
f_clean_ttys(void);
112 static state_t
f_catatonia(void);
113 static state_t
f_death(void);
115 state_func_t state_funcs
[] = {
126 enum { AUTOBOOT
, FASTBOOT
} runcom_mode
= AUTOBOOT
;
130 static void transition(state_t
);
131 static volatile sig_atomic_t requested_transition
= DEFAULT_STATE
;
133 static void setctty(const char *);
135 typedef struct init_session
{
136 int se_index
; /* index of entry in ttys file */
137 pid_t se_process
; /* controlling process */
138 struct timeval se_started
; /* used to avoid thrashing */
139 int se_flags
; /* status of session */
140 #define SE_SHUTDOWN 0x1 /* session won't be restarted */
141 #define SE_PRESENT 0x2 /* session is in /etc/ttys */
142 int se_nspace
; /* spacing count */
143 char *se_device
; /* filename of port */
144 char *se_getty
; /* what to run on that port */
145 char *se_getty_argv_space
; /* pre-parsed argument array space */
146 char **se_getty_argv
; /* pre-parsed argument array */
147 char *se_window
; /* window system (started only once) */
148 char *se_window_argv_space
; /* pre-parsed argument array space */
149 char **se_window_argv
; /* pre-parsed argument array */
150 char *se_type
; /* default terminal type */
151 struct init_session
*se_prev
;
152 struct init_session
*se_next
;
155 static void handle(sig_t
, ...);
156 static void delset(sigset_t
*, ...);
158 static void stall(const char *, ...) __printflike(1, 2);
159 static void warning(const char *, ...) __printflike(1, 2);
160 static void emergency(const char *, ...) __printflike(1, 2);
161 static void disaster(int);
162 static void badsys(int);
163 static int runshutdown(void);
164 static char *strk(char *);
167 #define SINGLE_USER 's'
169 #define READ_TTYS 't'
170 #define MULTI_USER 'm'
171 #define CLEAN_TTYS 'T'
172 #define CATATONIA 'c'
174 static void free_session(session_t
*);
175 static session_t
*new_session(session_t
*, int, struct ttyent
*);
176 static void adjttyent(struct ttyent
*typ
);
178 static char **construct_argv(char *);
179 static void start_window_system(session_t
*);
180 static void collect_child(pid_t
);
181 static pid_t
start_getty(session_t
*);
182 static void transition_handler(int);
183 static void alrm_handler(int);
184 static void setsecuritylevel(int);
185 static int getsecuritylevel(void);
186 static char *get_chroot(void);
187 static int setupargv(session_t
*, struct ttyent
*);
189 static void setprocresources(const char *);
192 static void clear_session_logs(session_t
*);
194 static int start_session_db(void);
195 static void add_session(session_t
*);
196 static void del_session(session_t
*);
197 static session_t
*find_session(pid_t
);
200 static struct timeval boot_time
;
201 state_t current_state
= death
;
202 static void session_utmpx(const session_t
*, int);
203 static void make_utmpx(const char *, const char *, int, pid_t
,
204 const struct timeval
*, int);
205 static char get_runlevel(const state_t
);
206 static void utmpx_set_runlevel(char, char);
209 static int Reboot
= FALSE
;
210 static int howto
= RB_AUTOBOOT
;
212 static DB
*session_db
;
213 static volatile sig_atomic_t clang
;
214 static session_t
*sessions
;
217 * The mother of all processes.
220 main(int argc
, char *argv
[])
229 (void)gettimeofday(&boot_time
, NULL
);
230 #endif /* SUPPORT_UTMPX */
232 /* Dispose of random users. */
234 errx(1, "%s", strerror(EPERM
));
236 /* System V users like to reexec init. */
238 #ifdef COMPAT_SYSV_INIT
239 /* So give them what they want */
241 if (strlen(argv
[1]) == 1) {
242 char runlevel
= *argv
[1];
246 case '0': /* halt + poweroff */
249 case '1': /* single-user */
252 case '6': /* reboot */
255 case 'c': /* block further logins */
258 case 'q': /* rescan /etc/ttys */
268 errx(1, "invalid run-level ``%s''", argv
[1]);
271 errx(1, "already running");
274 * Note that this does NOT open a file...
275 * Does 'init' deserve its own facility number?
277 openlog("init", LOG_CONS
, LOG_AUTH
);
280 * If chroot has been requested by the boot loader,
281 * do it now. Try to be robust: If the directory
282 * doesn't exist, continue anyway.
284 init_chroot
= get_chroot();
285 if (init_chroot
!= NULL
) {
286 if (chdir(init_chroot
) == -1 || chroot(".") == -1)
287 warning("can't chroot to %s: %m", init_chroot
);
292 * Create an initial session.
295 warning("initial setsid() failed: %m");
298 * Establish an initial user so that programs running
299 * single user do not freak out and die (like passwd).
301 if (setlogin("root") < 0)
302 warning("setlogin() failed: %m");
304 if (stat("/dev/null", &sts
) < 0) {
305 warning("/dev MAY BE CORRUPT! /dev/null is missing!\n");
310 * This code assumes that we always get arguments through flags,
311 * never through bits set in some random machine register.
313 while ((c
= getopt(argc
, argv
, "dsf")) != -1)
316 /* We don't support DEVFS. */
319 requested_transition
= single_user
;
322 runcom_mode
= FASTBOOT
;
325 warning("unrecognized flag '-%c'", c
);
330 warning("ignoring excess arguments");
333 * We catch or block signals rather than ignore them,
334 * so that they get reset on exec.
336 handle(badsys
, SIGSYS
, 0);
337 handle(disaster
, SIGABRT
, SIGFPE
, SIGILL
, SIGSEGV
,
338 SIGBUS
, SIGXCPU
, SIGXFSZ
, 0);
339 handle(transition_handler
, SIGHUP
, SIGINT
, SIGTERM
, SIGTSTP
,
340 SIGUSR1
, SIGUSR2
, 0);
341 handle(alrm_handler
, SIGALRM
, 0);
343 delset(&mask
, SIGABRT
, SIGFPE
, SIGILL
, SIGSEGV
, SIGBUS
, SIGSYS
,
344 SIGXCPU
, SIGXFSZ
, SIGHUP
, SIGINT
, SIGTERM
, SIGTSTP
, SIGALRM
,
345 SIGUSR1
, SIGUSR2
, 0);
346 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
347 sigemptyset(&sa
.sa_mask
);
349 sa
.sa_handler
= SIG_IGN
;
350 sigaction(SIGTTIN
, &sa
, NULL
);
351 sigaction(SIGTTOU
, &sa
, NULL
);
361 * Start the state machine.
363 transition(requested_transition
);
366 * Should never reach here.
372 * Associate a function with a signal handler.
375 handle(sig_t handler
, ...)
379 sigset_t mask_everything
;
382 va_start(ap
, handler
);
384 sa
.sa_handler
= handler
;
385 sigfillset(&mask_everything
);
387 while ((sig
= va_arg(ap
, int)) != 0) {
388 sa
.sa_mask
= mask_everything
;
389 /* XXX SA_RESTART? */
390 sa
.sa_flags
= sig
== SIGCHLD
? SA_NOCLDSTOP
: 0;
391 sigaction(sig
, &sa
, NULL
);
397 * Delete a set of signals from a mask.
400 delset(sigset_t
*maskp
, ...)
407 while ((sig
= va_arg(ap
, int)) != 0)
408 sigdelset(maskp
, sig
);
413 * Log a message and sleep for a while (to give someone an opportunity
414 * to read it and to save log or hardcopy output if the problem is chronic).
415 * NB: should send a message to the session logger to avoid blocking.
418 stall(const char *message
, ...)
422 va_start(ap
, message
);
424 vsyslog(LOG_ALERT
, message
, ap
);
426 sleep(STALL_TIMEOUT
);
430 * Like stall(), but doesn't sleep.
431 * If cpp had variadic macros, the two functions could be #defines for another.
432 * NB: should send a message to the session logger to avoid blocking.
435 warning(const char *message
, ...)
439 va_start(ap
, message
);
441 vsyslog(LOG_ALERT
, message
, ap
);
446 * Log an emergency message.
447 * NB: should send a message to the session logger to avoid blocking.
450 emergency(const char *message
, ...)
454 va_start(ap
, message
);
456 vsyslog(LOG_EMERG
, message
, ap
);
461 * Catch a SIGSYS signal.
463 * These may arise if a system does not support sysctl.
464 * We tolerate up to 25 of these, then throw in the towel.
469 static int badcount
= 0;
477 * Catch an unexpected signal.
482 emergency("fatal signal: %s",
483 (unsigned)sig
< NSIG
? sys_siglist
[sig
] : "unknown signal");
485 sleep(STALL_TIMEOUT
);
486 _exit(sig
); /* reboot */
490 * Get the security level of the kernel.
493 getsecuritylevel(void)
495 #ifdef KERN_SECURELVL
496 int name
[2], curlevel
;
500 name
[1] = KERN_SECURELVL
;
501 len
= sizeof curlevel
;
502 if (sysctl(name
, 2, &curlevel
, &len
, NULL
, 0) == -1) {
503 emergency("cannot get kernel security level: %s",
514 * Get the value of the "init_chroot" variable from the
515 * kernel environment (or NULL if not set).
521 static const char ichname
[] = "init_chroot="; /* includes '=' */
522 const int ichlen
= strlen(ichname
);
523 int real_oid
[CTL_MAXNAME
];
529 oidlen
= NELEM(real_oid
);
530 if (sysctlnametomib("kern.environment", real_oid
, &oidlen
)) {
531 warning("cannot find kern.environment base sysctl OID");
534 if (oidlen
+ 1 >= NELEM(real_oid
)) {
535 warning("kern.environment OID is too large!");
539 real_oid
[oidlen
] = 0;
542 real_oid
[oidlen
+ 1] = i
;
544 if (sysctl(real_oid
, oidlen
+ 2, sbuf
, &slen
, NULL
, 0) < 0) {
546 warning("sysctl kern.environment.%d: %m", i
);
551 * slen includes the terminating \0, but do a few sanity
557 if (strncmp(sbuf
, ichname
, ichlen
) != 0)
560 res
= strdup(sbuf
+ ichlen
);
567 * Set the security level of the kernel.
570 setsecuritylevel(int newlevel
)
572 #ifdef KERN_SECURELVL
573 int name
[2], curlevel
;
575 curlevel
= getsecuritylevel();
576 if (newlevel
== curlevel
)
579 name
[1] = KERN_SECURELVL
;
580 if (sysctl(name
, 2, NULL
, NULL
, &newlevel
, sizeof newlevel
) == -1) {
582 "cannot change kernel security level from %d to %d: %s",
583 curlevel
, newlevel
, strerror(errno
));
587 warning("kernel security level changed from %d to %d",
594 * Change states in the finite state machine.
595 * The initial state is passed as an argument.
598 transition(state_t s
)
602 utmpx_set_runlevel(get_runlevel(current_state
),
606 s
= (*state_funcs
[s
])();
611 * Close out the accounting files for a login session.
612 * NB: should send a message to the session logger to avoid blocking.
615 clear_session_logs(session_t
*sp
)
617 char *line
= sp
->se_device
+ sizeof(_PATH_DEV
) - 1;
620 if (logoutx(line
, 0, DEAD_PROCESS
))
621 logwtmpx(line
, "", "", 0, DEAD_PROCESS
);
624 logwtmp(line
, "", "");
628 * Start a session and allocate a controlling terminal.
629 * Only called by children of init after forking.
632 setctty(const char *name
)
637 if ((fd
= open(name
, O_RDWR
)) == -1) {
638 stall("can't open %s: %m", name
);
641 if (login_tty(fd
) == -1) {
642 stall("can't get %s for controlling terminal: %m", name
);
648 * Bring the system up single user.
656 const char *shell
= _PATH_BSHELL
;
661 static const char banner
[] =
662 "Enter root password, or ^D to go multi-user\n";
663 char *clear
, *password
;
670 /* Instead of going single user, let's reboot the machine */
678 if ((pid
= fork()) == 0) {
680 * Start the single user session.
682 setctty(_PATH_CONSOLE
);
686 * Check the root password.
687 * We don't care if the console is 'on' by default;
688 * it's the only tty that can be 'off' and 'secure'.
690 typ
= getttynam("console");
691 pp
= getpwnam("root");
692 if (typ
&& (typ
->ty_status
& TTY_SECURE
) == 0 &&
693 pp
&& *pp
->pw_passwd
) {
694 write(2, banner
, sizeof banner
- 1);
696 clear
= getpass("Password:");
697 if (clear
== NULL
|| *clear
== '\0')
699 password
= crypt(clear
, pp
->pw_passwd
);
700 bzero(clear
, _PASSWORD_LEN
);
701 if (password
!= NULL
&& strcmp(password
, pp
->pw_passwd
) == 0)
703 warning("single-user login failed\n");
716 "Enter full pathname of shell or RETURN for " _PATH_BSHELL ": "
717 write(STDERR_FILENO
, SHREQUEST
, sizeof(SHREQUEST
) - 1);
718 while ((num
= read(STDIN_FILENO
, cp
, 1)) != -1 &&
719 num
!= 0 && *cp
!= '\n' && cp
< &altshell
[127])
722 if (altshell
[0] != '\0')
725 #endif /* DEBUGSHELL */
729 * We catch all the interesting ones,
730 * and those are reset to SIG_DFL on exec.
733 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
737 * If the default one doesn't work, try the Bourne shell.
741 execv(shell
, __DECONST(char **, argv
));
742 emergency("can't exec %s for single user: %m", shell
);
743 execv(_PATH_BSHELL
, __DECONST(char **, argv
));
744 emergency("can't exec %s for single user: %m", _PATH_BSHELL
);
745 sleep(STALL_TIMEOUT
);
751 * We are seriously hosed. Do our best.
753 emergency("can't fork single-user shell, trying again");
754 while (waitpid(-1, NULL
, WNOHANG
) > 0)
759 requested_transition
= 0;
761 if ((wpid
= waitpid(-1, &status
, WUNTRACED
)) != -1)
766 warning("wait for single-user shell failed: %m; restarting");
769 if (wpid
== pid
&& WIFSTOPPED(status
)) {
770 warning("init: shell stopped, restarting\n");
774 } while (wpid
!= pid
&& !requested_transition
);
776 if (requested_transition
)
777 return requested_transition
;
779 if (!WIFEXITED(status
)) {
780 if (WTERMSIG(status
) == SIGKILL
) {
782 * reboot(8) killed shell?
784 warning("single user shell terminated.");
785 sleep(STALL_TIMEOUT
);
788 warning("single user shell terminated, restarting");
793 runcom_mode
= FASTBOOT
;
798 * Run the system startup script.
808 if ((pid
= fork()) == 0) {
809 sigemptyset(&sa
.sa_mask
);
811 sa
.sa_handler
= SIG_IGN
;
812 sigaction(SIGTSTP
, &sa
, NULL
);
813 sigaction(SIGHUP
, &sa
, NULL
);
815 setctty(_PATH_CONSOLE
);
818 argv
[1] = _PATH_RUNCOM
;
819 argv
[2] = runcom_mode
== AUTOBOOT
? "autoboot" : 0;
822 sigprocmask(SIG_SETMASK
, &sa
.sa_mask
, NULL
);
825 setprocresources(RESOURCE_RC
);
827 execv(_PATH_BSHELL
, __DECONST(char **, argv
));
828 stall("can't exec %s for %s: %m", _PATH_BSHELL
, _PATH_RUNCOM
);
829 _exit(1); /* force single user mode */
833 emergency("can't fork for %s on %s: %m",
834 _PATH_BSHELL
, _PATH_RUNCOM
);
835 while (waitpid(-1, NULL
, WNOHANG
) > 0)
837 sleep(STALL_TIMEOUT
);
842 * Copied from single_user(). This is a bit paranoid.
844 requested_transition
= 0;
846 if ((wpid
= waitpid(-1, &status
, WUNTRACED
)) != -1)
849 if (requested_transition
== death
)
853 warning("wait for %s on %s failed: %m; going to single user mode",
854 _PATH_BSHELL
, _PATH_RUNCOM
);
857 if (wpid
== pid
&& WIFSTOPPED(status
)) {
858 warning("init: %s on %s stopped, restarting\n",
859 _PATH_BSHELL
, _PATH_RUNCOM
);
863 } while (wpid
!= pid
);
865 if (WIFSIGNALED(status
) && WTERMSIG(status
) == SIGTERM
&&
866 requested_transition
== catatonia
) {
867 /* /etc/rc executed /sbin/reboot; wait for the end quietly */
875 if (!WIFEXITED(status
)) {
876 warning("%s on %s terminated abnormally, going to single user mode",
877 _PATH_BSHELL
, _PATH_RUNCOM
);
881 if (WEXITSTATUS(status
))
884 runcom_mode
= AUTOBOOT
; /* the default */
885 /* NB: should send a message to the session logger to avoid blocking. */
887 logwtmpx("~", "reboot", "", 0, INIT_PROCESS
);
889 logwtmp("~", "reboot", "");
894 * Open the session database.
896 * NB: We could pass in the size here; is it necessary?
899 start_session_db(void)
901 if (session_db
&& (*session_db
->close
)(session_db
))
902 emergency("session database close: %s", strerror(errno
));
903 if ((session_db
= dbopen(NULL
, O_RDWR
, 0, DB_HASH
, NULL
)) == NULL
) {
904 emergency("session database open: %s", strerror(errno
));
912 * Add a new login session.
915 add_session(session_t
*sp
)
920 key
.data
= &sp
->se_process
;
921 key
.size
= sizeof sp
->se_process
;
923 data
.size
= sizeof sp
;
925 if ((*session_db
->put
)(session_db
, &key
, &data
, 0))
926 emergency("insert %d: %s", sp
->se_process
, strerror(errno
));
928 session_utmpx(sp
, 1);
933 * Delete an old login session.
936 del_session(session_t
*sp
)
940 key
.data
= &sp
->se_process
;
941 key
.size
= sizeof sp
->se_process
;
943 if ((*session_db
->del
)(session_db
, &key
, 0))
944 emergency("delete %d: %s", sp
->se_process
, strerror(errno
));
946 session_utmpx(sp
, 0);
951 * Look up a login session by pid.
954 find_session(pid_t pid
)
961 key
.size
= sizeof pid
;
962 if ((*session_db
->get
)(session_db
, &key
, &data
, 0) != 0)
964 bcopy(data
.data
, (char *)&ret
, sizeof(ret
));
969 * Construct an argument vector from a command line.
972 construct_argv(char *command
)
975 char **argv
= malloc(((strlen(command
) + 1) / 2 + 1)
978 if ((argv
[argc
++] = strk(command
)) == NULL
) {
982 while ((argv
[argc
++] = strk(NULL
)) != NULL
)
988 * Deallocate a session descriptor.
991 free_session(session_t
*sp
)
996 free(sp
->se_getty_argv_space
);
997 free(sp
->se_getty_argv
);
1000 free(sp
->se_window
);
1001 free(sp
->se_window_argv_space
);
1002 free(sp
->se_window_argv
);
1011 adjttyent(struct ttyent
*typ
)
1016 size_t rdev_size
= sizeof(rdev
);
1018 if (typ
->ty_name
== NULL
)
1022 * IFCONSOLE option forces tty off if not the console.
1024 if (typ
->ty_status
& TTY_IFCONSOLE
) {
1025 asprintf(&devpath
, "%s%s", _PATH_DEV
, typ
->ty_name
);
1026 if (stat(devpath
, &st
) < 0 ||
1027 sysctlbyname("kern.console_rdev",
1030 /* device does not exist or no sysctl, disable */
1031 typ
->ty_status
&= ~TTY_ON
;
1032 } else if (rdev
!= st
.st_rdev
) {
1033 typ
->ty_status
&= ~TTY_ON
;
1040 * Allocate a new session descriptor.
1041 * Mark it SE_PRESENT.
1044 new_session(session_t
*sprev
, int session_index
, struct ttyent
*typ
)
1049 if (typ
->ty_name
== NULL
|| typ
->ty_getty
== NULL
)
1052 if ((typ
->ty_status
& TTY_ON
) == 0)
1055 sp
= (session_t
*) calloc(1, sizeof (session_t
));
1057 asprintf(&sp
->se_device
, "%s%s", _PATH_DEV
, typ
->ty_name
);
1058 sp
->se_index
= session_index
;
1059 sp
->se_flags
|= SE_PRESENT
;
1062 * Attempt to open the device, if we get "device not configured"
1063 * then don't add the device to the session list.
1065 if ((fd
= open(sp
->se_device
, O_RDONLY
| O_NONBLOCK
, 0)) < 0) {
1066 if (errno
== ENXIO
) {
1073 if (setupargv(sp
, typ
) == 0) {
1079 if (sprev
== NULL
) {
1083 sprev
->se_next
= sp
;
1084 sp
->se_prev
= sprev
;
1091 * Calculate getty and if useful window argv vectors.
1094 setupargv(session_t
*sp
, struct ttyent
*typ
)
1099 free(sp
->se_getty_argv_space
);
1100 free(sp
->se_getty_argv
);
1102 sp
->se_getty
= malloc(strlen(typ
->ty_getty
) + strlen(typ
->ty_name
) + 2);
1103 sprintf(sp
->se_getty
, "%s %s", typ
->ty_getty
, typ
->ty_name
);
1104 sp
->se_getty_argv_space
= strdup(sp
->se_getty
);
1105 sp
->se_getty_argv
= construct_argv(sp
->se_getty_argv_space
);
1106 if (sp
->se_getty_argv
== NULL
) {
1107 warning("can't parse getty for port %s", sp
->se_device
);
1109 free(sp
->se_getty_argv_space
);
1110 sp
->se_getty
= sp
->se_getty_argv_space
= NULL
;
1113 if (sp
->se_window
) {
1114 free(sp
->se_window
);
1115 free(sp
->se_window_argv_space
);
1116 free(sp
->se_window_argv
);
1118 sp
->se_window
= sp
->se_window_argv_space
= NULL
;
1119 sp
->se_window_argv
= NULL
;
1120 if (typ
->ty_window
) {
1121 sp
->se_window
= strdup(typ
->ty_window
);
1122 sp
->se_window_argv_space
= strdup(sp
->se_window
);
1123 sp
->se_window_argv
= construct_argv(sp
->se_window_argv_space
);
1124 if (sp
->se_window_argv
== NULL
) {
1125 warning("can't parse window for port %s",
1127 free(sp
->se_window_argv_space
);
1128 free(sp
->se_window
);
1129 sp
->se_window
= sp
->se_window_argv_space
= NULL
;
1135 sp
->se_type
= typ
->ty_type
? strdup(typ
->ty_type
) : 0;
1140 * Walk the list of ttys and create sessions for each active line.
1145 int session_index
= 0;
1146 session_t
*sp
, *snext
;
1149 #ifdef SUPPORT_UTMPX
1150 if (sessions
== NULL
) {
1153 make_utmpx("", BOOT_MSG
, BOOT_TIME
, 0, &boot_time
, 0);
1156 * If wtmpx is not empty, pick the down time from there
1158 if (stat(_PATH_WTMPX
, &st
) != -1 && st
.st_size
!= 0) {
1159 struct timeval down_time
;
1161 TIMESPEC_TO_TIMEVAL(&down_time
,
1162 st
.st_atime
> st
.st_mtime
?
1163 &st
.st_atimespec
: &st
.st_mtimespec
);
1164 make_utmpx("", DOWN_MSG
, DOWN_TIME
, 0, &down_time
, 0);
1169 * Destroy any previous session state.
1170 * There shouldn't be any, but just in case...
1172 for (sp
= sessions
; sp
; sp
= snext
) {
1174 clear_session_logs(sp
);
1175 snext
= sp
->se_next
;
1179 if (start_session_db())
1183 * Allocate a session entry for each active port.
1184 * Note that sp starts at 0.
1186 while ((typ
= getttyent()) != NULL
) {
1188 if ((snext
= new_session(sp
, ++session_index
, typ
)) != NULL
)
1198 * Start a window system running.
1201 start_window_system(session_t
*sp
)
1205 char term
[64], *env
[2];
1207 if ((pid
= fork()) == -1) {
1208 emergency("can't fork for window system on port %s: %m",
1210 /* hope that getty fails and we can try again */
1218 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
1221 emergency("setsid failed (window) %m");
1224 setprocresources(RESOURCE_WINDOW
);
1227 /* Don't use malloc after fork */
1228 strcpy(term
, "TERM=");
1229 strncat(term
, sp
->se_type
, sizeof(term
) - 6);
1235 execve(sp
->se_window_argv
[0], sp
->se_window_argv
, env
);
1236 stall("can't exec window system '%s' for port %s: %m",
1237 sp
->se_window_argv
[0], sp
->se_device
);
1242 * Start a login session running.
1245 start_getty(session_t
*sp
)
1249 time_t current_time
= time(NULL
);
1251 char term
[64], *env
[2];
1253 if (current_time
>= sp
->se_started
.tv_sec
&&
1254 current_time
- sp
->se_started
.tv_sec
< GETTY_SPACING
) {
1255 if (++sp
->se_nspace
> GETTY_NSPACE
) {
1263 * fork(), not vfork() -- we can't afford to block.
1265 if ((pid
= fork()) == -1) {
1266 emergency("can't fork for getty on port %s: %m", sp
->se_device
);
1274 warning("getty repeating too quickly on port %s, sleeping %d secs",
1275 sp
->se_device
, GETTY_SLEEP
);
1276 sleep((unsigned) GETTY_SLEEP
);
1279 if (sp
->se_window
) {
1280 start_window_system(sp
);
1285 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
1288 setprocresources(RESOURCE_GETTY
);
1291 /* Don't use malloc after fork */
1292 strcpy(term
, "TERM=");
1293 strncat(term
, sp
->se_type
, sizeof(term
) - 6);
1299 execve(sp
->se_getty_argv
[0], sp
->se_getty_argv
, env
);
1300 stall("can't exec getty '%s' for port %s: %m",
1301 sp
->se_getty_argv
[0], sp
->se_device
);
1306 * Collect exit status for a child.
1307 * If an exiting login, start a new login running.
1310 collect_child(pid_t pid
)
1312 session_t
*sp
, *sprev
, *snext
;
1317 if (! (sp
= find_session(pid
)))
1320 clear_session_logs(sp
);
1324 if (sp
->se_flags
& SE_SHUTDOWN
) {
1325 if ((sprev
= sp
->se_prev
) != NULL
)
1326 sprev
->se_next
= sp
->se_next
;
1328 sessions
= sp
->se_next
;
1329 if ((snext
= sp
->se_next
) != NULL
)
1330 snext
->se_prev
= sp
->se_prev
;
1335 if ((pid
= start_getty(sp
)) == -1) {
1336 /* serious trouble */
1337 requested_transition
= clean_ttys
;
1341 sp
->se_process
= pid
;
1342 gettimeofday(&sp
->se_started
, NULL
);
1347 * Catch a signal and request a state transition.
1350 transition_handler(int sig
)
1355 requested_transition
= clean_ttys
;
1358 howto
= RB_POWEROFF
;
1367 requested_transition
= death
;
1370 requested_transition
= catatonia
;
1373 requested_transition
= 0;
1379 * Take the system multiuser.
1387 requested_transition
= 0;
1390 * If the administrator has not set the security level to -1
1391 * to indicate that the kernel should not run multiuser in secure
1392 * mode, and the run script has not set a higher level of security
1393 * than level 1, then put the kernel into secure mode.
1395 if (getsecuritylevel() == 0)
1396 setsecuritylevel(1);
1398 for (sp
= sessions
; sp
; sp
= sp
->se_next
) {
1401 if ((pid
= start_getty(sp
)) == -1) {
1402 /* serious trouble */
1403 requested_transition
= clean_ttys
;
1406 sp
->se_process
= pid
;
1407 gettimeofday(&sp
->se_started
, NULL
);
1411 while (!requested_transition
)
1412 if ((pid
= waitpid(-1, NULL
, 0)) != -1)
1415 return requested_transition
;
1419 * This is an (n*2)+(n^2) algorithm. We hope it isn't run often...
1424 session_t
*sp
, *sprev
;
1426 int session_index
= 0;
1428 char *old_getty
, *old_window
, *old_type
;
1434 * mark all sessions for death, (!SE_PRESENT)
1435 * as we find or create new ones they'll be marked as keepers,
1436 * we'll later nuke all the ones not found in /etc/ttys
1438 for (sp
= sessions
; sp
!= NULL
; sp
= sp
->se_next
)
1439 sp
->se_flags
&= ~SE_PRESENT
;
1441 devlen
= sizeof(_PATH_DEV
) - 1;
1442 while ((typ
= getttyent()) != NULL
) {
1446 for (sprev
= NULL
, sp
= sessions
; sp
; sprev
= sp
, sp
= sp
->se_next
)
1447 if (strcmp(typ
->ty_name
, sp
->se_device
+ devlen
) == 0)
1451 /* we want this one to live */
1452 sp
->se_flags
|= SE_PRESENT
;
1453 if (sp
->se_index
!= session_index
) {
1454 warning("port %s changed utmp index from %d to %d",
1455 sp
->se_device
, sp
->se_index
,
1457 sp
->se_index
= session_index
;
1459 if ((typ
->ty_status
& TTY_ON
) == 0 ||
1460 typ
->ty_getty
== 0) {
1461 sp
->se_flags
|= SE_SHUTDOWN
;
1462 kill(sp
->se_process
, SIGHUP
);
1465 sp
->se_flags
&= ~SE_SHUTDOWN
;
1466 old_getty
= sp
->se_getty
? strdup(sp
->se_getty
) : 0;
1467 old_window
= sp
->se_window
? strdup(sp
->se_window
) : 0;
1468 old_type
= sp
->se_type
? strdup(sp
->se_type
) : 0;
1469 if (setupargv(sp
, typ
) == 0) {
1470 warning("can't parse getty for port %s",
1472 sp
->se_flags
|= SE_SHUTDOWN
;
1473 kill(sp
->se_process
, SIGHUP
);
1475 else if ( !old_getty
1476 || (!old_type
&& sp
->se_type
)
1477 || (old_type
&& !sp
->se_type
)
1478 || (!old_window
&& sp
->se_window
)
1479 || (old_window
&& !sp
->se_window
)
1480 || (strcmp(old_getty
, sp
->se_getty
) != 0)
1481 || (old_window
&& strcmp(old_window
, sp
->se_window
) != 0)
1482 || (old_type
&& strcmp(old_type
, sp
->se_type
) != 0)
1484 /* Don't set SE_SHUTDOWN here */
1486 sp
->se_started
.tv_sec
= sp
->se_started
.tv_usec
= 0;
1487 kill(sp
->se_process
, SIGHUP
);
1498 new_session(sprev
, session_index
, typ
);
1504 * sweep through and kill all deleted sessions
1505 * ones who's /etc/ttys line was deleted (SE_PRESENT unset)
1507 for (sp
= sessions
; sp
!= NULL
; sp
= sp
->se_next
) {
1508 if ((sp
->se_flags
& SE_PRESENT
) == 0) {
1509 sp
->se_flags
|= SE_SHUTDOWN
;
1510 kill(sp
->se_process
, SIGHUP
);
1518 * Block further logins.
1525 for (sp
= sessions
; sp
; sp
= sp
->se_next
)
1526 sp
->se_flags
|= SE_SHUTDOWN
;
1535 alrm_handler(int sig __unused
)
1541 * Bring the system down to single user.
1549 static const int death_sigs
[2] = { SIGTERM
, SIGKILL
};
1551 /* NB: should send a message to the session logger to avoid blocking. */
1552 #ifdef SUPPORT_UTMPX
1553 logwtmpx("~", "shutdown", "", 0, INIT_PROCESS
);
1555 logwtmp("~", "shutdown", "");
1557 for (sp
= sessions
; sp
; sp
= sp
->se_next
) {
1558 sp
->se_flags
|= SE_SHUTDOWN
;
1559 kill(sp
->se_process
, SIGHUP
);
1562 /* Try to run the rc.shutdown script within a period of time */
1565 for (i
= 0; i
< 2; ++i
) {
1566 if (kill(-1, death_sigs
[i
]) == -1 && errno
== ESRCH
)
1572 if ((pid
= waitpid(-1, NULL
, 0)) != -1)
1574 while (clang
== 0 && errno
!= ECHILD
);
1576 if (errno
== ECHILD
)
1580 warning("some processes would not die; ps axl advised");
1586 * Run the system shutdown script.
1588 * Exit codes: XXX I should document more
1589 * -2 shutdown script terminated abnormally
1590 * -1 fatal error - can't run script
1592 * >0 some error (exit code)
1599 int shutdowntimeout
;
1601 const char *argv
[4];
1602 struct sigaction sa
;
1606 * rc.shutdown is optional, so to prevent any unnecessary
1607 * complaints from the shell we simply don't run it if the
1608 * file does not exist. If the stat() here fails for other
1609 * reasons, we'll let the shell complain.
1611 if (stat(_PATH_RUNDOWN
, &sb
) == -1 && errno
== ENOENT
)
1614 if ((pid
= fork()) == 0) {
1617 /* Assume that init already grab console as ctty before */
1619 sigemptyset(&sa
.sa_mask
);
1621 sa
.sa_handler
= SIG_IGN
;
1622 sigaction(SIGTSTP
, &sa
, NULL
);
1623 sigaction(SIGHUP
, &sa
, NULL
);
1625 if ((fd
= open(_PATH_CONSOLE
, O_RDWR
)) == -1)
1626 warning("can't open %s: %m", _PATH_CONSOLE
);
1636 * Run the shutdown script.
1639 argv
[1] = _PATH_RUNDOWN
;
1646 sigprocmask(SIG_SETMASK
, &sa
.sa_mask
, NULL
);
1649 setprocresources(RESOURCE_RC
);
1651 execv(_PATH_BSHELL
, __DECONST(char **, argv
));
1652 warning("can't exec %s for %s: %m", _PATH_BSHELL
, _PATH_RUNDOWN
);
1653 _exit(1); /* force single user mode */
1657 emergency("can't fork for %s on %s: %m",
1658 _PATH_BSHELL
, _PATH_RUNDOWN
);
1659 while (waitpid(-1, NULL
, WNOHANG
) > 0)
1661 sleep(STALL_TIMEOUT
);
1665 len
= sizeof(shutdowntimeout
);
1666 if (sysctlbyname("kern.init_shutdown_timeout",
1668 &len
, NULL
, 0) == -1 || shutdowntimeout
< 2)
1669 shutdowntimeout
= DEATH_SCRIPT
;
1670 alarm(shutdowntimeout
);
1673 * Copied from single_user(). This is a bit paranoid.
1674 * Use the same ALRM handler.
1677 if ((wpid
= waitpid(-1, &status
, WUNTRACED
)) != -1)
1678 collect_child(wpid
);
1680 /* we were waiting for the sub-shell */
1681 kill(wpid
, SIGTERM
);
1682 warning("timeout expired for %s on %s: %m; going to single user mode",
1683 _PATH_BSHELL
, _PATH_RUNDOWN
);
1689 warning("wait for %s on %s failed: %m; going to single user mode",
1690 _PATH_BSHELL
, _PATH_RUNDOWN
);
1693 if (wpid
== pid
&& WIFSTOPPED(status
)) {
1694 warning("init: %s on %s stopped, restarting\n",
1695 _PATH_BSHELL
, _PATH_RUNDOWN
);
1699 } while (wpid
!= pid
&& !clang
);
1701 /* Turn off the alarm */
1704 if (WIFSIGNALED(status
) && WTERMSIG(status
) == SIGTERM
&&
1705 requested_transition
== catatonia
) {
1707 * /etc/rc.shutdown executed /sbin/reboot;
1708 * wait for the end quietly
1717 if (!WIFEXITED(status
)) {
1718 warning("%s on %s terminated abnormally, going to single user mode",
1719 _PATH_BSHELL
, _PATH_RUNDOWN
);
1723 if ((status
= WEXITSTATUS(status
)) != 0)
1724 warning("%s returned status %d", _PATH_RUNDOWN
, status
);
1742 while (c
== ' ' || c
== '\t' )
1752 while (c
&& c
!= '\'')
1754 if (!c
) /* unterminated string */
1759 while (c
&& c
!= ' ' && c
!= '\t' )
1770 setprocresources(const char *cname
)
1773 if ((lc
= login_getclassbyname(cname
, NULL
)) != NULL
) {
1774 setusercontext(lc
, NULL
, 0, LOGIN_SETPRIORITY
|LOGIN_SETRESOURCES
);
1780 #ifdef SUPPORT_UTMPX
1782 session_utmpx(const session_t
*sp
, int add
)
1784 const char *name
= sp
->se_getty
? sp
->se_getty
:
1785 (sp
->se_window
? sp
->se_window
: "");
1786 const char *line
= sp
->se_device
+ sizeof(_PATH_DEV
) - 1;
1788 make_utmpx(name
, line
, add
? LOGIN_PROCESS
: DEAD_PROCESS
,
1789 sp
->se_process
, &sp
->se_started
, sp
->se_index
);
1793 make_utmpx(const char *name
, const char *line
, int type
, pid_t pid
,
1794 const struct timeval
*tv
, int session
)
1799 (void)memset(&ut
, 0, sizeof(ut
));
1800 (void)strlcpy(ut
.ut_name
, name
, sizeof(ut
.ut_name
));
1802 (void)strlcpy(ut
.ut_line
, line
, sizeof(ut
.ut_line
));
1807 (void)gettimeofday(&ut
.ut_tv
, NULL
);
1808 ut
.ut_session
= session
;
1810 eline
= line
+ strlen(line
);
1811 if ((size_t)(eline
- line
) >= sizeof(ut
.ut_id
))
1812 line
= eline
- sizeof(ut
.ut_id
);
1813 (void)strncpy(ut
.ut_id
, line
, sizeof(ut
.ut_id
));
1815 if (pututxline(&ut
) == NULL
)
1816 warning("can't add utmpx record for `%s': %m", ut
.ut_line
);
1821 get_runlevel(const state_t s
)
1823 if (s
== single_user
)
1829 if (s
== multi_user
)
1831 if (s
== clean_ttys
)
1839 utmpx_set_runlevel(char old
, char new)
1844 * Don't record any transitions until we did the first transition
1845 * to read ttys, which is when we are guaranteed to have a read-write
1846 * /var. Perhaps use a different variable for this?
1848 if (sessions
== NULL
)
1851 (void)memset(&ut
, 0, sizeof(ut
));
1852 (void)snprintf(ut
.ut_line
, sizeof(ut
.ut_line
), RUNLVL_MSG
, new);
1853 ut
.ut_type
= RUN_LVL
;
1854 (void)gettimeofday(&ut
.ut_tv
, NULL
);
1855 ut
.ut_exit
.e_exit
= old
;
1856 ut
.ut_exit
.e_termination
= new;
1857 if (pututxline(&ut
) == NULL
)
1858 warning("can't add utmpx record for `runlevel': %m");