Latest and greatest
[people/mcb30/busybox.git] / init.c
1 /*
2  * Mini init implementation for busybox
3  *
4  *
5  * Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
6  * Adjusted by so many folks, it's impossible to keep track.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21  *
22  */
23
24 #include "internal.h"
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <stdarg.h>
28 #include <unistd.h>
29 #include <errno.h>
30 #include <signal.h>
31 #include <termios.h>
32 #include <sys/types.h>
33 #include <sys/fcntl.h>
34 #include <sys/wait.h>
35 #include <string.h>
36 #include <sys/mount.h>
37 #include <sys/reboot.h>
38 #include <sys/kdaemon.h>
39 #include <sys/sysmacros.h>
40 #include <linux/serial.h>       /* for serial_struct */
41 #include <sys/vt.h>             /* for vt_stat */
42 #include <sys/ioctl.h>
43
44 #define DEV_CONSOLE      "/dev/console" /* Logical system console */
45 #define VT_PRIMARY      "/dev/tty1"     /* Primary virtual console */
46 #define VT_SECONDARY    "/dev/tty2"     /* Virtual console */
47 #define VT_LOG          "/dev/tty3"     /* Virtual console */
48 #define SERIAL_CON0     "/dev/ttyS0"    /* Primary serial console */
49 #define SERIAL_CON1     "/dev/ttyS1"    /* Serial console */
50 #define SHELL           "/bin/sh"       /* Default shell */
51 #define INITSCRIPT      "/etc/init.d/rcS"       /* Initscript. */
52 #define PATH_DEFAULT    "PATH=/usr/local/sbin:/sbin:/bin:/usr/sbin:/usr/bin"
53
54 #define LOG             0x1
55 #define CONSOLE         0x2
56 static char *console = DEV_CONSOLE;
57 static char *second_console = VT_SECONDARY;
58 static char *log = VT_LOG;
59 static int kernel_version = 0;
60
61
62 /* try to open up the specified device */
63 int device_open(char *device, int mode)
64 {
65     int m, f, fd = -1;
66
67     m = mode | O_NONBLOCK;
68
69     /* Retry up to 5 times */
70     for (f = 0; f < 5; f++)
71         if ((fd = open(device, m)) >= 0)
72             break;
73     if (fd < 0)
74         return fd;
75     /* Reset original flags. */
76     if (m != mode)
77         fcntl(fd, F_SETFL, mode);
78     return fd;
79 }
80
81 /* print a message to the specified device:
82  * device may be bitwise-or'd from LOG | CONSOLE */
83 void message(int device, char *fmt, ...)
84 {
85     int fd;
86     static int log_fd=-1;
87     va_list arguments;
88
89     /* Take full control of the log tty, and never close it.
90      * It's mine, all mine!  Muhahahaha! */
91     if (log_fd < 0) {
92         if (log == NULL) {
93         /* don't even try to log, because there is no such console */
94         log_fd = -2;
95         /* log to main console instead */
96         device = CONSOLE;
97     }
98     else if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) {
99             log_fd=-1;
100             fprintf(stderr, "Bummer, can't write to log on %s!\r\n", log);
101             fflush(stderr);
102             return;
103         }
104     }
105
106     if ( (device & LOG) && (log_fd >= 0) ) {
107         va_start(arguments, fmt);
108         vdprintf(log_fd, fmt, arguments);
109         va_end(arguments);
110     }
111     if (device & CONSOLE) {
112         /* Always send console messages to /dev/console so people will see them. */
113         if ((fd = device_open(DEV_CONSOLE, O_WRONLY|O_NOCTTY|O_NDELAY)) >= 0) {
114             va_start(arguments, fmt);
115             vdprintf(fd, fmt, arguments);
116             va_end(arguments);
117             close(fd);
118         } else {
119             fprintf(stderr, "Bummer, can't print: ");
120             va_start(arguments, fmt);
121             vfprintf(stderr, fmt, arguments);
122             fflush(stderr);
123             va_end(arguments);
124         }
125     }
126 }
127
128
129 /* Set terminal settings to reasonable defaults */
130 void set_term( int fd)
131 {
132     struct termios tty;
133     static const char control_characters[] = {
134         '\003', '\034', '\177', '\030', '\004', '\0',
135         '\1', '\0', '\021', '\023', '\032', '\0', '\022',
136         '\017', '\027', '\026', '\0'
137         };
138
139     tcgetattr(fd, &tty);
140
141     /* Make it be sane */
142     tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD;
143     tty.c_cflag |= HUPCL|CLOCAL;
144
145     /* input modes */
146     tty.c_iflag = IGNPAR|ICRNL|IXON|IXOFF|IXANY;
147
148     /* use line dicipline 0 */
149     tty.c_line = 0;
150
151     /* output modes */
152     tty.c_oflag = OPOST|ONLCR;
153
154     /* local modes */
155     tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOPRT|ECHOKE|IEXTEN;
156
157     /* control chars */
158     memcpy(tty.c_cc, control_characters, sizeof(control_characters));
159
160     tcsetattr(fd, TCSANOW, &tty);
161 }
162
163 /* How much memory does this machine have? */
164 static int mem_total()
165 {
166     char s[80];
167     char *p = "/proc/meminfo";
168     FILE *f;
169     const char pattern[] = "MemTotal:";
170
171     if ((f = fopen(p, "r")) < 0) {
172         message(LOG, "Error opening %s: %s\n", p, strerror( errno));
173         return -1;
174     }
175     while (NULL != fgets(s, 79, f)) {
176         p = strstr(s, pattern);
177         if (NULL != p) {
178             fclose(f);
179             return (atoi(p + strlen(pattern)));
180         }
181     }
182     return -1;
183 }
184
185 static void console_init()
186 {
187     int fd;
188     int tried_devcons = 0;
189     int tried_vtprimary = 0;
190     struct serial_struct sr;
191     char *s;
192
193     if ((s = getenv("CONSOLE")) != NULL) {
194         console = s;
195     }
196 #if #cpu(sparc)
197     /* sparc kernel supports console=tty[ab] parameter which is also 
198      * passed to init, so catch it here */
199     else if ((s = getenv("console")) != NULL) {
200         /* remap tty[ab] to /dev/ttyS[01] */
201         if (strcmp( s, "ttya" )==0)
202             console = SERIAL_CON0;
203         else if (strcmp( s, "ttyb" )==0)
204             console = SERIAL_CON1;
205     }
206 #endif
207     else {
208         struct vt_stat vt;
209         static char the_console[13];
210
211         console = the_console;
212         /* 2.2 kernels: identify the real console backend and try to use it */
213         if (ioctl(0,TIOCGSERIAL,&sr) == 0) {
214             /* this is a serial console */
215             snprintf( the_console, sizeof the_console, "/dev/ttyS%d", sr.line );
216         }
217         else if (ioctl(0, VT_GETSTATE, &vt) == 0) {
218             /* this is linux virtual tty */
219             snprintf( the_console, sizeof the_console, "/dev/tty%d", vt.v_active );
220         } else {
221             console = DEV_CONSOLE;
222             tried_devcons++;
223         }
224     }
225
226     while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) {
227         /* Can't open selected console -- try /dev/console */
228         if (!tried_devcons) {
229             tried_devcons++;
230             console = DEV_CONSOLE;
231             continue;
232         }
233         /* Can't open selected console -- try vt1 */
234         if (!tried_vtprimary) {
235             tried_vtprimary++;
236             console = VT_PRIMARY;
237             continue;
238         }
239         break;
240     }
241     if (fd < 0)
242         /* Perhaps we should panic here? */
243         console = "/dev/null";
244     else {
245         /* check for serial console and disable logging to tty3 & running a
246         * shell to tty2 */
247         if (ioctl(0,TIOCGSERIAL,&sr) == 0) {
248             log = NULL;
249             second_console = NULL;
250         }
251         close(fd);
252     }
253     message(LOG, "console=%s\n", console );
254 }
255
256 static int waitfor(int pid)
257 {
258     int status, wpid;
259
260     message(LOG, "Waiting for process %d.\n", pid);
261     while ((wpid = wait(&status)) != pid) {
262         if (wpid > 0)
263             message(LOG, "pid %d exited, status=0x%x.\n", wpid, status);
264     }
265     return wpid;
266 }
267
268
269 static pid_t run(const char * const* command, 
270         char *terminal, int get_enter)
271 {
272     int fd;
273     pid_t pid;
274     const char * const* cmd = command+1;
275     static const char press_enter[] =
276         "\nPlease press Enter to activate this console. ";
277
278     if ((pid = fork()) == 0) {
279         /* Clean up */
280         close(0);
281         close(1);
282         close(2);
283         setsid();
284
285         /* Reset signal handlers set for parent process */
286         signal(SIGUSR1, SIG_DFL);
287         signal(SIGUSR2, SIG_DFL);
288         signal(SIGINT, SIG_DFL);
289         signal(SIGTERM, SIG_DFL);
290
291         if ((fd = device_open(terminal, O_RDWR)) < 0) {
292             message(LOG, "Bummer, can't open %s\r\n", terminal);
293             exit(-1);
294         }
295         dup(fd);
296         dup(fd);
297         tcsetpgrp(0, getpgrp());
298         set_term(0);
299
300         if (get_enter==TRUE) {
301             /*
302              * Save memory by not exec-ing anything large (like a shell)
303              * before the user wants it. This is critical if swap is not
304              * enabled and the system has low memory. Generally this will
305              * be run on the second virtual console, and the first will
306              * be allowed to start a shell or whatever an init script 
307              * specifies.
308              */
309             char c;
310             message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n", 
311                     *cmd, getpid(), terminal );
312             write(1, press_enter, sizeof(press_enter) - 1);
313             read(0, &c, 1);
314         }
315
316         /* Log the process name and args */
317         message(LOG, "Starting pid %d, console %s: '", getpid(), terminal);
318         while ( *cmd) message(LOG, "%s ", *cmd++);
319         message(LOG, "'\r\n");
320         
321         /* Now run it.  The new program will take over this PID, 
322          * so nothing further in init.c should be run. */
323         execvp(*command, (char**)command+1);
324
325         message(LOG, "Bummer, could not run '%s'\n", command);
326         exit(-1);
327     }
328     return pid;
329 }
330
331 /* Make sure there is enough memory to do something useful. *
332  * Calls swapon if needed so be sure /proc is mounted. */
333 static void check_memory()
334 {
335     struct stat statbuf;
336     const char* const swap_on_cmd[] = 
337             { "/bin/swapon", "swapon", "-a", 0};
338
339     if (mem_total() > 3500)
340         return;
341
342     if (stat("/etc/fstab", &statbuf) == 0) {
343         /* Try to turn on swap */
344         waitfor(run(swap_on_cmd, log, FALSE));
345         if (mem_total() < 3500)
346             goto goodnight;
347     } else
348         goto goodnight;
349     return;
350
351 goodnight:
352         message(CONSOLE, "Sorry, your computer does not have enough memory.\r\n");
353         while (1) sleep(1);
354 }
355
356 static void shutdown_system(void)
357 {
358     const char* const swap_off_cmd[] = { "swapoff", "swapoff", "-a", 0};
359     const char* const umount_cmd[] = { "umount", "umount", "-a", "-n", 0};
360
361 #ifndef DEBUG_INIT
362     /* Allow Ctrl-Alt-Del to reboot system. */
363     reboot(RB_ENABLE_CAD);
364 #endif
365     message(CONSOLE, "The system is going down NOW !!\r\n");
366     sync();
367     /* Send signals to every process _except_ pid 1 */
368     message(CONSOLE, "Sending SIGHUP to all processes.\r\n");
369 #ifndef DEBUG_INIT
370     kill(-1, SIGHUP);
371 #endif
372     sleep(2);
373     sync();
374     message(CONSOLE, "Sending SIGKILL to all processes.\r\n");
375 #ifndef DEBUG_INIT
376     kill(-1, SIGKILL);
377 #endif
378     sleep(1);
379     waitfor(run( swap_off_cmd, console, FALSE));
380     waitfor(run( umount_cmd, console, FALSE));
381     sync();
382     if (kernel_version > 0 && kernel_version <= 2 * 65536 + 2 * 256 + 11) {
383         /* bdflush, kupdate not needed for kernels >2.2.11 */
384         message(CONSOLE, "Flushing buffers.\r\n");
385         bdflush(1, 0);
386         sync();
387     }
388 }
389
390 static void halt_signal(int sig)
391 {
392     shutdown_system();
393     message(CONSOLE,
394             "The system is halted. Press CTRL-ALT-DEL or turn off power\r\n");
395     sync();
396 #ifndef DEBUG_INIT
397     reboot(RB_HALT_SYSTEM);
398     //reboot(RB_POWER_OFF);
399 #endif
400     exit(0);
401 }
402
403 static void reboot_signal(int sig)
404 {
405     shutdown_system();
406     message(CONSOLE, "Please stand by while rebooting the system.\r\n");
407     sync();
408 #ifndef DEBUG_INIT
409     reboot(RB_AUTOBOOT);
410 #endif
411     exit(0);
412 }
413
414 extern int init_main(int argc, char **argv)
415 {
416     int run_rc = TRUE;
417     int wait_for_enter = TRUE;
418     pid_t pid1 = 0;
419     pid_t pid2 = 0;
420     struct stat statbuf;
421     const char* const rc_script_command[] = { INITSCRIPT, INITSCRIPT, 0};
422     const char* const shell_command[] = { SHELL, "-" SHELL, 0};
423     const char* const* tty0_command = shell_command;
424     const char* const* tty1_command = shell_command;
425 #ifdef BB_CONSOLE_CMD_IF_RC_SCRIPT_EXITS
426     const char* const rc_exit_command[] = BB_CONSOLE_CMD_IF_RC_SCRIPT_EXITS;
427 #endif
428
429 #ifdef DEBUG_INIT
430     char *hello_msg_format =
431         "init(%d) started:  BusyBox v%s (%s) multi-call binary\r\n";
432 #else
433     char *hello_msg_format =
434         "init started:  BusyBox v%s (%s) multi-call binary\r\n";
435 #endif
436
437     
438 #ifndef DEBUG_INIT
439     if (getpid() != 1) {
440         usage( "init\n\nInit is the parent of all processes.\n\n"
441                 "This version of init is designed to be run only by the kernel\n");
442     }
443 #endif
444
445     /* Check if we are supposed to be in single user mode */
446     if ( argc > 1 && (!strcmp(argv[1], "single") || 
447                 !strcmp(argv[1], "-s") || !strcmp(argv[1], "1"))) {
448         run_rc = FALSE;
449     }
450
451     
452     /* Set up sig handlers  -- be sure to
453      * clear all of these in run() */
454     signal(SIGUSR1, halt_signal);
455     signal(SIGUSR2, reboot_signal);
456     signal(SIGINT, reboot_signal);
457     signal(SIGTERM, reboot_signal);
458
459     /* Turn off rebooting via CTL-ALT-DEL -- we get a 
460      * SIGINT on CAD so we can shut things down gracefully... */
461 #ifndef DEBUG_INIT
462     reboot(RB_DISABLE_CAD);
463 #endif 
464
465     /* Figure out where the default console should be */
466     console_init();
467
468     /* Close whatever files are open, and reset the console. */
469     close(0);
470     close(1);
471     close(2);
472     set_term(0);
473     setsid();
474
475     /* Make sure PATH is set to something sane */
476     putenv(PATH_DEFAULT);
477
478    
479     /* Hello world */
480 #ifndef DEBUG_INIT
481     message(CONSOLE|LOG, hello_msg_format, BB_VER, BB_BT);
482 #else
483     message(CONSOLE|LOG, hello_msg_format, getpid(), BB_VER, BB_BT);
484 #endif
485
486     
487     /* Mount /proc */
488     if (mount ("proc", "/proc", "proc", 0, 0) == 0) {
489         message(CONSOLE|LOG, "Mounting /proc: done.\n");
490         kernel_version = get_kernel_revision();
491     } else
492         message(CONSOLE|LOG, "Mounting /proc: failed!\n");
493
494     /* Make sure there is enough memory to do something useful. */
495     check_memory();
496
497
498     /* Make sure an init script exists before trying to run it */
499     if (run_rc == TRUE && stat(INITSCRIPT, &statbuf)==0) {
500         wait_for_enter = FALSE;
501         tty0_command = rc_script_command;
502     }
503
504
505     /* Ok, now launch the rc script and/or prepare to 
506      * start up some VTs if somebody hits enter... 
507      */
508     for (;;) {
509         pid_t wpid;
510         int status;
511
512         if (pid1 == 0 && tty0_command) {
513             pid1 = run(tty0_command, console, wait_for_enter);
514         }
515         if (pid2 == 0 && tty1_command && second_console) {
516             pid2 = run(tty1_command, second_console, TRUE);
517         }
518         wpid = wait(&status);
519         if (wpid > 0 ) {
520             message(LOG, "pid %d exited, status=%x.\n", wpid, status);
521         }
522         /* Don't respawn init script if it exits */
523         if (wpid == pid1) {
524             if (run_rc == FALSE) {
525                 pid1 = 0;
526             }
527 #ifdef BB_CONSOLE_CMD_IF_RC_SCRIPT_EXITS
528             else {
529                 pid1 = 0;
530                 run_rc=FALSE;
531                 wait_for_enter=TRUE;
532                 tty0_command=rc_exit_command;
533             }
534 #endif
535         }
536         if (wpid == pid2) {
537             pid2 = 0;
538         }
539         sleep(1);
540     }
541 }