]>
git.wh0rd.org - sysvinit.git/blob - src/init.c
2 * Init A System-V Init Clone.
5 * init [0123456SsQqAaBbCc]
6 * telinit [0123456SsQqAaBbCc]
8 * Version: @(#)init.c 2.86 30-Jul-2004 miquels@cistron.nl
10 #define VERSION "2.89"
11 #define DATE "26-Mar-2010"
13 * This file is part of the sysvinit suite,
14 * Copyright (C) 1991-2004 Miquel van Smoorenburg.
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include <sys/types.h>
34 #include <sys/ioctl.h>
39 #include <sys/resource.h>
52 #include <sys/syslog.h>
56 # include <selinux/selinux.h>
57 # include <sys/mount.h>
63 # define STACK_DEBUG 1
64 # if (__GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
65 /* Only glibc 2.0 needs this */
66 # include <sigcontext.h>
67 # elif ( __GLIBC__ > 2) && ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1))
68 # include <bits/sigcontext.h>
74 # include <security/pam_appl.h>
75 # include <security/pam_misc.h>
85 # define SIGPWR SIGUSR2
95 /* Set a signal handler. */
96 #define SETSIG(sa, sig, fun, flags) \
98 sa.sa_handler = fun; \
99 sa.sa_flags = flags; \
100 sigemptyset(&sa.sa_mask); \
101 sigaction(sig, &sa, NULL); \
104 /* Version information */
105 char *Version
= "@(#) init " VERSION
" " DATE
" miquels@cistron.nl";
106 char *bootmsg
= "version " VERSION
" %s";
107 #define E_VERSION "INIT_VERSION=sysvinit-" VERSION
109 CHILD
*family
= NULL
; /* The linked list of all entries */
110 CHILD
*newFamily
= NULL
; /* The list after inittab re-read */
112 CHILD ch_emerg
= { /* Emergency shell */
122 char runlevel
= 'S'; /* The current run level */
123 char thislevel
= 'S'; /* The current runlevel */
124 char prevlevel
= 'N'; /* Previous runlevel */
125 int dfl_level
= 0; /* Default runlevel */
126 sig_atomic_t got_cont
= 0; /* Set if we received the SIGCONT signal */
127 sig_atomic_t got_signals
; /* Set if we received a signal. */
128 int emerg_shell
= 0; /* Start emergency shell? */
129 int wrote_wtmp_reboot
= 1; /* Set when we wrote the reboot record */
130 int wrote_utmp_reboot
= 1; /* Set when we wrote the reboot record */
131 int wrote_wtmp_rlevel
= 1; /* Set when we wrote the runlevel record */
132 int wrote_utmp_rlevel
= 1; /* Set when we wrote the runlevel record */
133 int sltime
= 5; /* Sleep time between TERM and KILL */
134 char *argv0
; /* First arguments; show up in ps listing */
135 int maxproclen
; /* Maximal length of argv[0] with \0 */
136 struct utmp utproto
; /* Only used for sizeof(utproto.ut_id) */
137 char *console_dev
; /* Console device. */
138 int pipe_fd
= -1; /* /dev/initctl */
139 int did_boot
= 0; /* Did we already do BOOT* stuff? */
140 int main(int, char **);
142 /* Used by re-exec part */
143 int reload
= 0; /* Should we do initialization stuff? */
144 char *myname
="/sbin/init"; /* What should we exec */
145 int oops_error
; /* Used by some of the re-exec code. */
146 const char *Signature
= "12567362"; /* Signature for re-exec fd */
148 /* Macro to see if this is a special action */
149 #define ISPOWER(i) ((i) == POWERWAIT || (i) == POWERFAIL || \
150 (i) == POWEROKWAIT || (i) == POWERFAILNOW || \
153 /* ascii values for the `action' field. */
158 { "respawn", RESPAWN
},
162 { "bootwait", BOOTWAIT
},
163 { "powerfail", POWERFAIL
},
164 { "powerfailnow",POWERFAILNOW
},
165 { "powerwait", POWERWAIT
},
166 { "powerokwait", POWEROKWAIT
},
167 { "ctrlaltdel", CTRLALTDEL
},
169 { "ondemand", ONDEMAND
},
170 { "initdefault", INITDEFAULT
},
171 { "sysinit", SYSINIT
},
172 { "kbrequest", KBREQUEST
},
177 * State parser token table (see receive_state)
190 { "CMD", C_PROCESS
},
193 { "-RL", D_RUNLEVEL
},
194 { "-TL", D_THISLEVEL
},
195 { "-PL", D_PREVLEVEL
},
196 { "-SI", D_GOTSIGN
},
197 { "-WR", D_WROTE_WTMP_REBOOT
},
198 { "-WU", D_WROTE_UTMP_REBOOT
},
200 { "-DB", D_DIDBOOT
},
201 { "-LW", D_WROTE_WTMP_RLEVEL
},
202 { "-LU", D_WROTE_UTMP_RLEVEL
},
216 #define NR_EXTRA_ENV 16
217 char *extra_env
[NR_EXTRA_ENV
];
221 * Sleep a number of seconds.
223 * This only works correctly because the linux select updates
224 * the elapsed time in the struct timeval passed to select!
227 void do_sleep(int sec
)
234 while(select(0, NULL
, NULL
, NULL
, &tv
) < 0 && errno
== EINTR
)
240 * Non-failing allocation routines (init cannot fail).
243 void *imalloc(size_t size
)
247 while ((m
= malloc(size
)) == NULL
) {
248 initlog(L_VB
, "out of memory");
256 char *istrdup(char *s
)
269 * Send the state info of the previous running init to
270 * the new one, in a version-independant way.
273 void send_state(int fd
)
281 fprintf(fp
, "VER%s\n", Version
);
282 fprintf(fp
, "-RL%c\n", runlevel
);
283 fprintf(fp
, "-TL%c\n", thislevel
);
284 fprintf(fp
, "-PL%c\n", prevlevel
);
285 fprintf(fp
, "-SI%u\n", got_signals
);
286 fprintf(fp
, "-WR%d\n", wrote_wtmp_reboot
);
287 fprintf(fp
, "-WU%d\n", wrote_utmp_reboot
);
288 fprintf(fp
, "-ST%d\n", sltime
);
289 fprintf(fp
, "-DB%d\n", did_boot
);
291 for (p
= family
; p
; p
= p
->next
) {
292 fprintf(fp
, "REC%s\n", p
->id
);
293 fprintf(fp
, "LEV%s\n", p
->rlevel
);
294 for (i
= 0, val
= p
->flags
; flags
[i
].mask
; i
++)
295 if (val
& flags
[i
].mask
) {
296 val
&= ~flags
[i
].mask
;
297 fprintf(fp
, "FL %s\n",flags
[i
].name
);
299 fprintf(fp
, "PID%d\n",p
->pid
);
300 fprintf(fp
, "EXS%u\n",p
->exstat
);
301 for(i
= 0; actions
[i
].act
; i
++)
302 if (actions
[i
].act
== p
->action
) {
303 fprintf(fp
, "AC %s\n", actions
[i
].name
);
306 fprintf(fp
, "CMD%s\n", p
->process
);
307 fprintf(fp
, "EOR\n");
309 fprintf(fp
, "END\n");
314 * Read a string from a file descriptor.
315 * FIXME: why not use fgets() ?
317 static int get_string(char *p
, int size
, FILE *f
)
321 while ((c
= getc(f
)) != EOF
&& c
!= '\n') {
326 return (c
!= EOF
) && (size
> 0);
330 * Read trailing data from the state pipe until we see a newline.
332 static int get_void(FILE *f
)
336 while ((c
= getc(f
)) != EOF
&& c
!= '\n')
343 * Read the next "command" from the state pipe.
345 static int get_cmd(FILE *f
)
350 if (fread(cmd
, 1, sizeof(cmd
) - 1, f
) != sizeof(cmd
) - 1)
353 for(i
= 0; cmds
[i
].cmd
&& strcmp(cmds
[i
].name
, cmd
) != 0; i
++)
359 * Read a CHILD * from the state pipe.
361 static CHILD
*get_record(FILE *f
)
369 switch (cmd
= get_cmd(f
)) {
379 fscanf(f
, "%c\n", &runlevel
);
382 fscanf(f
, "%c\n", &thislevel
);
385 fscanf(f
, "%c\n", &prevlevel
);
388 fscanf(f
, "%u\n", &got_signals
);
390 case D_WROTE_WTMP_REBOOT
:
391 fscanf(f
, "%d\n", &wrote_wtmp_reboot
);
393 case D_WROTE_UTMP_REBOOT
:
394 fscanf(f
, "%d\n", &wrote_utmp_reboot
);
397 fscanf(f
, "%d\n", &sltime
);
400 fscanf(f
, "%d\n", &did_boot
);
402 case D_WROTE_WTMP_RLEVEL
:
403 fscanf(f
, "%d\n", &wrote_wtmp_rlevel
);
405 case D_WROTE_UTMP_RLEVEL
:
406 fscanf(f
, "%d\n", &wrote_utmp_rlevel
);
409 if (cmd
> 0 || cmd
== C_EOF
) {
414 } while (cmd
!= C_REC
);
416 p
= imalloc(sizeof(CHILD
));
417 get_string(p
->id
, sizeof(p
->id
), f
);
419 do switch(cmd
= get_cmd(f
)) {
425 fscanf(f
, "%d\n", &(p
->pid
));
428 fscanf(f
, "%u\n", &(p
->exstat
));
431 get_string(p
->rlevel
, sizeof(p
->rlevel
), f
);
434 get_string(p
->process
, sizeof(p
->process
), f
);
437 get_string(s
, sizeof(s
), f
);
438 for(i
= 0; flags
[i
].name
; i
++) {
439 if (strcmp(flags
[i
].name
,s
) == 0)
442 p
->flags
|= flags
[i
].mask
;
445 get_string(s
, sizeof(s
), f
);
446 for(i
= 0; actions
[i
].name
; i
++) {
447 if (strcmp(actions
[i
].name
, s
) == 0)
450 p
->action
= actions
[i
].act
? actions
[i
].act
: OFF
;
456 } while( cmd
!= C_EOR
);
462 * Read the complete state info from the state pipe.
463 * Returns 0 on success
466 int receive_state(int fd
)
469 char old_version
[256];
474 if (get_cmd(f
) != C_VER
)
476 get_string(old_version
, sizeof(old_version
), f
);
478 for (pp
= &family
; (*pp
= get_record(f
)) != NULL
; pp
= &((*pp
)->next
))
485 * Set the process title.
488 __attribute__ ((format (printf
, 1, 2)))
490 static int setproctitle(char *fmt
, ...)
499 len
= vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
502 if (maxproclen
> 1) {
503 memset(argv0
, 0, maxproclen
);
504 strncpy(argv0
, buf
, maxproclen
- 1);
511 * Set console_dev to a working console.
514 void console_init(void)
517 int tried_devcons
= 0;
518 int tried_vtmaster
= 0;
521 if ((s
= getenv("CONSOLE")) != NULL
)
524 console_dev
= CONSOLE
;
528 while ((fd
= open(console_dev
, O_RDONLY
|O_NONBLOCK
)) < 0) {
529 if (!tried_devcons
) {
531 console_dev
= CONSOLE
;
534 if (!tried_vtmaster
) {
536 console_dev
= VT_MASTER
;
542 console_dev
= "/dev/null";
549 * Open the console with retries.
552 int console_open(int mode
)
558 * Open device in nonblocking mode.
560 m
= mode
| O_NONBLOCK
;
563 * Retry the open five times.
565 for(f
= 0; f
< 5; f
++) {
566 if ((fd
= open(console_dev
, m
)) >= 0) break;
570 if (fd
< 0) return fd
;
573 * Set original flags.
576 fcntl(fd
, F_SETFL
, mode
);
581 * We got a signal (HUP PWR WINCH ALRM INT)
584 void signal_handler(int sig
)
586 ADDSET(got_signals
, sig
);
590 * SIGCHLD: one of our children has died.
594 void chld_handler(int sig
__attribute__((unused
)))
596 void chld_handler(int sig
)
601 int saved_errno
= errno
;
604 * Find out which process(es) this was (were)
606 while((pid
= waitpid(-1, &st
, WNOHANG
)) != 0) {
607 if (errno
== ECHILD
) break;
608 for( ch
= family
; ch
; ch
= ch
->next
)
609 if ( ch
->pid
== pid
&& (ch
->flags
& RUNNING
) ) {
611 "chld_handler: marked %d as zombie",
613 ADDSET(got_signals
, SIGCHLD
);
617 ch
->new->exstat
= st
;
618 ch
->new->flags
|= ZOMBIE
;
623 INITDBG(L_VB
, "chld_handler: unknown child %d exited.",
631 * Linux ignores all signals sent to init when the
632 * SIG_DFL handler is installed. Therefore we must catch SIGTSTP
633 * and SIGCONT, or else they won't work....
635 * The SIGCONT handler
639 void cont_handler(int sig
__attribute__((unused
)))
641 void cont_handler(int sig
)
648 * Fork and dump core in /.
653 static int dumped
= 0;
660 if (fork() != 0) return;
663 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
665 rlim
.rlim_cur
= RLIM_INFINITY
;
666 rlim
.rlim_max
= RLIM_INFINITY
;
667 setrlimit(RLIMIT_CORE
, &rlim
);
670 signal(SIGSEGV
, SIG_DFL
);
672 sigdelset(&mask
, SIGSEGV
);
673 sigprocmask(SIG_SETMASK
, &mask
, NULL
);
680 * OOPS: segmentation violation!
681 * If we have the info, print where it occured.
682 * Then sleep 30 seconds and try to continue.
685 #if defined(STACK_DEBUG) && defined(__linux__)
687 void segv_handler(int sig
__attribute__((unused
)), struct sigcontext ctx
)
689 void segv_handler(int sig
, struct sigcontext ctx
)
693 int saved_errno
= errno
;
695 if ((void *)ctx
.eip
>= (void *)do_sleep
&&
696 (void *)ctx
.eip
< (void *)main
)
698 initlog(L_VB
, "PANIC: segmentation violation at %p%s! "
699 "sleeping for 30 seconds.", (void *)ctx
.eip
, p
);
706 void segv_handler(int sig
__attribute__((unused
)))
708 void segv_handler(int sig
)
711 int saved_errno
= errno
;
714 "PANIC: segmentation violation! sleeping for 30 seconds.");
722 * The SIGSTOP & SIGTSTP handler
726 void stop_handler(int sig
__attribute__((unused
)))
728 void stop_handler(int sig
)
731 int saved_errno
= errno
;
734 while(!got_cont
) pause();
740 * Set terminal settings to reasonable defaults
743 void console_stty(void)
748 if ((fd
= console_open(O_RDWR
|O_NOCTTY
)) < 0) {
749 initlog(L_VB
, "can't open %s", console_dev
);
753 #ifdef __FreeBSD_kernel__
755 * The kernel of FreeBSD expects userland to set TERM. Usually, we want
756 * "cons25". Later, gettys might disagree on this (i.e. we're not using
757 * syscons) but some boot scripts, like /etc/init.d/xserver-xorg, still
758 * need a non-dumb terminal.
760 putenv ("TERM=cons25");
763 (void) tcgetattr(fd
, &tty
);
765 tty
.c_cflag
&= CBAUD
|CBAUDEX
|CSIZE
|CSTOPB
|PARENB
|PARODD
;
766 tty
.c_cflag
|= HUPCL
|CLOCAL
|CREAD
;
768 tty
.c_cc
[VINTR
] = CINTR
;
769 tty
.c_cc
[VQUIT
] = CQUIT
;
770 tty
.c_cc
[VERASE
] = CERASE
; /* ASCII DEL (0177) */
771 tty
.c_cc
[VKILL
] = CKILL
;
772 tty
.c_cc
[VEOF
] = CEOF
;
775 tty
.c_cc
[VSWTC
] = _POSIX_VDISABLE
;
776 tty
.c_cc
[VSTART
] = CSTART
;
777 tty
.c_cc
[VSTOP
] = CSTOP
;
778 tty
.c_cc
[VSUSP
] = CSUSP
;
779 tty
.c_cc
[VEOL
] = _POSIX_VDISABLE
;
780 tty
.c_cc
[VREPRINT
] = CREPRINT
;
781 tty
.c_cc
[VDISCARD
] = CDISCARD
;
782 tty
.c_cc
[VWERASE
] = CWERASE
;
783 tty
.c_cc
[VLNEXT
] = CLNEXT
;
784 tty
.c_cc
[VEOL2
] = _POSIX_VDISABLE
;
787 * Set pre and post processing
789 tty
.c_iflag
= IGNPAR
|ICRNL
|IXON
|IXANY
;
790 #ifdef IUTF8 /* Not defined on FreeBSD */
791 tty
.c_iflag
|= IUTF8
;
793 tty
.c_oflag
= OPOST
|ONLCR
;
794 tty
.c_lflag
= ISIG
|ICANON
|ECHO
|ECHOCTL
|ECHOPRT
|ECHOKE
;
796 #if defined(SANE_TIO) && (SANE_TIO == 1)
798 * Disable flow control (-ixon), ignore break (ignbrk),
799 * and make nl/cr more usable (sane).
801 tty
.c_iflag
|= IGNBRK
;
802 tty
.c_iflag
&= ~(BRKINT
|INLCR
|IGNCR
|IXON
);
803 tty
.c_oflag
&= ~(OCRNL
|ONLRET
);
806 * Now set the terminal line.
807 * We don't care about non-transmitted output data
808 * and non-read input data.
810 (void) tcsetattr(fd
, TCSANOW
, &tty
);
811 (void) tcflush(fd
, TCIOFLUSH
);
816 * Print to the system console
822 if ((fd
= console_open(O_WRONLY
|O_NOCTTY
|O_NDELAY
)) >= 0) {
823 write(fd
, s
, strlen(s
));
829 * Log something to a logfile and the console.
832 __attribute__ ((format (printf
, 2, 3)))
834 void initlog(int loglevel
, char *s
, ...)
838 sigset_t nmask
, omask
;
840 va_start(va_alist
, s
);
841 vsnprintf(buf
, sizeof(buf
), s
, va_alist
);
844 if (loglevel
& L_SY
) {
846 * Re-establish connection with syslogd every time.
847 * Block signals while talking to syslog.
850 sigprocmask(SIG_BLOCK
, &nmask
, &omask
);
851 openlog("init", 0, LOG_DAEMON
);
852 syslog(LOG_INFO
, "%s", buf
);
854 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
858 * And log to the console.
860 if (loglevel
& L_CO
) {
869 static pam_handle_t
*pamh
= NULL
;
872 init_conv(int num_msg
, const struct pam_message
**msgm
,
873 struct pam_response
**response
__attribute__((unused
)),
874 void *appdata_ptr
__attribute__((unused
)))
877 init_conv(int num_msg
, const struct pam_message
**msgm
,
878 struct pam_response
**response
, void *appdata_ptr
)
882 for (i
= 0; i
< num_msg
; i
++) {
883 const struct pam_message
*msg
= msgm
[i
];
884 if (msg
== (const struct pam_message
*)0)
886 if (msg
->msg
== (char*)0)
888 switch (msg
->msg_style
) {
891 initlog(L_VB
, "pam_message %s", msg
->msg
);
898 static const struct pam_conv conv
= { init_conv
, NULL
};
899 # define PAM_FAIL_CHECK(func, args...) \
901 if ((pam_ret = (func)(args)) != PAM_SUCCESS) { \
902 initlog(L_VB, "%s", pam_strerror(pamh, pam_ret)); \
910 * Build a new environment for execve().
912 char **init_buildenv(int child
)
914 char i_lvl
[] = "RUNLEVEL=x";
915 char i_prev
[] = "PREVLEVEL=x";
917 char i_shell
[] = "SHELL=" SHELL
;
920 char **pamenv
= (char**)0;
924 for (n
= 0; environ
[n
]; n
++)
929 pamenv
= pam_getenvlist(pamh
);
930 for (i
= 0; pamenv
[i
]; i
++)
936 e
= calloc(n
, sizeof(char *));
938 for (n
= 0; environ
[n
]; n
++)
939 e
[n
] = istrdup(environ
[n
]);
941 for (i
= 0; i
< NR_EXTRA_ENV
; i
++) {
943 e
[n
++] = istrdup(extra_env
[i
]);
948 for (i
= 0; pamenv
[i
]; i
++)
949 e
[n
++] = istrdup(pamenv
[i
]);
951 snprintf(i_cons
, sizeof(i_cons
), "CONSOLE=%s", console_dev
);
952 i_lvl
[9] = thislevel
;
953 i_prev
[10] = prevlevel
;
954 e
[n
++] = istrdup(i_shell
);
955 e
[n
++] = istrdup(i_lvl
);
956 e
[n
++] = istrdup(i_prev
);
957 e
[n
++] = istrdup(i_cons
);
958 e
[n
++] = istrdup(E_VERSION
);
967 void init_freeenv(char **e
)
971 for (n
= 0; e
[n
]; n
++)
980 * This function is too long and indents too deep.
984 pid_t
spawn(CHILD
*ch
, int *res
)
986 char *args
[16]; /* Argv array */
987 char buf
[136]; /* Line buffer */
988 int f
, st
; /* Scratch variables */
989 char *ptr
; /* Ditto */
990 time_t t
; /* System time */
991 int oldAlarm
; /* Previous alarm value */
992 char *proc
= ch
->process
; /* Command line */
993 pid_t pid
, pgrp
; /* child, console process group. */
994 sigset_t nmask
, omask
; /* For blocking SIGCHLD */
998 buf
[sizeof(buf
) - 1] = 0;
1000 /* Skip '+' if it's there */
1001 if (proc
[0] == '+') proc
++;
1003 ch
->flags
|= XECUTED
;
1005 if (ch
->action
== RESPAWN
|| ch
->action
== ONDEMAND
) {
1006 /* Is the date stamp from less than 2 minutes ago? */
1008 if (ch
->tm
+ TESTTIME
> t
) {
1015 /* Do we try to respawn too fast? */
1016 if (ch
->count
>= MAXSPAWN
) {
1019 "Id \"%s\" respawning too fast: disabled for %d minutes",
1020 ch
->id
, SLEEPTIME
/ 60);
1021 ch
->flags
&= ~RUNNING
;
1022 ch
->flags
|= FAILING
;
1024 /* Remember the time we stopped */
1027 /* Try again in 5 minutes */
1028 oldAlarm
= alarm(0);
1029 if (oldAlarm
> SLEEPTIME
|| oldAlarm
<= 0) oldAlarm
= SLEEPTIME
;
1035 /* See if there is an "initscript" (except in single user mode). */
1036 if (access(INITSCRIPT
, R_OK
) == 0 && runlevel
!= 'S') {
1037 /* Build command line using "initscript" */
1039 args
[2] = INITSCRIPT
;
1041 args
[4] = ch
->rlevel
;
1042 args
[5] = "unknown";
1043 for(f
= 0; actions
[f
].name
; f
++) {
1044 if (ch
->action
== actions
[f
].act
) {
1045 args
[5] = actions
[f
].name
;
1051 } else if (strpbrk(proc
, "~`!$^&*()=|\\{}[];\"'<>?")) {
1052 /* See if we need to fire off a shell for this command */
1053 /* Give command line to shell */
1056 strcpy(buf
, "exec ");
1057 strncat(buf
, proc
, sizeof(buf
) - strlen(buf
) - 1);
1061 /* Split up command line arguments */
1063 strncat(buf
, proc
, sizeof(buf
) - 1);
1065 for(f
= 1; f
< 15; f
++) {
1066 /* Skip white space */
1067 while(*ptr
== ' ' || *ptr
== '\t') ptr
++;
1070 /* May be trailing space.. */
1071 if (*ptr
== 0) break;
1073 /* Skip this `word' */
1074 while(*ptr
&& *ptr
!= ' ' && *ptr
!= '\t' && *ptr
!= '#')
1077 /* If end-of-line, break */
1078 if (*ptr
== '#' || *ptr
== 0) {
1083 /* End word with \0 and continue */
1091 * Block sigchild while forking.
1093 sigemptyset(&nmask
);
1094 sigaddset(&nmask
, SIGCHLD
);
1095 sigprocmask(SIG_BLOCK
, &nmask
, &omask
);
1097 if ((pid
= fork()) == 0) {
1104 if (pipe_fd
>= 0) close(pipe_fd
);
1106 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
1109 * In sysinit, boot, bootwait or single user mode:
1110 * for any wait-type subprocess we _force_ the console
1111 * to be its controlling tty.
1113 if (strchr("*#sS", runlevel
) && ch
->flags
& WAITING
) {
1115 * We fork once extra. This is so that we can
1116 * wait and change the process group and session
1117 * of the console after exit of the leader.
1120 if ((f
= console_open(O_RDWR
|O_NOCTTY
)) >= 0) {
1121 /* Take over controlling tty by force */
1122 (void)ioctl(f
, TIOCSCTTY
, 1);
1128 * 4 Sep 2001, Andrea Arcangeli:
1129 * Fix a race in spawn() that is used to deadlock init in a
1130 * waitpid() loop: must set the childhandler as default before forking
1131 * off the child or the chld_handler could run before the waitpid loop
1132 * has a chance to find its zombie-child.
1134 SETSIG(sa
, SIGCHLD
, SIG_DFL
, SA_RESTART
);
1135 if ((pid
= fork()) < 0) {
1136 initlog(L_VB
, "cannot fork: %s",
1143 * Ignore keyboard signals etc.
1144 * Then wait for child to exit.
1146 SETSIG(sa
, SIGINT
, SIG_IGN
, SA_RESTART
);
1147 SETSIG(sa
, SIGTSTP
, SIG_IGN
, SA_RESTART
);
1148 SETSIG(sa
, SIGQUIT
, SIG_IGN
, SA_RESTART
);
1150 while ((rc
= waitpid(pid
, &st
, 0)) != pid
)
1151 if (rc
< 0 && errno
== ECHILD
)
1155 * Small optimization. See if stealing
1156 * controlling tty back is needed.
1158 pgrp
= tcgetpgrp(f
);
1159 if (pgrp
!= getpid())
1163 * Steal controlling tty away. We do
1164 * this with a temporary process.
1166 if ((pid
= fork()) < 0) {
1167 initlog(L_VB
, "cannot fork: %s",
1173 (void)ioctl(f
, TIOCSCTTY
, 1);
1176 while((rc
= waitpid(pid
, &st
, 0)) != pid
)
1177 if (rc
< 0 && errno
== ECHILD
)
1182 /* Set ioctl settings to default ones */
1187 if ((f
= console_open(O_RDWR
|O_NOCTTY
)) < 0) {
1188 initlog(L_VB
, "open(%s): %s", console_dev
,
1190 f
= open("/dev/null", O_RDWR
);
1197 PAM_FAIL_CHECK(pam_start
, "init", "root" , &conv
, &pamh
);
1198 PAM_FAIL_CHECK(pam_set_item
, pamh
, PAM_TTY
, console_dev
);
1199 PAM_FAIL_CHECK(pam_acct_mgmt
, pamh
, PAM_SILENT
);
1200 PAM_FAIL_CHECK(pam_open_session
, pamh
, PAM_SILENT
);
1201 PAM_FAIL_CHECK(pam_setcred
, pamh
, PAM_ESTABLISH_CRED
|PAM_SILENT
);
1204 * Update utmp/wtmp file prior to starting
1205 * any child. This MUST be done right here in
1206 * the child process in order to prevent a race
1207 * condition that occurs when the child
1208 * process' time slice executes before the
1209 * parent (can and does happen in a uniprocessor
1210 * environment). If the child is a getty and
1211 * the race condition happens, then init's utmp
1212 * update will happen AFTER the getty runs
1213 * and expects utmp to be updated already!
1215 * Do NOT log if process field starts with '+'
1216 * FIXME: that's for compatibility with *very*
1217 * old getties - probably it can be taken out.
1219 if (ch
->process
[0] != '+')
1220 write_utmp_wtmp("", ch
->id
, getpid(), INIT_PROCESS
, "");
1222 /* Reset all the signals, set up environment */
1223 for(f
= 1; f
< NSIG
; f
++) SETSIG(sa
, f
, SIG_DFL
, SA_RESTART
);
1224 environ
= init_buildenv(1);
1227 * Execute prog. In case of ENOEXEC try again
1228 * as a shell script.
1230 execvp(args
[1], args
+ 1);
1231 if (errno
== ENOEXEC
) {
1234 strcpy(buf
, "exec ");
1235 strncat(buf
, proc
, sizeof(buf
) - strlen(buf
) - 1);
1238 execvp(args
[1], args
+ 1);
1240 initlog(L_VB
, "cannot execute \"%s\"", args
[1]);
1242 if (ch
->process
[0] != '+')
1243 write_utmp_wtmp("", ch
->id
, getpid(), DEAD_PROCESS
, NULL
);
1245 (void)pam_setcred(pamh
, PAM_DELETE_CRED
|PAM_SILENT
);
1246 pam_ret
= pam_close_session(pamh
, PAM_SILENT
);
1248 pam_end(pamh
, pam_ret
);
1253 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
1255 INITDBG(L_VB
, "Started id %s (pid %d)", ch
->id
, pid
);
1258 initlog(L_VB
, "cannot fork, retry..");
1267 * Start a child running!
1270 void startup(CHILD
*ch
)
1273 * See if it's disabled
1275 if (ch
->flags
& FAILING
) return;
1277 switch(ch
->action
) {
1286 if (!(ch
->flags
& XECUTED
)) ch
->flags
|= WAITING
;
1291 if (ch
->flags
& XECUTED
) break;
1294 ch
->flags
|= RUNNING
;
1295 (void)spawn(ch
, &(ch
->pid
));
1302 * Read the inittab file.
1305 void read_inittab(void)
1307 FILE *fp
; /* The INITTAB file */
1308 CHILD
*ch
, *old
, *i
; /* Pointers to CHILD structure */
1309 CHILD
*head
= NULL
; /* Head of linked list */
1311 struct stat st
; /* To stat INITLVL */
1313 sigset_t nmask
, omask
; /* For blocking SIGCHLD. */
1314 char buf
[256]; /* Line buffer */
1315 char err
[64]; /* Error message. */
1317 *action
, *process
; /* Fields of a line */
1319 int lineNo
= 0; /* Line number in INITTAB file */
1320 int actionNo
; /* Decoded action field */
1321 int f
; /* Counter */
1322 int round
; /* round 0 for SIGTERM, 1 for SIGKILL */
1323 int foundOne
= 0; /* No killing no sleep */
1324 int talk
; /* Talk to the user */
1325 int done
= 0; /* Ready yet? */
1328 if (newFamily
!= NULL
) {
1329 INITDBG(L_VB
, "PANIC newFamily != NULL");
1332 INITDBG(L_VB
, "Reading inittab");
1336 * Open INITTAB and real line by line.
1338 if ((fp
= fopen(INITTAB
, "r")) == NULL
)
1339 initlog(L_VB
, "No inittab file found");
1343 * Add single user shell entry at the end.
1345 if (fp
== NULL
|| fgets(buf
, sizeof(buf
), fp
) == NULL
) {
1348 * See if we have a single user entry.
1350 for(old
= newFamily
; old
; old
= old
->next
)
1351 if (strpbrk(old
->rlevel
, "S")) break;
1353 snprintf(buf
, sizeof(buf
), "~~:S:wait:%s\n", SULOGIN
);
1359 * Skip comments and empty lines
1361 for(p
= buf
; *p
== ' ' || *p
== '\t'; p
++)
1363 if (*p
== '#' || *p
== '\n') continue;
1368 id
= strsep(&p
, ":");
1369 rlevel
= strsep(&p
, ":");
1370 action
= strsep(&p
, ":");
1371 process
= strsep(&p
, "\n");
1374 * Check if syntax is OK. Be very verbose here, to
1375 * avoid newbie postings on comp.os.linux.setup :)
1378 if (!id
|| !*id
) strcpy(err
, "missing id field");
1379 if (!rlevel
) strcpy(err
, "missing runlevel field");
1380 if (!process
) strcpy(err
, "missing process field");
1381 if (!action
|| !*action
)
1382 strcpy(err
, "missing action field");
1383 if (id
&& strlen(id
) > sizeof(utproto
.ut_id
))
1384 sprintf(err
, "id field too long (max %d characters)",
1385 (int)sizeof(utproto
.ut_id
));
1386 if (rlevel
&& strlen(rlevel
) > 11)
1387 strcpy(err
, "rlevel field too long (max 11 characters)");
1388 if (process
&& strlen(process
) > 127)
1389 strcpy(err
, "process field too long");
1390 if (action
&& strlen(action
) > 32)
1391 strcpy(err
, "action field too long");
1393 initlog(L_VB
, "%s[%d]: %s", INITTAB
, lineNo
, err
);
1394 INITDBG(L_VB
, "%s:%s:%s:%s", id
, rlevel
, action
, process
);
1399 * Decode the "action" field
1402 for(f
= 0; actions
[f
].name
; f
++)
1403 if (strcasecmp(action
, actions
[f
].name
) == 0) {
1404 actionNo
= actions
[f
].act
;
1407 if (actionNo
== -1) {
1408 initlog(L_VB
, "%s[%d]: %s: unknown action field",
1409 INITTAB
, lineNo
, action
);
1414 * See if the id field is unique
1416 for(old
= newFamily
; old
; old
= old
->next
) {
1417 if(strcmp(old
->id
, id
) == 0 && strcmp(id
, "~~")) {
1418 initlog(L_VB
, "%s[%d]: duplicate ID field \"%s\"",
1419 INITTAB
, lineNo
, id
);
1426 * Allocate a CHILD structure
1428 ch
= imalloc(sizeof(CHILD
));
1433 ch
->action
= actionNo
;
1434 strncpy(ch
->id
, id
, sizeof(utproto
.ut_id
) + 1); /* Hack for different libs. */
1435 strncpy(ch
->process
, process
, sizeof(ch
->process
) - 1);
1437 for(f
= 0; f
< (int)sizeof(rlevel
) - 1 && rlevel
[f
]; f
++) {
1438 ch
->rlevel
[f
] = rlevel
[f
];
1439 if (ch
->rlevel
[f
] == 's') ch
->rlevel
[f
] = 'S';
1441 strncpy(ch
->rlevel
, rlevel
, sizeof(ch
->rlevel
) - 1);
1443 strcpy(ch
->rlevel
, "0123456789");
1444 if (ISPOWER(ch
->action
))
1445 strcpy(ch
->rlevel
, "S0123456789");
1448 * We have the fake runlevel '#' for SYSINIT and
1449 * '*' for BOOT and BOOTWAIT.
1451 if (ch
->action
== SYSINIT
) strcpy(ch
->rlevel
, "#");
1452 if (ch
->action
== BOOT
|| ch
->action
== BOOTWAIT
)
1453 strcpy(ch
->rlevel
, "*");
1456 * Now add it to the linked list. Special for powerfail.
1458 if (ISPOWER(ch
->action
)) {
1461 * Disable by default
1463 ch
->flags
|= XECUTED
;
1466 * Tricky: insert at the front of the list..
1469 for(i
= newFamily
; i
; i
= i
->next
) {
1470 if (!ISPOWER(i
->action
)) break;
1474 * Now add after entry "old"
1479 if (i
== NULL
) head
= ch
;
1481 ch
->next
= newFamily
;
1483 if (ch
->next
== NULL
) head
= ch
;
1487 * Just add at end of the list
1489 if (ch
->action
== KBREQUEST
) ch
->flags
|= XECUTED
;
1499 * Walk through the old list comparing id fields
1501 for(old
= family
; old
; old
= old
->next
)
1502 if (strcmp(old
->id
, ch
->id
) == 0) {
1513 * Loop through the list of children, and see if they need to
1517 INITDBG(L_VB
, "Checking for children to kill");
1518 for(round
= 0; round
< 2; round
++) {
1520 for(ch
= family
; ch
; ch
= ch
->next
) {
1521 ch
->flags
&= ~KILLME
;
1524 * Is this line deleted?
1526 if (ch
->new == NULL
) ch
->flags
|= KILLME
;
1529 * If the entry has changed, kill it anyway. Note that
1530 * we do not check ch->process, only the "action" field.
1531 * This way, you can turn an entry "off" immediately, but
1532 * changes in the command line will only become effective
1533 * after the running version has exited.
1535 if (ch
->new && ch
->action
!= ch
->new->action
) ch
->flags
|= KILLME
;
1538 * Only BOOT processes may live in all levels
1540 if (ch
->action
!= BOOT
&&
1541 strchr(ch
->rlevel
, runlevel
) == NULL
) {
1543 * Ondemand procedures live always,
1544 * except in single user
1546 if (runlevel
== 'S' || !(ch
->flags
& DEMAND
))
1547 ch
->flags
|= KILLME
;
1551 * Now, if this process may live note so in the new list
1553 if ((ch
->flags
& KILLME
) == 0) {
1554 ch
->new->flags
= ch
->flags
;
1555 ch
->new->pid
= ch
->pid
;
1556 ch
->new->exstat
= ch
->exstat
;
1562 * Is this process still around?
1564 if ((ch
->flags
& RUNNING
) == 0) {
1565 ch
->flags
&= ~KILLME
;
1568 INITDBG(L_VB
, "Killing \"%s\"", ch
->process
);
1570 case 0: /* Send TERM signal */
1573 "Sending processes the TERM signal");
1574 kill(-(ch
->pid
), SIGTERM
);
1577 case 1: /* Send KILL signal and collect status */
1580 "Sending processes the KILL signal");
1581 kill(-(ch
->pid
), SIGKILL
);
1588 * See if we have to wait 5 seconds
1590 if (foundOne
&& round
== 0) {
1592 * Yup, but check every second if we still have children.
1594 for(f
= 0; f
< sltime
; f
++) {
1595 for(ch
= family
; ch
; ch
= ch
->next
) {
1596 if (!(ch
->flags
& KILLME
)) continue;
1597 if ((ch
->flags
& RUNNING
) && !(ch
->flags
& ZOMBIE
))
1602 * No running children, skip SIGKILL
1605 foundOne
= 0; /* Skip the sleep below. */
1614 * Now give all processes the chance to die and collect exit statuses.
1616 if (foundOne
) do_sleep(1);
1617 for(ch
= family
; ch
; ch
= ch
->next
)
1618 if (ch
->flags
& KILLME
) {
1619 if (!(ch
->flags
& ZOMBIE
))
1620 initlog(L_CO
, "Pid %d [id %s] seems to hang", ch
->pid
,
1623 INITDBG(L_VB
, "Updating utmp for pid %d [id %s]",
1625 ch
->flags
&= ~RUNNING
;
1626 if (ch
->process
[0] != '+')
1627 write_utmp_wtmp("", ch
->id
, ch
->pid
, DEAD_PROCESS
, NULL
);
1632 * Both rounds done; clean up the list.
1634 sigemptyset(&nmask
);
1635 sigaddset(&nmask
, SIGCHLD
);
1636 sigprocmask(SIG_BLOCK
, &nmask
, &omask
);
1637 for(ch
= family
; ch
; ch
= old
) {
1642 for(ch
= family
; ch
; ch
= ch
->next
) ch
->new = NULL
;
1644 sigprocmask(SIG_SETMASK
, &omask
, NULL
);
1648 * Dispose of INITLVL file.
1650 if (lstat(INITLVL
, &st
) >= 0 && S_ISLNK(st
.st_mode
)) {
1652 * INITLVL is a symbolic link, so just truncate the file.
1654 close(open(INITLVL
, O_WRONLY
|O_TRUNC
));
1657 * Delete INITLVL file.
1664 * Dispose of INITLVL2 file.
1666 if (lstat(INITLVL2
, &st
) >= 0 && S_ISLNK(st
.st_mode
)) {
1668 * INITLVL2 is a symbolic link, so just truncate the file.
1670 close(open(INITLVL2
, O_WRONLY
|O_TRUNC
));
1673 * Delete INITLVL2 file.
1681 * Walk through the family list and start up children.
1682 * The entries that do not belong here at all are removed
1686 void start_if_needed(void)
1688 CHILD
*ch
; /* Pointer to child */
1689 int delete; /* Delete this entry from list? */
1691 INITDBG(L_VB
, "Checking for children to start");
1693 for(ch
= family
; ch
; ch
= ch
->next
) {
1696 if (ch
->rlevel
[0] == 'C') {
1697 INITDBG(L_VB
, "%s: flags %d", ch
->process
, ch
->flags
);
1701 /* Are we waiting for this process? Then quit here. */
1702 if (ch
->flags
& WAITING
) break;
1704 /* Already running? OK, don't touch it */
1705 if (ch
->flags
& RUNNING
) continue;
1707 /* See if we have to start it up */
1709 if (strchr(ch
->rlevel
, runlevel
) ||
1710 ((ch
->flags
& DEMAND
) && !strchr("#*Ss", runlevel
))) {
1716 /* FIXME: is this OK? */
1717 ch
->flags
&= ~(RUNNING
|WAITING
);
1718 if (!ISPOWER(ch
->action
) && ch
->action
!= KBREQUEST
)
1719 ch
->flags
&= ~XECUTED
;
1722 /* Do we have to wait for this process? */
1723 if (ch
->flags
& WAITING
) break;
1729 * Ask the user on the console for a runlevel
1732 int ask_runlevel(void)
1734 const char prompt
[] = "\nEnter runlevel: ";
1740 fd
= console_open(O_RDWR
|O_NOCTTY
);
1742 if (fd
< 0) return('S');
1744 while(!strchr("0123456789S", lvl
)) {
1745 write(fd
, prompt
, sizeof(prompt
) - 1);
1747 read(fd
, buf
, sizeof(buf
));
1748 if (buf
[0] != 0 && (buf
[1] == '\r' || buf
[1] == '\n'))
1750 if (islower(lvl
)) lvl
= toupper(lvl
);
1757 * Search the INITTAB file for the 'initdefault' field, with the default
1758 * runlevel. If this fails, ask the user to supply a runlevel.
1761 int get_init_default(void)
1768 * Look for initdefault.
1770 for(ch
= family
; ch
; ch
= ch
->next
)
1771 if (ch
->action
== INITDEFAULT
) {
1774 if (*p
> lvl
) lvl
= *p
;
1780 * See if level is valid
1783 if (islower(lvl
)) lvl
= toupper(lvl
);
1784 if (strchr("0123456789S", lvl
) == NULL
) {
1786 "Initdefault level '%c' is invalid", lvl
);
1791 * Ask for runlevel on console if needed.
1793 if (lvl
<= 0) lvl
= ask_runlevel();
1796 * Log the fact that we have a runlevel now.
1805 * Do actions for the new level. If we are compatible with
1806 * the "old" INITLVL and arg == 0, try to read the new
1807 * runlevel from that file first.
1810 int read_level(int arg
)
1812 CHILD
*ch
; /* Walk through list */
1813 unsigned char foo
= 'X'; /* Contents of INITLVL */
1828 if (stat(INITLVL
, &stt
) != 0 || stt
.st_size
!= 0L)
1829 fp
= fopen(INITLVL
, "r");
1832 (stat(INITLVL2
, &stt
) != 0 || stt
.st_size
!= 0L))
1833 fp
= fopen(INITLVL2
, "r");
1836 /* INITLVL file empty or not there - act as 'init q' */
1837 initlog(L_SY
, "Re-reading inittab");
1840 ok
= fscanf(fp
, "%c %d", &foo
, &st
);
1843 /* We go to the new runlevel passed as an argument. */
1847 if (ok
== 2) sltime
= st
;
1849 #endif /* INITLVL */
1851 if (islower(foo
)) foo
= toupper(foo
);
1852 if (ok
< 1 || ok
> 2 || strchr("QS0123456789ABCU", foo
) == NULL
) {
1853 initlog(L_VB
, "bad runlevel: %c", foo
);
1857 /* Log this action */
1860 initlog(L_VB
, "Going single user");
1863 initlog(L_SY
, "Re-reading inittab");
1869 "Activating demand-procedures for '%c'", foo
);
1872 initlog(L_SY
, "Trying to re-exec init");
1875 initlog(L_VB
, "Switching to runlevel: %c", foo
);
1879 #if defined(SIGINT_ONLYONCE) && (SIGINT_ONLYONCE == 1)
1880 /* Re-enable signal from keyboard */
1881 struct sigaction sa
;
1882 SETSIG(sa
, SIGINT
, signal_handler
, 0);
1887 /* Check if this is a runlevel a, b or c */
1888 if (strchr("ABC", foo
)) {
1889 if (runlevel
== 'S') return(runlevel
);
1891 /* Read inittab again first! */
1894 /* Mark those special tasks */
1895 for(ch
= family
; ch
; ch
= ch
->next
)
1896 if (strchr(ch
->rlevel
, foo
) != NULL
||
1897 strchr(ch
->rlevel
, tolower(foo
)) != NULL
) {
1898 ch
->flags
|= DEMAND
;
1899 ch
->flags
&= ~XECUTED
;
1901 "Marking (%s) as ondemand, flags %d",
1907 /* Store both the old and the new runlevel. */
1908 wrote_utmp_rlevel
= 0;
1909 wrote_wtmp_rlevel
= 0;
1910 write_utmp_wtmp("runlevel", "~~", foo
+ 256*runlevel
, RUN_LVL
, "~");
1912 prevlevel
= runlevel
;
1918 * This procedure is called after every signal (SIGHUP, SIGALRM..)
1920 * Only clear the 'failing' flag if the process is sleeping
1921 * longer than 5 minutes, or inittab was read again due
1922 * to user interaction.
1925 void fail_check(void)
1927 CHILD
*ch
; /* Pointer to child structure */
1928 time_t t
; /* System time */
1929 time_t next_alarm
= 0; /* When to set next alarm */
1933 for(ch
= family
; ch
; ch
= ch
->next
) {
1935 if (ch
->flags
& FAILING
) {
1936 /* Can we free this sucker? */
1937 if (ch
->tm
+ SLEEPTIME
< t
) {
1938 ch
->flags
&= ~FAILING
;
1942 /* No, we'll look again later */
1943 if (next_alarm
== 0 ||
1944 ch
->tm
+ SLEEPTIME
> next_alarm
)
1945 next_alarm
= ch
->tm
+ SLEEPTIME
;
1951 if (next_alarm
< 1) next_alarm
= 1;
1956 /* Set all 'Fail' timers to 0 */
1958 void fail_cancel(void)
1962 for(ch
= family
; ch
; ch
= ch
->next
) {
1965 ch
->flags
&= ~FAILING
;
1970 * Start up powerfail entries.
1973 void do_power_fail(int pwrstat
)
1978 * Tell powerwait & powerfail entries to start up
1980 for (ch
= family
; ch
; ch
= ch
->next
) {
1981 if (pwrstat
== 'O') {
1983 * The power is OK again.
1985 if (ch
->action
== POWEROKWAIT
)
1986 ch
->flags
&= ~XECUTED
;
1987 } else if (pwrstat
== 'L') {
1989 * Low battery, shut down now.
1991 if (ch
->action
== POWERFAILNOW
)
1992 ch
->flags
&= ~XECUTED
;
1995 * Power is failing, shutdown imminent
1997 if (ch
->action
== POWERFAIL
|| ch
->action
== POWERWAIT
)
1998 ch
->flags
&= ~XECUTED
;
2004 * Check for state-pipe presence
2007 int check_pipe(int fd
)
2015 t
.tv_sec
= t
.tv_usec
= 0;
2017 if (select(fd
+1, &s
, NULL
, NULL
, &t
) != 1)
2019 if (read(fd
, signature
, 8) != 8)
2021 return strncmp(Signature
, signature
, 8) == 0;
2025 * Make a state-pipe.
2028 int make_pipe(int fd
)
2035 fcntl(fds
[1], F_SETFD
, 1);
2036 fcntl(fd
, F_SETFD
, 0);
2037 write(fds
[1], Signature
, 8);
2043 * Attempt to re-exec.
2049 sigset_t mask
, oldset
;
2054 if (strchr("S0123456",runlevel
) == NULL
)
2058 * Reset the alarm, and block all signals.
2062 sigprocmask(SIG_BLOCK
, &mask
, &oldset
);
2065 * construct a pipe fd --> STATE_PIPE and write a signature
2067 fd
= make_pipe(STATE_PIPE
);
2070 * It's a backup day today, so I'm pissed off. Being a BOFH, however,
2071 * does have it's advantages...
2076 DELSET(got_signals
, SIGCHLD
);
2077 DELSET(got_signals
, SIGHUP
);
2078 DELSET(got_signals
, SIGUSR1
);
2081 * That should be cleaned.
2083 for(ch
= family
; ch
; ch
= ch
->next
)
2084 if (ch
->flags
& ZOMBIE
) {
2085 INITDBG(L_VB
, "Child died, PID= %d", ch
->pid
);
2086 ch
->flags
&= ~(RUNNING
|ZOMBIE
|WAITING
);
2087 if (ch
->process
[0] != '+')
2088 write_utmp_wtmp("", ch
->id
, ch
->pid
, DEAD_PROCESS
, NULL
);
2091 if ((pid
= fork()) == 0) {
2093 * Child sends state information to the parent.
2100 * The existing init process execs a new init binary.
2102 env
= init_buildenv(0);
2103 execle(myname
, myname
, "--init", NULL
, env
);
2106 * We shouldn't be here, something failed.
2107 * Bitch, close the state pipe, unblock signals and return.
2111 sigprocmask(SIG_SETMASK
, &oldset
, NULL
);
2113 initlog(L_CO
, "Attempt to re-exec failed");
2117 * Redo utmp/wtmp entries if required or requested
2118 * Check for written records and size of utmp
2121 void redo_utmp_wtmp(void)
2124 const int ret
= stat(UTMP_FILE
, &ustat
);
2126 if ((ret
< 0) || (ustat
.st_size
== 0))
2127 wrote_utmp_rlevel
= wrote_utmp_reboot
= 0;
2129 if ((wrote_wtmp_reboot
== 0) || (wrote_utmp_reboot
== 0))
2130 write_utmp_wtmp("reboot", "~~", 0, BOOT_TIME
, "~");
2132 if ((wrote_wtmp_rlevel
== 0) || (wrote_wtmp_rlevel
== 0))
2133 write_utmp_wtmp("runlevel", "~~", thislevel
+ 256 * prevlevel
, RUN_LVL
, "~");
2137 * We got a change runlevel request through the
2138 * init.fifo. Process it.
2141 void fifo_new_level(int level
)
2148 if (level
== runlevel
) return;
2151 /* Are we waiting for a child? */
2152 for(ch
= family
; ch
; ch
= ch
->next
)
2153 if (ch
->flags
& WAITING
) break;
2157 /* We need to go into a new runlevel */
2158 oldlevel
= runlevel
;
2159 runlevel
= read_level(level
);
2160 if (runlevel
== 'U') {
2161 runlevel
= oldlevel
;
2164 if (oldlevel
!= 'S' && runlevel
== 'S') console_stty();
2165 if (runlevel
== '6' || runlevel
== '0' ||
2166 runlevel
== '1') console_stty();
2167 if (runlevel
> '1' && runlevel
< '6') redo_utmp_wtmp();
2170 setproctitle("init [%c]", (int)runlevel
);
2177 * Set/unset environment variables. The variables are
2178 * encoded as KEY=VAL\0KEY=VAL\0\0. With "=VAL" it means
2179 * setenv, without it means unsetenv.
2182 void initcmd_setenv(char *data
, int size
)
2184 char *env
, *p
, *e
, *eq
;
2189 while (*data
&& data
< e
) {
2191 for (p
= data
; *p
&& p
< e
; p
++)
2192 if (*p
== '=') eq
= p
;
2197 sz
= eq
? (eq
- env
) : (p
- env
);
2199 /*initlog(L_SY, "init_setenv: %s, %s, %d", env, eq, sz);*/
2202 * We only allow INIT_* to be set.
2204 if (strncmp(env
, "INIT_", 5) != 0)
2207 /* Free existing vars. */
2208 for (i
= 0; i
< NR_EXTRA_ENV
; i
++) {
2209 if (extra_env
[i
] == NULL
) continue;
2210 if (!strncmp(extra_env
[i
], env
, sz
) &&
2211 extra_env
[i
][sz
] == '=') {
2213 extra_env
[i
] = NULL
;
2217 /* Set new vars if needed. */
2218 if (eq
== NULL
) continue;
2219 for (i
= 0; i
< NR_EXTRA_ENV
; i
++) {
2220 if (extra_env
[i
] == NULL
) {
2221 extra_env
[i
] = istrdup(env
);
2230 * Read from the init FIFO. Processes like telnetd and rlogind can
2231 * ask us to create login processes on their behalf.
2233 * FIXME: this needs to be finished. NOT that it is buggy, but we need
2234 * to add the telnetd/rlogind stuff so people can start using it.
2235 * Maybe move to using an AF_UNIX socket so we can use
2236 * the 2.2 kernel credential stuff to see who we're talking to.
2240 void check_init_fifo(void)
2242 struct init_request request
;
2244 struct stat st
, st2
;
2250 * First, try to create /dev/initctl if not present.
2252 if (stat(INIT_FIFO
, &st2
) < 0 && errno
== ENOENT
)
2253 (void)mkfifo(INIT_FIFO
, 0600);
2256 * If /dev/initctl is open, stat the file to see if it
2257 * is still the _same_ inode.
2260 fstat(pipe_fd
, &st
);
2261 if (stat(INIT_FIFO
, &st2
) < 0 ||
2262 st
.st_dev
!= st2
.st_dev
||
2263 st
.st_ino
!= st2
.st_ino
) {
2270 * Now finally try to open /dev/initctl
2273 if ((pipe_fd
= open(INIT_FIFO
, O_RDWR
|O_NONBLOCK
)) >= 0) {
2274 fstat(pipe_fd
, &st
);
2275 if (!S_ISFIFO(st
.st_mode
)) {
2276 initlog(L_VB
, "%s is not a fifo", INIT_FIFO
);
2283 * Don't use fd's 0, 1 or 2.
2285 (void) dup2(pipe_fd
, PIPE_FD
);
2290 * Return to caller - we'll be back later.
2295 /* Wait for data to appear, _if_ the pipe was opened. */
2296 if (pipe_fd
>= 0) while(!quit
) {
2298 /* Do select, return on EINTR. */
2300 FD_SET(pipe_fd
, &fds
);
2303 n
= select(pipe_fd
+ 1, &fds
, NULL
, NULL
, &tv
);
2305 if (n
== 0 || errno
== EINTR
) return;
2309 /* Read the data, return on EINTR. */
2310 n
= read(pipe_fd
, &request
, sizeof(request
));
2313 * End of file. This can't happen under Linux (because
2314 * the pipe is opened O_RDWR - see select() in the
2315 * kernel) but you never know...
2322 if (errno
== EINTR
) return;
2323 initlog(L_VB
, "error reading initrequest");
2328 * This is a convenient point to also try to
2329 * find the console device or check if it changed.
2336 if (request
.magic
!= INIT_MAGIC
|| n
!= sizeof(request
)) {
2337 initlog(L_VB
, "got bogus initrequest");
2340 switch(request
.cmd
) {
2341 case INIT_CMD_RUNLVL
:
2342 sltime
= request
.sleeptime
;
2343 fifo_new_level(request
.runlevel
);
2346 case INIT_CMD_POWERFAIL
:
2347 sltime
= request
.sleeptime
;
2351 case INIT_CMD_POWERFAILNOW
:
2352 sltime
= request
.sleeptime
;
2356 case INIT_CMD_POWEROK
:
2357 sltime
= request
.sleeptime
;
2361 case INIT_CMD_SETENV
:
2362 initcmd_setenv(request
.i
.data
, sizeof(request
.i
.data
));
2365 initlog(L_VB
, "got unimplemented initrequest.");
2371 * We come here if the pipe couldn't be opened.
2373 if (pipe_fd
< 0) pause();
2379 * This function is used in the transition
2380 * sysinit (-> single user) boot -> multi-user.
2383 void boot_transitions()
2386 static int newlevel
= 0;
2387 static int warn
= 1;
2391 /* Check if there is something to wait for! */
2392 for( ch
= family
; ch
; ch
= ch
->next
)
2393 if ((ch
->flags
& RUNNING
) && ch
->action
!= BOOT
) break;
2396 /* No processes left in this level, proceed to next level. */
2400 case '#': /* SYSINIT -> BOOT */
2401 INITDBG(L_VB
, "SYSINIT -> BOOT");
2403 /* Write a boot record. */
2404 wrote_utmp_reboot
= 0;
2405 wrote_wtmp_reboot
= 0;
2406 write_utmp_wtmp("reboot", "~~", 0, BOOT_TIME
, "~");
2408 /* Get our run level */
2409 newlevel
= dfl_level
? dfl_level
: get_init_default();
2410 if (newlevel
== 'S') {
2411 runlevel
= newlevel
;
2412 /* Not really 'S' but show anyway. */
2413 setproctitle("init [S]");
2417 case '*': /* BOOT -> NORMAL */
2418 INITDBG(L_VB
, "BOOT -> NORMAL");
2419 if (runlevel
!= newlevel
)
2420 loglevel
= newlevel
;
2421 runlevel
= newlevel
;
2425 case 'S': /* Ended SU mode */
2427 INITDBG(L_VB
, "END SU MODE");
2428 newlevel
= get_init_default();
2429 if (!did_boot
&& newlevel
!= 'S')
2432 if (runlevel
!= newlevel
)
2433 loglevel
= newlevel
;
2434 runlevel
= newlevel
;
2438 for(ch
= family
; ch
; ch
= ch
->next
)
2439 if (strcmp(ch
->rlevel
, "S") == 0)
2440 ch
->flags
&= ~(FAILING
|WAITING
|XECUTED
);
2445 "no more processes left in this runlevel");
2448 if (got_signals
== 0)
2453 initlog(L_VB
, "Entering runlevel: %c", runlevel
);
2454 wrote_utmp_rlevel
= 0;
2455 wrote_wtmp_rlevel
= 0;
2456 write_utmp_wtmp("runlevel", "~~", runlevel
+ 256 * oldlevel
, RUN_LVL
, "~");
2457 thislevel
= runlevel
;
2458 prevlevel
= oldlevel
;
2459 setproctitle("init [%c]", (int)runlevel
);
2465 * Init got hit by a signal. See which signal it is,
2466 * and act accordingly.
2469 void process_signals()
2477 if (ISMEMBER(got_signals
, SIGPWR
)) {
2478 INITDBG(L_VB
, "got SIGPWR");
2479 /* See _what_ kind of SIGPWR this is. */
2481 if ((fd
= open(PWRSTAT
, O_RDONLY
)) >= 0) {
2488 do_power_fail(pwrstat
);
2489 DELSET(got_signals
, SIGPWR
);
2492 if (ISMEMBER(got_signals
, SIGINT
)) {
2493 #if defined(SIGINT_ONLYONCE) && (SIGINT_ONLYONCE == 1)
2494 /* Ignore any further signal from keyboard */
2495 struct sigaction sa
;
2496 SETSIG(sa
, SIGINT
, SIG_IGN
, SA_RESTART
);
2498 INITDBG(L_VB
, "got SIGINT");
2499 /* Tell ctrlaltdel entry to start up */
2500 for(ch
= family
; ch
; ch
= ch
->next
)
2501 if (ch
->action
== CTRLALTDEL
)
2502 ch
->flags
&= ~XECUTED
;
2503 DELSET(got_signals
, SIGINT
);
2506 if (ISMEMBER(got_signals
, SIGWINCH
)) {
2507 INITDBG(L_VB
, "got SIGWINCH");
2508 /* Tell kbrequest entry to start up */
2509 for(ch
= family
; ch
; ch
= ch
->next
)
2510 if (ch
->action
== KBREQUEST
)
2511 ch
->flags
&= ~XECUTED
;
2512 DELSET(got_signals
, SIGWINCH
);
2515 if (ISMEMBER(got_signals
, SIGALRM
)) {
2516 INITDBG(L_VB
, "got SIGALRM");
2517 /* The timer went off: check it out */
2518 DELSET(got_signals
, SIGALRM
);
2521 if (ISMEMBER(got_signals
, SIGCHLD
)) {
2522 INITDBG(L_VB
, "got SIGCHLD");
2523 /* First set flag to 0 */
2524 DELSET(got_signals
, SIGCHLD
);
2526 /* See which child this was */
2527 for(ch
= family
; ch
; ch
= ch
->next
)
2528 if (ch
->flags
& ZOMBIE
) {
2529 INITDBG(L_VB
, "Child died, PID= %d", ch
->pid
);
2530 ch
->flags
&= ~(RUNNING
|ZOMBIE
|WAITING
);
2531 if (ch
->process
[0] != '+')
2532 write_utmp_wtmp("", ch
->id
, ch
->pid
, DEAD_PROCESS
, NULL
);
2537 if (ISMEMBER(got_signals
, SIGHUP
)) {
2538 INITDBG(L_VB
, "got SIGHUP");
2540 /* Are we waiting for a child? */
2541 for(ch
= family
; ch
; ch
= ch
->next
)
2542 if (ch
->flags
& WAITING
) break;
2546 /* We need to go into a new runlevel */
2547 oldlevel
= runlevel
;
2549 runlevel
= read_level(0);
2551 if (runlevel
== 'U') {
2552 runlevel
= oldlevel
;
2555 if (oldlevel
!= 'S' && runlevel
== 'S') console_stty();
2556 if (runlevel
== '6' || runlevel
== '0' ||
2557 runlevel
== '1') console_stty();
2560 setproctitle("init [%c]", (int)runlevel
);
2561 DELSET(got_signals
, SIGHUP
);
2565 if (ISMEMBER(got_signals
, SIGUSR1
)) {
2567 * SIGUSR1 means close and reopen /dev/initctl
2569 INITDBG(L_VB
, "got SIGUSR1");
2572 DELSET(got_signals
, SIGUSR1
);
2580 void init_main(void)
2583 struct sigaction sa
;
2591 * Fork so we can debug the init process.
2593 if ((f
= fork()) > 0) {
2594 static const char killmsg
[] = "PRNT: init killed.\r\n";
2597 while((rc
= wait(&st
)) != f
)
2598 if (rc
< 0 && errno
== ECHILD
)
2600 write(1, killmsg
, sizeof(killmsg
) - 1);
2607 * Tell the kernel to send us SIGINT when CTRL-ALT-DEL
2608 * is pressed, and that we want to handle keyboard signals.
2610 init_reboot(BMAGIC_SOFT
);
2611 if ((f
= open(VT_MASTER
, O_RDWR
| O_NOCTTY
)) >= 0) {
2612 (void) ioctl(f
, KDSIGACCEPT
, SIGWINCH
);
2615 (void) ioctl(0, KDSIGACCEPT
, SIGWINCH
);
2619 * Ignore all signals.
2621 for(f
= 1; f
<= NSIG
; f
++)
2622 SETSIG(sa
, f
, SIG_IGN
, SA_RESTART
);
2625 SETSIG(sa
, SIGALRM
, signal_handler
, 0);
2626 SETSIG(sa
, SIGHUP
, signal_handler
, 0);
2627 SETSIG(sa
, SIGINT
, signal_handler
, 0);
2628 SETSIG(sa
, SIGCHLD
, chld_handler
, SA_RESTART
);
2629 SETSIG(sa
, SIGPWR
, signal_handler
, 0);
2630 SETSIG(sa
, SIGWINCH
, signal_handler
, 0);
2631 SETSIG(sa
, SIGUSR1
, signal_handler
, 0);
2632 SETSIG(sa
, SIGSTOP
, stop_handler
, SA_RESTART
);
2633 SETSIG(sa
, SIGTSTP
, stop_handler
, SA_RESTART
);
2634 SETSIG(sa
, SIGCONT
, cont_handler
, SA_RESTART
);
2635 SETSIG(sa
, SIGSEGV
, (void (*)(int))segv_handler
, SA_RESTART
);
2642 /* Close whatever files are open, and reset the console. */
2650 * Set default PATH variable.
2652 setenv("PATH", PATH_DEFAULT
, 1 /* Overwrite */);
2655 * Initialize /var/run/utmp (only works if /var is on
2656 * root and mounted rw)
2658 if ((fd
= open(UTMP_FILE
, O_WRONLY
|O_CREAT
|O_TRUNC
, 0644)) >= 0)
2662 * Say hello to the world
2664 initlog(L_CO
, bootmsg
, "booting");
2667 * See if we have to start an emergency shell.
2671 SETSIG(sa
, SIGCHLD
, SIG_DFL
, SA_RESTART
);
2672 if (spawn(&ch_emerg
, &f
) > 0) {
2673 while((rc
= wait(&st
)) != f
)
2674 if (rc
< 0 && errno
== ECHILD
)
2677 SETSIG(sa
, SIGCHLD
, chld_handler
, SA_RESTART
);
2681 * Start normal boot procedure.
2688 * Restart: unblock signals and let the show go on
2690 initlog(L_CO
, bootmsg
, "reloading");
2692 sigprocmask(SIG_UNBLOCK
, &sgt
, NULL
);
2695 * Set default PATH variable.
2697 setenv("PATH", PATH_DEFAULT
, 0 /* Don't overwrite */);
2703 /* See if we need to make the boot transitions. */
2705 INITDBG(L_VB
, "init_main: waiting..");
2707 /* Check if there are processes to be waited on. */
2708 for(ch
= family
; ch
; ch
= ch
->next
)
2709 if ((ch
->flags
& RUNNING
) && ch
->action
!= BOOT
) break;
2712 /* Wait until we get hit by some signal. */
2713 while (ch
!= NULL
&& got_signals
== 0) {
2714 if (ISMEMBER(got_signals
, SIGHUP
)) {
2715 /* See if there are processes to be waited on. */
2716 for(ch
= family
; ch
; ch
= ch
->next
)
2717 if (ch
->flags
& WAITING
) break;
2719 if (ch
!= NULL
) check_init_fifo();
2721 #else /* CHANGE_WAIT */
2722 if (ch
!= NULL
&& got_signals
== 0) check_init_fifo();
2723 #endif /* CHANGE_WAIT */
2725 /* Check the 'failing' flags */
2728 /* Process any signals. */
2731 /* See what we need to start up (again) */
2738 * Tell the user about the syntax we expect.
2743 fprintf(stderr
, "Usage: %s {-e VAR[=VAL] | [-t SECONDS] {0|1|2|3|4|5|6|S|s|Q|q|A|a|B|b|C|c|U|u}}\n", s
);
2748 int telinit(char *progname
, int argc
, char **argv
)
2750 #ifdef TELINIT_USES_INITLVL
2753 struct init_request request
;
2754 struct sigaction sa
;
2758 memset(&request
, 0, sizeof(request
));
2759 request
.magic
= INIT_MAGIC
;
2761 while ((f
= getopt(argc
, argv
, "t:e:")) != EOF
) switch(f
) {
2763 sltime
= atoi(optarg
);
2767 env
= request
.i
.data
;
2769 if (env
+ l
+ 2 > request
.i
.data
+ sizeof(request
.i
.data
)) {
2770 fprintf(stderr
, "%s: -e option data "
2771 "too large\n", progname
);
2774 memcpy(env
, optarg
, l
);
2783 if (env
) *env
++ = 0;
2788 request
.cmd
= INIT_CMD_SETENV
;
2790 if (argc
- optind
!= 1 || strlen(argv
[optind
]) != 1)
2792 if (!strchr("0123456789SsQqAaBbCcUu", argv
[optind
][0]))
2794 request
.cmd
= INIT_CMD_RUNLVL
;
2795 request
.runlevel
= env
? 0 : argv
[optind
][0];
2796 request
.sleeptime
= sltime
;
2799 /* Change to the root directory. */
2802 /* Open the fifo and write a command. */
2803 /* Make sure we don't hang on opening /dev/initctl */
2804 SETSIG(sa
, SIGALRM
, signal_handler
, 0);
2806 if ((fd
= open(INIT_FIFO
, O_WRONLY
)) >= 0) {
2808 size_t s
= sizeof(request
);
2809 void *ptr
= &request
;
2812 p
= write(fd
, ptr
, s
);
2814 if (errno
== EINTR
|| errno
== EAGAIN
)
2826 #ifdef TELINIT_USES_INITLVL
2827 if (request
.cmd
== INIT_CMD_RUNLVL
) {
2828 /* Fallthrough to the old method. */
2830 /* Now write the new runlevel. */
2831 if ((fp
= fopen(INITLVL
, "w")) == NULL
) {
2832 fprintf(stderr
, "%s: cannot create %s\n",
2836 fprintf(fp
, "%s %d", argv
[optind
], sltime
);
2839 /* And tell init about the pending runlevel change. */
2840 if (kill(INITPID
, SIGHUP
) < 0) perror(progname
);
2846 fprintf(stderr
, "%s: ", progname
);
2847 if (ISMEMBER(got_signals
, SIGALRM
)) {
2848 fprintf(stderr
, "timeout opening/writing control channel %s\n",
2857 * Main entry for init and telinit.
2859 int main(int argc
, char **argv
)
2868 /* Get my own name */
2869 if ((p
= strrchr(argv
[0], '/')) != NULL
)
2878 if (geteuid() != 0) {
2879 fprintf(stderr
, "%s: must be superuser.\n", p
);
2884 * Is this telinit or init ?
2886 isinit
= (getpid() == 1);
2887 for (f
= 1; f
< argc
; f
++) {
2888 if (!strcmp(argv
[f
], "-i") || !strcmp(argv
[f
], "--init")) {
2893 if (!isinit
) exit(telinit(p
, argc
, argv
));
2898 if (check_pipe(STATE_PIPE
)) {
2900 receive_state(STATE_PIPE
);
2902 myname
= istrdup(argv
[0]);
2905 for (f
= 0; f
< argc
; f
++)
2906 maxproclen
+= strlen(argv
[f
]) + 1;
2908 setproctitle("init [%c]", (int)runlevel
);
2913 /* Check command line arguments */
2914 maxproclen
= strlen(argv
[0]) + 1;
2915 for(f
= 1; f
< argc
; f
++) {
2916 if (!strcmp(argv
[f
], "single") || !strcmp(argv
[f
], "-s"))
2918 else if (!strcmp(argv
[f
], "-a") || !strcmp(argv
[f
], "auto"))
2919 putenv("AUTOBOOT=YES");
2920 else if (!strcmp(argv
[f
], "-b") || !strcmp(argv
[f
],"emergency"))
2922 else if (!strcmp(argv
[f
], "-z")) {
2924 if (argv
[f
+ 1]) f
++;
2925 } else if (strchr("0123456789sS", argv
[f
][0])
2926 && strlen(argv
[f
]) == 1)
2927 dfl_level
= argv
[f
][0];
2928 /* "init u" in the very beginning makes no sense */
2929 if (dfl_level
== 's') dfl_level
= 'S';
2930 maxproclen
+= strlen(argv
[f
]) + 1;
2934 if (getenv("SELINUX_INIT") == NULL
) {
2935 const int rc
= mount("proc", "/proc", "proc", 0, 0);
2936 if (is_selinux_enabled() > 0) {
2937 putenv("SELINUX_INIT=YES");
2938 if (rc
== 0) umount2("/proc", MNT_DETACH
);
2939 if (selinux_init_load_policy(&enforce
) == 0) {
2940 execv(myname
, argv
);
2943 /* SELinux in enforcing mode but load_policy failed */
2944 /* At this point, we probably can't open /dev/console, so log() won't work */
2945 fprintf(stderr
,"Unable to load SELinux Policy. Machine is in enforcing mode. Halting now.\n");
2950 if (rc
== 0) umount2("/proc", MNT_DETACH
);
2953 /* Start booting. */
2956 setproctitle("init boot");