Linux-2

Transcription

1 ... 2 INIT... 4 INIT /ETC/INITTAB INIT INIT PROCESS INIT init init init INITTAB ACTION Shutdown

2 init Unix init /sbin/init init process Unix init init root init run level init process root Ctrl-Alt-Del init daemon kill myrun::ondemand:/home/wzhou/mydaemon /home/wzhou/mydaemon kill init process init process

3

4 init init process /etc/inittab /etc/inittab ~]$ cat /etc/inittab # # inittab This file describes how the INIT process should set up # the system in a certain run-level. # # Author: Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org> # Modified for RHS Linux by Marc Ewing and Donnie Barnes # # Default runlevel. The runlevels used by RHS are: # 0 - halt (Do NOT set initdefault to this) # 1 - Single user mode # 2 - Multiuser, without NFS (The same as 3, if you do not have networking) # 3 - Full multiuser mode # 4 - unused # 5 - X11 # 6 - reboot (Do NOT set initdefault to this) # id:5:initdefault: # System initialization. si::sysinit:/etc/rc.d/rc.sysinit l0:0:wait:/etc/rc.d/rc 0 l1:1:wait:/etc/rc.d/rc 1 l2:2:wait:/etc/rc.d/rc 2 l3:3:wait:/etc/rc.d/rc 3

5 l4:4:wait:/etc/rc.d/rc 4 l5:5:wait:/etc/rc.d/rc 5 l6:6:wait:/etc/rc.d/rc 6 # Trap CTRL-ALT-DELETE ca::ctrlaltdel:/sbin/shutdown -t3 -r now # When our UPS tells us power has failed, assume we have a few minutes # of power left. Schedule a shutdown for 2 minutes from now. # This does, of course, assume you have powerd installed and your # UPS connected and working correctly. pf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" # If power was restored before the shutdown kicked in, cancel it. pr:12345:powerokwait:/sbin/shutdown -c "Power Restored; Shutdown Cancelled" # Run gettys in standard runlevels 1:2345:respawn:/sbin/mingetty tty1 2:2345:respawn:/sbin/mingetty tty2 3:2345:respawn:/sbin/mingetty tty3 4:2345:respawn:/sbin/mingetty tty4 5:2345:respawn:/sbin/mingetty tty5 6:2345:respawn:/sbin/mingetty tty6 # Run xdm in runlevel 5 x:5:respawn:/etc/x11/prefdm -nodaemon id:5:initdefault: run level 5 X Window Full multiuser mode si::sysinit:/etc/rc.d/rc.sysinit sysinit (run level) /etc/rc.d/rc.sysinit init/main.c start_kernel() /etc/rc.d/rc.sysinit

6 l0:0:wait:/etc/rc.d/rc 0 l1:1:wait:/etc/rc.d/rc 1 l2:2:wait:/etc/rc.d/rc 2 l3:3:wait:/etc/rc.d/rc 3 l4:4:wait:/etc/rc.d/rc 4 l5:5:wait:/etc/rc.d/rc 5 l6:6:wait:/etc/rc.d/rc 6 run level 0 /etc/rc.d/rc run level 1 /etc/rc.d/rc run level 2 /etc/rc.d/rc run level 3 /etc/rc.d/rc run level 4 /etc/rc.d/rc run level 5 /etc/rc.d/rc run level 6 /etc/rc.d/rc /etc/rc.d/rc ca::ctrlaltdel:/sbin/shutdown -t3 -r now run level root Ctrl+Alt+Del /sbin/shutdown -t3 -r now init Ctrl+Alt+Del shutdown (now) warning 3 # When our UPS tells us power has failed, assume we have a few minutes # of power left. Schedule a shutdown for 2 minutes from now. # This does, of course, assume you have powerd installed and your # UPS connected and working correctly. pf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" # If power was restored before the shutdown kicked in, cancel it. pr:12345:powerokwait:/sbin/shutdown -c "Power Restored; Shutdown Cancelled" powerokwait /sbin/shutdown -c "Power Restored; Shutdown Cancelled" # Run gettys in standard runlevels 1:2345:respawn:/sbin/mingetty tty1 2:2345:respawn:/sbin/mingetty tty2 3:2345:respawn:/sbin/mingetty tty3

7 4:2345:respawn:/sbin/mingetty tty4 5:2345:respawn:/sbin/mingetty tty5 6:2345:respawn:/sbin/mingetty tty6 /sbin/mingetty # Run xdm in runlevel 5 x:5:respawn:/etc/x11/prefdm -nodaemon

8 run level 5 /etc/x11/prefdm nodaemon inittab init process init process initdefault sysinit /etc/rc.d/rc.sysinit identifier l5 l5:5:wait:/etc/rc.d/rc 5 init process wait init process inittab action /etc/rc.d/rc 5 6 action 1:2345:respawn:/sbin/mingetty tty1 2:2345:respawn:/sbin/mingetty tty2 3:2345:respawn:/sbin/mingetty tty3 4:2345:respawn:/sbin/mingetty tty4 5:2345:respawn:/sbin/mingetty tty5 6:2345:respawn:/sbin/mingetty tty6 6 run level init process /sbin/mingetty tty5 respawn /sbin/mingetty /sbin/mingetty /sbin/mingetty tty1 /etc/x11/prefdm nodaemon ca::ctrlaltdel:/sbin/shutdown -t3 -r now pf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" pr:12345:powerokwait:/sbin/shutdown -c "Power Restored; Shutdown Cancelled" root Ctrl-Alt-Del init process /sbin/shutdown -t3 -r now UPS /sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" UPS /sbin/shutdown -c "Power Restored; Shutdown Cancelled" init process root Ctrl-Alt-Del UPS Unix signal init process signal

9 init init init man init man inittab init process NAME init, telinit - process control initialization SYNOPSIS /sbin/init [ -a ] [ -s ] [ -b ] [ -z xxx ] [ Ss ] /sbin/telinit [ -t sec ] [ sSQqabcUu ] DESCRIPTION Init Init is the parent of all processes. Its primary role is to create processes from a script stored in the file /etc/inittab (see inittab(5)). This file usually has entries which cause init to spawn gettys on each line that users can log in. It also controls autonomous processes required by any particular system. RUNLEVELS A runlevel is a software configuration of the system which allows only a selected group of processes to exist. The processes spawned by init for each of these runlevels are defined in the /etc/inittab file. Init can be in one of eight runlevels: 0â 6 and S or s. The runlevel is changed by having a privileged user run telinit, which sends appropriate signals to init, telling it which runlevel to change to.

10 Runlevels 0, 1, and 6 are reserved. Runlevel 0 is used to halt the system, runlevel 6 is used to reboot the system, and runlevel 1 is used to get the system down into single user mode. Runlevel S is not really meant to be used directly, but more for the scripts that are executed when entering runlevel 1. For more information on this, see the manpages for shutdown(8) and inittab(5). Runlevels 7-9 are also valid, though not really documented. This is because "traditional" Unix variants donâ t use them. In case youâ re curious, runlevels S and s are in fact the same. Internally they are aliases for the same runlevel. BOOTING After init is invoked as the last step of the kernel boot sequence, it looks for the file /etc/inittab to see if there is an entry of the type initdefault (see inittab(5)). The initdefault entry determines the initial runlevel of the system. If there is no such entry (or no /etc/inittab at all), a runlevel must be entered at the system console. Runlevel S or s bring the system to single user mode and do not require an /etc/inittab file. In single user mode, a root shell is opened on /dev/console. When entering single user mode, init initializes the consoles stty settings to sane values. Clocal mode is set. Hardware speed and handshaking are not changed. When entering a multi-user mode for the first time, init performs the boot and bootwait entries to allow file systems to be mounted before users can log in. Then all entries matching the runlevel are processed. When starting a new process, init first checks whether the file /etc/initscript exists. If it does, it uses this script to start the process. Each time a child terminates, init records the fact and the reason it died in /var/run/utmp and /var/log/wtmp, provided that these files exist.

11 CHANGING RUNLEVELS After it has spawned all of the processes specified, init waits for one of its descendant processes to die, a powerfail signal, or until it is signaled by telinit to change the systemâ s runlevel. When one of the above three conditions occurs, it re-examines the /etc/inittab file. New entries can be added to this file at any time. However, init still waits for one of the above three conditions to occur. To provide for an instantaneous response, the telinit Q or q command can wake up init to re-examine the /etc/inittab file. TELINIT If init is not in single user mode and receives a powerfail signal (SIGPWR), it reads the file /etc/powerstatus. It then starts a command based on the contents of this file: F(AIL) Power is failing, UPS is providing the power. Execute the powerwait and powerfail entries. O(K) The power has been restored, execute the powerokwait entries. L(OW) The power is failing and the UPS has a low battery. Execute the powerfailnow entries. If /etc/powerstatus doesnâ t exist or contains anything else then the letters F, O or L, init will behave as if it has read the letter F. Usage of SIGPWR and /etc/powerstatus is discouraged. Someone wanting to interact with init should use the /dev/initctl control channel - see the source code of the sysvinit package for more documentation about this. When init is requested to change the runlevel, it sends the warning signal SIGTERM to all processes that are undefined in the new runlevel. It then waits 5 seconds before forcibly terminating these processes via the SIGKILL signal. Note that init assumes that all these processes (and their descendants) remain in the same process group which init originally created for them. If any process changes its process group affiliation it will not receive these signals. Such processes need to be terminated separately.

12 /sbin/telinit is linked to /sbin/init. It takes a one-character argument and signals init to perform the appropriate action. The following arguments serve as directives to telinit: 0,1,2,3,4,5 or 6 tell init to switch to the specified run level. a,b,c tell init to process only those /etc/inittab file entries having runlevel a,b or c. Q or q tell init to re-examine the /etc/inittab file. S or s tell init to switch to single user mode. U or u tell init to re-execute itself (preserving the state). No re-examining of /etc/inittab file happens. Run level should be one of Ss12345, otherwise request would be silently ignored. telinit can also tell init how long it should wait between sending processes the SIGTERM and SIGKILL signals. The default is 5 seconds, but this can be changed with the -t sec option. telinit can be invoked only by users with appropriate privileges. The init binary checks if it is init or telinit by looking at its process id; the real initâ s process id is always 1. From this it follows that instead of calling telinit one can also just use init instead as a shortcut. ENVIRONMENT Init sets the following environment variables for all its children: PATH /usr/local/sbin:/sbin:/bin:/usr/sbin:/usr/bin INIT_VERSION As the name says. Useful to determine if a script runs directly from init.

13 RUNLEVEL The current system runlevel. PREVLEVEL The previous runlevel (useful after a runlevel switch). CONSOLE The system console. This is really inherited from the kernel; however if it is not set init will set it to /dev/console by default. BOOTFLAGS It is possible to pass a number of flags to init from the boot monitor (eg. LILO). Init accepts the following flags: -s, S, single Single user mode boot. In this mode /etc/inittab is examined and the bootup rc scripts are usually run before the single user mode shell is started. 1-5 Runlevel to boot into. -b, emergency Boot directly into a single user shell without running any other startup scripts. -a, auto The LILO boot loader adds the word "auto" to the command line if it booted the kernel with the default command line (without user intervention). If this is found init sets the "AUTOBOOT" environment variable to "yes". Note that you cannot use this for any security measures - of course the user could specify "auto" or -a on the command line manually. -z xxx The argument to -z is ignored. You can use this to expand the command line a bit, so that it takes some more space on the stack. Init can then manipulate the command line so that ps(1) shows the current runlevel.

14 INTERFACE Init listens on a fifo in /dev, /dev/initctl, for messages. Telinit uses this to communicate with init. The interface is not very well documented or finished. Those interested should study the initreq.h file in the src/ subdirectory of the init source code tar archive. SIGNALS Init reacts to several signals: SIGHUP Has the same effect as telinit q. SIGUSR1 On receipt of this signals, init closes and re-opens its control fifo, /dev/initctl. Useful for bootscripts when /dev is remounted. SIGINT Normally the kernel sends this signal to init when CTRL-ALT-DEL is pressed. It activates the ctrlaltdel action. SIGWINCH The kernel sends this signal when the KeyboardSignal key is hit. It activates the kbrequest action. CONFORMING TO Init is compatible with the System V init. It works closely together with the scripts in the directories /etc/init.d and /etc/rc{runlevel}.d. If your system uses this convention, there should be a README file in the directory /etc/init.d explaining how these scripts work. FILES /etc/inittab /etc/initscript /dev/console /var/run/utmp /var/log/wtmp /dev/initctl

15 WARNINGS Init assumes that processes and descendants of processes remain in the same process group which was originally created for them. If the processes change their group, init canâ t kill them and you may end up with two processes reading from one terminal line. DIAGNOSTICS If init finds that it is continuously respawning an entry more than 10 times in 2 minutes, it will assume that there is an error in the command string, generate an error message on the system console, and refuse to respawn this entry until either 5 minutes has elapsed or it receives a signal. This prevents it from eating up system resources when someone makes a typographical error in the /etc/inittab file or the program for the entry is removed. AUTHOR Miquel van Smoorenburg (miquels@cistron.nl), initial manual page by Michael Haardt (u31b3hs@pool.informatik.rwth-aachen.de). SEE ALSO getty(1), login(1), sh(1), runlevel(8), shutdown(8), kill(1), inittab(5), initscript(5), utmp(5) 18 April 2003 INIT(8) /etc/inittab INITTAB(5) Linux System Administrator's Manual INITTAB(5) NAME inittab - format of the inittab file used by the sysv-compatible init process DESCRIPTION The inittab file describes which processes are started at bootup and during normal operation (e.g. /etc/init.d/boot, /etc/init.d/rc, gettys...). Init(8) distinguishes multiple runlevels,

16 each of which can have its own set of processes that are started. Valid runlevels are 0-6 plus A, B, and C for ondemand entries. An entry in the inittab file has the following format: id:runlevels:action:process Lines beginning with '#' are ignored. id is a unique sequence of 1-4 characters which identifies an entry in inittab (for versions of sysvinit compiled with the old libc5 (< ) or a.out libraries the limit is 2 characters). Note: traditionally, for getty and other login processes, the value of the id field is kept the same as the suffix of the corresponding tty, e.g. 1 for tty1. Some ancient login accounting programs might expect this, though I can't think of any. runlevels lists the runlevels for which the specified action should be taken. action describes which action should be taken. process specifies the process to be executed. If the process field starts with a '+' character, init will not do utmp and wtmp accounting for that process. This is needed for gettys that insist on doing their own utmp/wtmp housekeeping. This is also a historic bug. The runlevels field may contain multiple characters for different runlevels. For example, 123 specifies that the process should be started in runlevels 1, 2, and 3. The runlevels for ondemand entries may contain an A, B, or C. The runlevels field of sysinit, boot, and bootwait entries are ignored. When the system runlevel is changed, any running processes that are not specified for the new runlevel are killed, first with SIGTERM, then with SIGKILL. Valid actions for the action field are: respawn The process will be restarted whenever it terminates (e.g. getty).

17 wait The process will be started once when the specified runlevel is entered and init will wait for its termination. once The process will be executed once when the specified runlevel is entered. boot The process will be executed during system boot. The runlevels field is ignored. bootwait The process will be executed during system boot, while init waits for its termination (e.g. /etc/rc). The runlevels field is ignored. off This does nothing. ondemand 1 A process marked with an ondemand runlevel will be executed whenever the specified ondemand runlevel is called. However, no runlevel change will occur (ondemand runlevels are 'a', 'b', and 'c'). initdefault An initdefault entry specifies the runlevel which should be entered after system boot. If none exists, init will ask for a runlevel on the console. The process field is ignored. sysinit The process will be executed during system boot. It will be executed before any boot or bootwait entries. The runlevels field is ignored. powerwait The process will be executed when the power goes down. Init is usually informed about this by a process talking to a UPS connected to the computer. Init will wait for the process to finish before continuing. powerfail As for powerwait, except that init does not wait for the process's completion. 1 Ondemand respawn run level

18 powerokwait This process will be executed as soon as init is informormed that the power has been restored. powerfailnow This process will be executed when init is told that the battery of the external UPS is almost empty and the power is failing (provided that the external UPS and the monitoring process are able to detect this condition). ctrlaltdel The process will be executed when init receives the SIGINT signal. This means that someone on the system console has pressed the CTRL-ALT-DEL key combination. Typically one wants to execute some sort of shutdown either to get into single-user level or to reboot the machine. kbrequest The process will be executed when init receives a signal from the keyboard handler that a special key combination was pressed on the console keyboard. The documentation for this function is not complete yet; more documentation can be found in the kbd-x.xx packages (most recent was kbd-0.94 at the time of this writing). Basically you want to map some keyboard combination to the "KeyboardSignal" action. For example, to map Alt-Uparrow for this purpose use the following in your keymaps file: alt keycode 103 = KeyboardSignal EXAMPLES This is an example of a inittab which resembles the old Linux inittab: # inittab for linux id:1:initdefault: rc::bootwait:/etc/rc 1:1:respawn:/etc/getty 9600 tty1 2:1:respawn:/etc/getty 9600 tty2 3:1:respawn:/etc/getty 9600 tty3 4:1:respawn:/etc/getty 9600 tty4

19 This inittab file executes /etc/rc during boot and starts gettys on tty1-tty4. A more elaborate inittab with different runlevels (see the comments inside): # Level to run in id:2:initdefault: # Boot-time system configuration/initialization script. si::sysinit:/etc/init.d/rcs # What to do in single-user mode. ~:S:wait:/sbin/sulogin # /etc/init.d executes the S and K scripts upon change # of runlevel. # # Runlevel 0 is halt. # Runlevel 1 is single-user. # Runlevels 2-5 are multi-user. # Runlevel 6 is reboot. l0:0:wait:/etc/init.d/rc 0 l1:1:wait:/etc/init.d/rc 1 l2:2:wait:/etc/init.d/rc 2 l3:3:wait:/etc/init.d/rc 3 l4:4:wait:/etc/init.d/rc 4 l5:5:wait:/etc/init.d/rc 5 l6:6:wait:/etc/init.d/rc 6 # What to do at the "3 finger salute". ca::ctrlaltdel:/sbin/shutdown -t1 -h now # Runlevel 2,3: getty on virtual consoles # Runlevel 3: getty on terminal (ttys0) and modem (ttys1) 1:23:respawn:/sbin/getty tty1 VC linux 2:23:respawn:/sbin/getty tty2 VC linux

20 3:23:respawn:/sbin/getty tty3 VC linux 4:23:respawn:/sbin/getty tty4 VC linux S0:3:respawn:/sbin/getty -L 9600 ttys0 vt320 S1:3:respawn:/sbin/mgetty -x0 -D ttys1 FILES /etc/inittab AUTHOR Init was written by Miquel van Smoorenburg This manual page was written by Sebastian Lederer and modified by Michael Haardt SEE ALSO init(8), telinit(8)

21 init init process init process Linux Linux start_kernel() CPU C C stack start_kernel() C main() main() linker main() main() argc argv main() start_kernel() Linux init Linux /init/main.c 483 asmlinkage void init start_kernel(void) Linux 484 { 485 char * command_line; 486 extern struct kernel_param start param[], stop param[]; smp_setup_processor_id(); /* 491 * Need to run as early as possible, to initialize the 492 * lockdep hash: 493 */ 494 unwind_init();

22 495 lockdep_init(); local_irq_disable(); 498 early_boot_irqs_off(); 499 early_init_irq_lock_class(); /* 502 * Interrupts are still disabled. Do necessary setups, then 503 * enable them 504 */ 505 lock_kernel(); 506 boot_cpu_init(); 507 page_address_init(); 508 printk(kern_notice); 509 printk(linux_banner); 611 cpuset_init(); 612 taskstats_init_early(); 613 delayacct_init(); check_bugs(); acpi_early_init(); /* before LAPIC and SMP init */ /* Do the rest non- init'ed, we're now alive */ 620 rest_init(); Linux 621 } 416 static void noinline rest_init(void) 417 releases(kernel_lock) 418 { 419 kernel_thread(init, NULL, CLONE_FS CLONE_SIGHAND); 420 numa_default_policy(); Linux Windows NT 421 unlock_kernel(); Linux

23 422 init init process 423 /* 424 * The boot idle thread must execute schedule() 425 * at least one to get things moving: 426 */ 427 preempt_enable_no_resched(); 428 schedule(); 429 preempt_disable(); /* Call into cpu_idle with preempt disabled */ 432 cpu_idle(); 433 } 716 static int init(void * unused) init process 717 { 718 lock_kernel(); 719 /* 720 * init can run on any cpu. 721 */ 722 set_cpus_allowed(current, CPU_MASK_ALL); 723 /* 724 * Tell the world that we're going to be the grim 725 * reaper of innocent orphaned children. 726 * 727 * We don't want people to have to make incorrect 728 * assumptions about where in the task array this 729 * can be found. 730 */ 731 init_pid_ns.child_reaper = current; cad_pid = task_pid(current); smp_prepare_cpus(max_cpus); do_pre_smp_initcalls(); 738

24 739 smp_init(); 740 sched_init_smp(); cpuset_init_smp(); do_basic_setup(); /* 747 * check if there is an early userspace init. If yes, let it do all 748 * the work 749 */ if (!ramdisk_execute_command) 752 ramdisk_execute_command = "/init"; if (sys_access((const char user *) ramdisk_execute_command, 0)!= 0) { 755 ramdisk_execute_command = NULL; 756 prepare_namespace(); 757 } /* 760 * Ok, we have completed the initial bootup, and 761 * we're essentially up and running. Get rid of the 762 * initmem segments and start the user-mode stuff */ 764 free_initmem(); 765 unlock_kernel(); 766 mark_rodata_ro(); 767 system_state = SYSTEM_RUNNING; 768 numa_default_policy(); if (sys_open((const char user *) "/dev/console", O_RDWR, 0) < 0) 771 printk(kern_warning "Warning: unable to open an initial console.\n"); (void) sys_dup(0); 774 (void) sys_dup(0); 775

25 776 if (ramdisk_execute_command) { 777 run_init_process(ramdisk_execute_command); 778 printk(kern_warning "Failed to execute %s\n", 779 ramdisk_execute_command); 780 } /* 783 * We try each of these until one succeeds. 784 * 785 * The Bourne shell can be used instead of init if we are 786 * trying to recover a really broken machine. 787 */ 788 if (execute_command) { 789 run_init_process(execute_command); 790 printk(kern_warning "Failed to execute %s. Attempting " 791 "defaults...\n", execute_command); 792 } 793 run_init_process("/sbin/init"); run_init_process() 794 run_init_process("/etc/init"); sys_execve() 795 run_init_process("/bin/init"); init process 796 run_init_process("/bin/sh"); panic("no init found. Try passing init= option to kernel."); 799 } run_init_process 710 static void run_init_process(char *init_filename) 711 { 712 argv_init[0] = init_filename; 713 kernel_execve(init_filename, argv_init, envp_init); 714 }

26 254 /* 255 * Do a system call from kernel instead of calling sys_execve so we 256 * end up with proper pt_regs. 257 */ sys_execve 258 int kernel_execve(const char *filename, char *const argv[], char *const envp[]) 259 { 260 long res; 261 asm volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx" 262 : "=a" ( res) 263 : "0" ( NR_execve),"ri" (filename),"c" (argv), "d" (envp) : "memory"); 264 return res; 265 } init

27 Linux Linux kernel debugger Linux init process init 1 init 2 init 3 init init init run level init 1 init 1 /sbin/init 2594 /* 2595 * Main entry for init and telinit */ 2597 int main(int argc, char **argv) argc 1 argv[0] = /sbin/init 2598 { 2599 char *p; 2600 int f; 2601 int isinit; /* Get my own name */ 2604 if ((p = strrchr(argv[0], '/'))!= NULL) argv[0] = /sbin/init 2605 p++; p init 2606 else 2607 p = argv[0]; 2608 umask(022); /* Quick check */ 2611 if (geteuid()!= 0) { root init root

28 2612 fprintf(stderr, "%s: must be superuser.\n", p); 2613 exit(1); 2614 } /* 2617 * Is this telinit or init? 2618 */ 2619 isinit = (getpid() == 1); init process PID 1 isinit = true 2620 for (f = 1; f < argc; f++) { init if (!strcmp(argv[f], "-i")!strcmp(argv[f], "--init")) 2622 isinit = 1; 2623 break; 2624 } 2625 if (!isinit) exit(telinit(p, argc, argv)); init /* 2628 * Check for re-exec 2629 */ 2630 if (check_pipe(state_pipe)) { init 1 init 3 pipe 2631 init check_pipe() 2632 receive_state(state_pipe); 0 init 0 if L myname = istrdup(argv[0]); 2635 argv0 = argv[0]; 2636 maxproclen = 0; 2637 for (f = 0; f < argc; f++) 2638 maxproclen += strlen(argv[f]) + 1; 2639 reload = 1; 2640 setproctitle("init [%c]",runlevel); init_main(); 2643 } /* Check command line arguments */ init maxproclen = strlen(argv[0]) + 1; L2666

29 2647 for(f = 1; f < argc; f++) { 2648 if (!strcmp(argv[f], "single")!strcmp(argv[f], "-s")) 2649 dfl_level = 'S'; 2650 else if (!strcmp(argv[f], "-a")!strcmp(argv[f], "auto")) 2651 putenv("autoboot=yes"); 2652 else if (!strcmp(argv[f], "-b")!strcmp(argv[f],"emergency")) 2653 emerg_shell = 1; 2654 else if (!strcmp(argv[f], "-z")) { 2655 /* Ignore -z xxx */ 2656 if (argv[f + 1]) f++; 2657 } else if (strchr(" ss", argv[f][0]) 2658 && strlen(argv[f]) == 1) 2659 dfl_level = argv[f][0]; 2660 /* "init u" in the very beginning makes no sense */ 2661 if (dfl_level == 's') dfl_level = 'S'; 2662 maxproclen += strlen(argv[f]) + 1; 2663 } /* Start booting. */ 2666 argv0 = argv[0]; init 1 argv0 = /sbin/init 2667 argv[1] = NULL; 2668 setproctitle("init boot"); 2669 init_main(dfl_level); init 1 init_main(0) dfl_level /*NOTREACHED*/ 2672 return 0; 2673 } 2340 /* 2341 * The main loop 2342 */ 2343 int init_main() 2344 { 2345 CHILD *ch; 2346 struct sigaction sa; 2347 sigset_t sgt;

30 2348 pid_t rc; 2349 int f, st; if (!reload) { init 1 reload 0 if #if INITDEBUG debug init debug init 1 /sbin/init 2354 /* debugger 2355 * Fork so we can debug the init process */ 2357 if ((f = fork()) > 0) { 2358 static const char killmsg[] = "PRNT: init killed.\r\n"; 2359 pid_t rc; while((rc = wait(&st))!= f) 2362 if (rc < 0 && errno == ECHILD) 2363 break; 2364 write(1, killmsg, sizeof(killmsg) - 1); 2365 while(1) pause(); 2366 } 2367 #endif #ifdef linux init,freebsd Macro Linux 2370 /* 2371 * Tell the kernel to send us SIGINT when CTRL-ALT-DEL 2372 * is pressed, and that we want to handle keyboard signals */ 2374 init_reboot(bmagic_soft); reboot(bmagic_soft) CTRL-ALT-DEL init process SIGINT signal man 2 reboot 2375 if ((f = open(vt_master, O_RDWR O_NOCTTY)) >= 0) { 2376 (void) ioctl(f, KDSIGACCEPT, SIGWINCH); 2377 close(f); 2378 } else 2379 (void) ioctl(0, KDSIGACCEPT, SIGWINCH); 2380 #endif 2381

31 2382 /* 2383 * Ignore all signals. signal handler ignore signals 2384 */ signals handler 2385 for(f = 1; f <= NSIG; f++) 2386 SETSIG(sa, f, SIG_IGN, SA_RESTART); 2387 } 2388 signal SIGALRM SIGHUP SIGINT CTRL-ALT-DEL SIGCHLD SIGPWR SIGWINCH SIG SIGSTOP SIGTSTP SIGCONT SIGSTOP SIGSEGV init process SIGALRM SIGHUP SIGINT SIGPWR SIGWINCH SIGUSR1 signal_handler signal_handler signal got_signals init process SIGCHLD chld_handler init process chld_handler

32 init process SIGSTOP SIGTSTP stop_handler init process SIGCONT cont_handler init process SIGSEGV segv_handler init process init process process 2389 SETSIG(sa, SIGALRM, signal_handler, 0); init process signal handler 2390 SETSIG(sa, SIGHUP, signal_handler, 0); 2391 SETSIG(sa, SIGINT, signal_handler, 0); 2392 SETSIG(sa, SIGCHLD, chld_handler, SA_RESTART); 2393 SETSIG(sa, SIGPWR, signal_handler, 0); 2394 SETSIG(sa, SIGWINCH, signal_handler, 0); 2395 SETSIG(sa, SIGUSR1, signal_handler, 0); 2396 SETSIG(sa, SIGSTOP, stop_handler, SA_RESTART); 2397 SETSIG(sa, SIGTSTP, stop_handler, SA_RESTART); 2398 SETSIG(sa, SIGCONT, cont_handler, SA_RESTART); 2399 SETSIG(sa, SIGSEGV, (void (*)(int))segv_handler, SA_RESTART); signal handler SIGALRM SIGHUP SIGINT SIGPWR SIGWINCH SIGUSR1 signal_handler 543 /* 544 * We got a signal (HUP PWR WINCH ALRM INT) 545 */ 546 void signal_handler(int sig) 547 { 548 ADDSET(got_signals, sig); HUP PWR WINCH ALRM INT signal 549 } init_main() process_signals() got_signals 106 sig_atomic_t got_signals; /* Set if we received a signal. */ ADDSET #define ADDSET(set, val) ((set) = (1 << (val))) got_signals signal process_signals() 2238 void process_signals() init process SIGALRM SIGHUP SIGINT SIGPWR SIGWINCH 2239 { SIGUSR1 signal

33 2240 CHILD *ch; 2241 int pwrstat; 2242 int oldlevel; 2243 int fd; 2244 char c; if (ISMEMBER(got_signals, SIGPWR)) { SIGPWR signal UPS fail 2247 INITDBG(L_VB, "got SIGPWR"); 2248 /* See _what_ kind of SIGPWR this is. */ 2249 pwrstat = 0; 2250 if ((fd = open(pwrstat, O_RDONLY)) >= 0) { /etc/powerstatus 2251 c = 0; F O L 2252 read(fd, &c, 1); SIGPWR 2253 pwrstat = c; fail pwrstat 2254 close(fd); 2255 unlink(pwrstat); /etc/powerstatus 2256 } 2257 do_power_fail(pwrstat); powerfail family action action inittab powerfail pf::powerfail:/sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" init process /sbin/shutdown -f -h +2 "Power Failure; System Shutting Down" 2258 DELSET(got_signals, SIGPWR); got_signals SIGPWR 2259 } if (ISMEMBER(got_signals, SIGINT)) { SIGINT signal 2262 INITDBG(L_VB, "got SIGINT"); 2263 /* Tell ctrlaltdel entry to start up */ 2264 for(ch = family; ch; ch = ch->next) 2265 if (ch->action == CTRLALTDEL) 2266 ch->flags &= ~XECUTED; Ctrl-Alt-Del handler 2267 DELSET(got_signals, SIGINT); 2268 }

34 if ( ISMEMBER(got_signals, SIGWINCH) ) { 2271 INITDBG(L_VB, "got SIGWINCH"); 2272 /* Tell kbrequest entry to start up */ 2273 f or(ch = family; ch; ch = ch->next) 2274 if (ch->action == KBREQUEST) 2275 ch->flags &= ~XECUTED; 2276 DELSET(got_signals, SIGWINCH); 2277 } if (ISMEMBER(got_signals, SIGALRM)) { SIGALRM signal 2280 INITDBG(L_VB, "got SIGALRM"); 2281 /* The timer went off: check it out */ 2282 DELSET(got_signals, SIGALRM); 2283 } if ( ISMEMBER(got_signals, SIGCHLD) ) { init process 2286 INITDBG(L_VB, "got SIGCHLD"); 2287 /* First set flag to 0 */ 2288 DELSET(got_signals, SIGCHLD); signal /* See which child this was */ 2291 for(ch = family; ch; ch = ch->next) family 2292 if (ch->flags & ZOMBIE) { 2293 INITDBG(L_VB, "Child died, PID= %d", ch->pid); 2294 ch->flags &= ~(RUNNING ZOMBIE WAITING); 2295 if (ch->process[0]!= '+') 2296 write_utmp_wtmp("", ch->id, ch->pid, DEAD_PROCESS, NULL); 2297 } } if ( ISMEMBER(got_signals, SIGHUP) ) { signal SIGHUP init 2302 INITDBG(L_VB, "got SIGHUP"); process inittab 2303 # if CHANGE_WAIT 2304 /* Are we waiting for a child? */

35 2305 for(ch = family; ch; ch = ch->next) 2306 if (ch->flags & WAITING) break; 2307 if (ch == NULL) 2308 #endif 2309 { 2310 /* We need to go into a new runlevel */ 2311 oldlevel = runlevel; 2312 #ifdef INITLVL 2313 runlevel = read_level(0); 2314 #endif 2315 if (runlevel == 'U') { 2316 runlevel = oldlevel; 2317 re_exec(); 2318 } else { 2319 if (oldlevel!= 'S' && runlevel == 'S') console_stty(); 2320 if (runlevel == '6' runlevel == '0' 2321 runlevel == '1') console_stty(); 2322 read_inittab(); 2323 fail_cancel(); 2324 setproctitle("init [%c]", runlevel); 2325 DELSET(got_signals, SIGHUP); 2326 } 2327 } 2328 } 2329 if (ISMEMBER(got_signals, SIGUSR1)) { signal pipe /dev/initctl 2330 /* 2331 * SIGUSR1 means close and reopen /dev/initctl 2332 */ 2333 INITDBG(L_VB, "got SIGUSR1"); 2334 close(pipe_fd); 2335 pipe_fd = -1; 2336 DELSET(got_signals, SIGUSR1); 2337 } 2338 } init_main()

36 console_init(); console if (!reload) { init 1 0 if /* Close whatever files are open, and reset the console. */ 2406 close(0); setsid() 2407 close(1); daemon process 2408 close(2); 2409 console_stty(); 2410 setsid(); /* 2413 * Set default PATH variable */ 2415 putenv(path_dfl); init 1 PATH="PATH=/bin:/usr/bin:/sbin:/usr/sbin" /* 2418 * Initialize /var/run/utmp (only works if /var is on 2419 * root and mounted rw) 2420 */ 2421 (void) close(open(utmp_file, O_WRONLY O_CREAT O_TRUNC, 0644)); /var/run/utmp /* 2424 * Say hello to the world 2425 */ 2426 initlog(l_co, bootmsg, "booting"); /* 2429 * See if we have to start an emergency shell */ 2431 if (emerg_shell) { shell init 1 if 2432 SETSIG(sa, SIGCHLD, SIG_DFL, SA_RESTART); 2433 if (spawn(&ch_emerg, &f) > 0) { 2434 while((rc = wait(&st))!= f) 2435 if (rc < 0 && errno == ECHILD)

37 2436 break; 2437 } 2438 SETSIG(sa, SIGCHLD, chld_handler, SA_RESTART); 2439 } /* 2442 * Start normal boot procedure */ 2444 runlevel = '#'; init read_inittab(); /etc/inittab } else { re-exec init process inittab init 1 L /* 2449 * Restart: unblock signals and let the show go on 2450 */ 2451 initlog(l_co, bootmsg, "reloading"); 2452 sigfillset(&sgt); 2453 sigprocmask(sig_unblock, &sgt, NULL); 2454 } 2455 start_if_needed(); family /etc/inittab action inittab while(1) { init process init process init daemon process init 2459 /* See if we need to make the boot transitions. */ 2460 boot_transitions(); 2461 INITDBG(L_VB, "init_main: waiting.."); /* Check if there are processes to be waited on. */ 2464 for(ch = family; ch; ch = ch->next) 2465 if ((ch->flags & RUNNING) && ch->action!= BOOT) break; #if CHANGE_WAIT

38 2468 /* Wait until we get hit by some signal. */ 2469 while (ch!= NULL && got_signals == 0) { daemon process 2470 if (ISMEMBER(got_signals, SIGHUP)) { SIGHUP init process inittab 2471 /* See if there are processes to be waited on. */ 2472 for(ch = family; ch; ch = ch->next) wait boot 2473 if (ch->flags & WAITING) break; 2474 } 2475 if (ch!= NULL) check_init_fifo(); 2476 } 2477 #else /* CHANGE_WAIT */ 2478 if (ch!= NULL && got_signals == 0) check_init_fifo(); 2479 #endif /* CHANGE_WAIT */ check_init_fifo() init 2 init 3 /dev/initctl pipe /* Check the 'failing' flags */ 2482 fail_check(); /* Process any signals. */ 2485 process_signals(); signal init process signal got_signals 2486 init process init process signal signal L /* See what we need to start up (again) */ 2488 start_if_needed(); family node 2489 } (action) 2490 /*NOTREACHED*/ 2491 } init process inittab Inittab init process /* Information about a process in the in-core inittab */ typedef struct _child_ { int flags; /* Status of this entry */ int exstat; /* Exit status of process */

39 int pid; /* Pid of this process */ time_t tm; /* When respawned last */ int count; /* Times respawned in the last 2 minutes */ char id[8]; /* Inittab id (must be unique) */ char rlevel[12]; /* run levels */ int action; /* what to do (see list below) */ char process[128]; /* The command line */ struct _child_ *new; /* New entry (after inittab re-read) */ struct _child_ *next; /* For the linked list */ } CHILD; Inittab 3:2345:respawn:/ sbin/mingetty tty3 init process CHILD field id[8] rlevel[12] action process[128] Respawn /sbin/mingetty tty3 flags process exstat process exit() pid process process identifier tm respawn process init process respawn count respawn ondemanded process 2 (spawn) init process process next family

40 family /etc/inittab id:5:initdefault: CHILD Node si::sysinit:/etc/rc.d/rc.sysinit CHILD Node l0:0:wait:/etc/rc.d/rc 0 CHILD Node l1:1:wait:/etc/rc.d/rc 1 l2:2:wait:/etc/rc.d/rc 2 l3:3:wait:/etc/rc.d/rc 3 l4:4:wait:/etc/rc.d/rc 4 l5:5:wait:/etc/rc.d/rc 5 l6:6:wait:/etc/rc.d/rc 6 read_inittab ca::ctrlaltdel:/sbin/shutdown -t3 -r now 3:2345:respawn:/sbin/mingetty tty3 CHILD Node N

41 1108 void read_inittab(void) 1109 { 1110 FILE *fp; /* The INITTAB file */ 1111 CHILD *ch, *old, *i; /* Pointers to CHILD structure */ 1112 CHILD *head = NULL; /* Head of linked list */ 1113 #ifdef INITLVL 1114 struct stat st; /* To stat INITLVL */ 1115 #endif 1116 sigset_t nmask, omask; /* For blocking SIGCHLD. */ 1117 char buf[256]; /* Line buffer */ 1118 char err[64]; /* Error message. */ 1119 char *id, *rlevel, 1120 *action, *process; /* Fields of a line */ 1121 char *p; 1122 int lineno = 0; /* Line number in INITTAB file */ 1123 int actionno; /* Decoded action field */ 1124 int f; /* Counter */ 1125 int round; /* round 0 for SIGTERM, 1 for SIGKILL */ 1126 int foundone = 0; /* No killing no sleep */ 1127 int talk; /* Talk to the user */ 1128 int done = 0; /* Ready yet? */ #if DEBUG 1131 if (newfamily!= NULL) { 1132 INITDBG(L_VB, "PANIC newfamily!= NULL"); 1133 exit(1); 1134 } 1135 INITDBG(L_VB, "Reading inittab"); 1136 #endif /* 1139 * Open INITTAB and real line by line */ 1141 if ((fp = fopen(inittab, "r")) == NULL) /etc/inittab 1142 initlog(l_vb, "No inittab file found"); 1143

42 1144 while(!done) { inittab newfamily newfamily 1145 /* family 1146 * Add single user shell entry at the end */ 1148 if (fp == NULL fgets(buf, sizeof(buf), fp) == NULL) { 1149 done = 1; 1150 /* 1151 * See if we have a single user entry */ 1153 for(old = newfamily; old; old = old->next) 1154 if (strpbrk(old->rlevel, "S")) break; 1155 if (old == NULL) 1156 snprintf(buf, sizeof(buf), "~~:S:wait:%s\n", SULOGIN); 1157 else 1158 continue; 1159 } 1160 lineno++; 1161 /* 1162 * Skip comments and empty lines 1163 */ 1164 for(p = buf; *p == ' ' *p == '\t'; p++) 1165 ; 1166 if (*p == '#' *p == '\n') continue; # /* 1169 * Decode the fields 1170 */ id:runlevels:action:process id = strsep(&p, ":"); : strsep 1172 rlevel = strsep(&p, ":"); 1173 action = strsep(&p, ":"); 1174 process = strsep(&p, "\n"); 1175 init manual /* 1177 * Check if syntax is OK. Be very verbose here, to

43 1178 * avoid newbie postings on comp.os.linux.setup :) 1179 */ 1180 err[0] = 0; 1181 if (!id!*id) strcpy(err, "missing id field"); 1182 if (!rlevel) strcpy(err, "missing runlevel field"); 1183 if (!process) strcpy(err, "missing process field"); 1184 if (!action!*action) 1185 strcpy(err, "missing action field"); 1186 if (id && strlen(id) > sizeof(utproto.ut_id)) 1187 sprintf(err, "id field too long (max %d characters)", 1188 (int)sizeof(utproto.ut_id)); 1189 if (rlevel && strlen(rlevel) > 11) 1190 strcpy(err, "rlevel field too long (max 11 characters)"); 1191 if (process && strlen(process) > 127) 1192 strcpy(err, "process field too long"); 1193 if (action && strlen(action) > 32) 1194 strcpy(err, "action field too long"); 1195 if (err[0]!= 0) { 1196 initlog(l_vb, "%s[%d]: %s", INITTAB, lineno, err); 1197 INITDBG(L_VB, "%s:%s:%s:%s", id, rlevel, action, process); 1198 continue; 1199 } /* 1202 * Decode the "action" field 1203 */ init action actions[] identifier 1204 actionno = -1; 1205 for(f = 0; actions[f].name; f++) 1206 if (strcasecmp(action, actions[f].name) == 0) { 1207 actionno = actions[f].act; 1208 break; 1209 } 1210 if (actionno == -1) { action( actions[] ) 1211 initlog(l_vb, "%s[%d]: %s: unknown action field", 1212 INITTAB, lineno, action); 1213 continue;

44 1214 } /* 1217 * See if the id field is unique 1218 */ identifier CHILD id /etc/inittab id 1219 for(old = newfamily; old; old = old->next) { 1220 if(strcmp(old->id, id) == 0 && strcmp(id, "~~")) { 1221 initlog(l_vb, "%s[%d]: duplicate ID field \"%s\"", 1222 INITTAB, lineno, id); 1223 break; 1224 } 1225 } 1226 if (old) continue; /* 1229 * Allocate a CHILD structure 1230 */ 1231 ch = imalloc(sizeof(child)); CHILD node /* 1234 * And fill it in. CHILD node 1235 */ 1236 ch->action = actionno; action 1237 strncpy(ch->id, id, sizeof(utproto.ut_id) + 1); /* Hack for different libs. */ 1238 strncpy(ch->process, process, sizeof(ch->process) - 1); 1239 if (rlevel[0]) { run level 1240 for(f = 0; f < sizeof(rlevel) - 1 && rlevel[f]; f++) { 1241 ch->rlevel[f] = rlevel[f]; 1242 if (ch->rlevel[f] == 's') ch->rlevel[f] = 'S'; 1243 } 1244 strncpy(ch->rlevel, rlevel, sizeof(ch->rlevel) - 1);

45 1245 } else { run level run level process 1246 strcpy(ch->rlevel, " "); 1247 if (ISPOWER(ch->action)) 1248 strcpy(ch->rlevel, "S "); 1249 } action 1250 /* 1251 * We have the fake runlevel '#' for SYSINIT and 1252 * '*' for BOOT and BOOTWAIT */ SYSINIT action '#' BOOT action '*' run level 0 9 'S' # * run level SYSINIT BOOT action 1254 if (ch->action == SYSINIT) strcpy(ch->rlevel, "#"); 1255 if (ch->action == BOOT ch->action == BOOTWAIT) 1256 strcpy(ch->rlevel, "*"); /* 1259 * Now add it to the linked list. Special for powerfail */ /etc/inittab newfamily family init run level family init /etc/inittab 1261 if (ISPOWER(ch->action)) { action POWERWAIT POWERFAIL POWEROKWAIT 1262 POWERFAILNOW CTRLALTDEL Ctrl+Alt+Del 1263 /* 1264 * Disable by default 1265 */ 1266 ch->flags = XECUTED; startup() action flag 1267 XECUTED 1268 /* Ctrl+Alt+Del /etc/inittab CTRLALTDEL

46 Action process disable ( XECUTED ) Ctrl+Alt+Del enable action family 1269 * Tricky: insert at the front of the list */ 1271 old = NULL; 1272 for(i = newfamily; i; i = i->next) { 1273 if (!ISPOWER(i->action)) break; 1274 old = i; 1275 } 1276 /* 1277 * Now add after entry "old" 1278 */ 1279 if (old) { 1280 ch->next = i; 1281 old->next = ch; 1282 if (i == NULL) head = ch; 1283 } else { 1284 ch->next = newfamily; 1285 newfamily = ch; 1286 if (ch->next == NULL) head = ch; 1287 } 1288 } else { action KBREQUEST SIGWINCH 1289 /* 1290 * Just add at end of the list 1291 */ 1292 if (ch->action == KBREQUEST) ch->flags = XECUTED; 1293 ch->next = NULL; 1294 if (head) 1295 head->next = ch; 1296 else 1297 newfamily = ch; 1298 head = ch; 1299 } 1300

47 1301 /* 1302 * Walk through the old list comparing id fields 1303 */ 1304 for(old = family; old; old = old->next) 1305 if (strcmp(old->id, ch->id) == 0) { 1306 old->new = ch; 1307 break; 1308 } 1309 } 1310 /* 1311 * We're done */ 1313 if (fp) fclose(fp); /etc/inittab init daemon init init 3 kernel init(init 1) daemon init init /* 1316 * Loop through the list of children, and see if they need to 1317 * be killed */ INITDBG(L_VB, "Checking for children to kill"); 1321 for(round = 0; round < 2; round++) { 1322 talk = 1; 1323 for(ch = family; ch; ch = ch->next) { init init 1 family 1324 ch->flags &= ~KILLME; round = 0 talk = 1 foundone = L /* 1327 * Is this line deleted? 1328 */ 1329 if (ch->new == NULL) ch->flags = KILLME;

48 /* 1332 * If the entry has changed, kill it anyway. Note that 1333 * we do not check ch->process, only the "action" field * This way, you can turn an entry "off" immediately, but 1335 * changes in the command line will only become effective 1336 * after the running version has exited */ 1338 if (ch->new && ch->action!= ch->new->action) ch->flags = KILLME; /* 1341 * Only BOOT processes may live in all levels 1342 */ 1343 if (ch->action!= BOOT && 1344 strchr(ch->rlevel, runlevel) == NULL) { 1345 /* 1346 * Ondemand procedures live always, 1347 * except in single user 1348 */ 1349 if (runlevel == 'S'!(ch->flags & DEMAND)) 1350 ch->flags = KILLME; 1351 } /* 1354 * Now, if this process may live note so in the new list 1355 */ 1356 if ((ch->flags & KILLME) == 0) { 1357 ch->new->flags = ch->flags; 1358 ch->new->pid = ch->pid; 1359 ch->new->exstat = ch->exstat; 1360 continue; 1361 } /* 1365 * Is this process still around? 1366 */

49 1367 if ((ch->flags & RUNNING) == 0) { 1368 ch->flags &= ~KILLME; 1369 continue; 1370 } 1371 INITDBG(L_VB, "Killing \"%s\"", ch->process); 1372 switch(round) { 1373 case 0: /* Send TERM signal */ 1374 if (talk) 1375 initlog(l_co, 1376 "Sending processes the TERM signal"); 1377 kill(-(ch->pid), SIGTERM); 1378 foundone = 1; 1379 break; 1380 case 1: /* Send KILL signal and collect status */ 1381 if (talk) 1382 initlog(l_co, 1383 "Sending processes the KILL signal"); 1384 kill(-(ch->pid), SIGKILL); 1385 break; 1386 } 1387 talk = 0; } 1390 /* 1391 * See if we have to wait 5 seconds 1392 */ 1393 if (foundone && round == 0) { init init 1 round = 0, foundone = /* if L * Yup, but check every second if we still have children */ 1397 for(f = 0; f < sltime; f++) { 1398 for(ch = family; ch; ch = ch->next) { 1399 if (!(ch->flags & KILLME)) continue; 1400 if ((ch->flags & RUNNING) &&!(ch->flags & ZOMBIE)) 1401 break; 1402 } 1403 if (ch == NULL) {

50 1404 /* 1405 * No running children, skip SIGKILL 1406 */ 1407 round = 1; 1408 foundone = 0; /* Skip the sleep below. */ 1409 break; 1410 } 1411 do_sleep(1); 1412 } 1413 } 1414 } /* 1417 * Now give all processes the chance to die and collect exit statuses */ 1419 if (foundone) do_sleep(1); init 1 foundone = for(ch = family; ch; ch = ch->next) family L if (ch->flags & KILLME) { 1422 if (!(ch->flags & ZOMBIE)) 1423 initlog(l_co, "Pid %d [id %s] seems to hang", ch->pid, 1424 ch->id); 1425 else { 1426 INITDBG(L_VB, "Updating utmp for pid %d [id %s]", 1427 ch->pid, ch->id); 1428 ch->flags &= ~RUNNING; 1429 if (ch->process[0]!= '+') 1430 write_utmp_wtmp("", ch->id, ch->pid, DEAD_PROCESS, NULL); 1431 } 1432 } /* 1435 * Both rounds done; clean up the list */ 1437 sigemptyset(&nmask); 1438 sigaddset(&nmask, SIGCHLD); 1439 sigprocmask(sig_block, &nmask, &omask); 1440 for(ch = family; ch; ch = old) { init 1 family L1444

51 1441 old = ch->next; 1442 free(ch); 1443 } 1444 family = newfamily; newfamily 1445 for(ch = family; ch; ch = ch->next) ch->new = NULL; 1446 newfamily = NULL; 1447 sigprocmask(sig_setmask, &omask, NULL); #ifdef INITLVL 1450 /* 1451 * Dispose of INITLVL file */ /etc/initrunlvl symbol link 1453 if (lstat(initlvl, &st) >= 0 && S_ISLNK(st.st_mode)) { /etc/initrunlvl symbol link 1454 /* 1455 * INITLVL is a symbolic link, so just truncate the file */ 1457 close(open(initlvl, O_WRONLY O_TRUNC)); 1458 } else { 1459 /* 1460 * Delete INITLVL file */ 1462 unlink(initlvl); 1463 } 1464 #endif 1465 #ifdef INITLVL /* 1467 * Dispose of INITLVL2 file */ /var/log/initrunlvl symbol link 1469 if (lstat(initlvl2, &st) >= 0 && S_ISLNK(st.st_mode)) { 1470 /* 1471 * INITLVL2 is a symbolic link, so just truncate the file */ 1473 close(open(initlvl2, O_WRONLY O_TRUNC)); 1474 } else { 1475 /*

52 1476 * Delete INITLVL2 file */ 1478 unlink(initlvl2); 1479 } 1480 #endif 1481 } init 1 read_inittab() L1313 daemon init 3 init 3 inittab CHILD node family init process start_if_needed() 1483 /* 1484 * Walk through the family list and start up children * The entries that do not belong here at all are removed 1486 * from the list */ family CHILD process[128] 1488 void start_if_needed(void) 1489 { 1490 CHILD *ch; /* Pointer to child */ 1491 int delete; /* Delete this entry from list? */ INITDBG(L_VB, "Checking for children to start"); read_inittab() /etc/inittab family node for(ch = family; ch; ch = ch->next) { #if DEBUG 1498 if (ch->rlevel[0] == 'C') { 1499 INITDBG(L_VB, "%s: flags %d", ch->process, ch->flags);

53 1500 } 1501 #endif /* Are we waiting for this process? Then quit here. */ 1504 if (ch->flags & WAITING) break; WAITING init process 1505 process 1506 /* Already running? OK, don't touch it */ 1507 if (ch->flags & RUNNING) continue; node process running /* See if we have to start it up */ 1510 delete = 1; 1511 if (strchr(ch->rlevel, runlevel) runlevel DEMAND( ) #*Ss sysinit boot action ( #*Ss run level ) 1512 ((ch->flags & DEMAND) &&!strchr("#*ss", runlevel))) { 1513 startup(ch); 1514 delete = 0; node clear 1515 } if (delete) { node level 1518 /* FIXME: is this OK? */ 1519 ch->flags &= ~(RUNNING WAITING); 1520 if (!ISPOWER(ch->action) && ch->action!= KBREQUEST) 1521 ch->flags &= ~XECUTED; 1522 ch->pid = 0; 1523 } else 1524 /* Do we have to wait for this process? */ 1525 if (ch->flags & WAITING) break; 1526 } 1527 /* Done. */ 1528 }

54 1063 /* 1064 * Start a child running! 1065 */ CHILD l2:2:wait:/etc/rc.d/rc 2 /etc/rc.d/rc 2 /etc/rc.d/rc void startup(child *ch) 1067 { 1068 /* 1069 * See if it's disabled 1070 */ 1071 if (ch->flags & FAILING) return; switch(ch->action) { case SYSINIT: 1076 case BOOTWAIT: 1077 case WAIT: 1078 case POWERWAIT: 1079 case POWERFAILNOW: 1080 case POWEROKWAIT: 1081 case CTRLALTDEL: 1082 if (!(ch->flags & XECUTED)) ch->flags = WAITING; action XECUTED WAITING spawn() WAITING 1083 case KBREQUEST:

55 1084 case BOOT: 1085 case POWERFAIL: 1086 case ONCE: 1087 if (ch->flags & XECUTED) break; XECUTED 1088 case ONDEMAND: 1089 case RESPAWN: 1090 ch->flags = RUNNING; 1091 if (spawn(ch, &(ch->pid)) < 0) break; ch->pid pid spawn() 1092 /* 1093 * Do NOT log if process field starts with '+' 1094 * FIXME: that's for compatibility with *very* 1095 * old getties - probably it can be taken out */ 1097 if (ch->process[0]!= '+') 1098 write_utmp_wtmp("", ch->id, ch->pid, 1099 INIT_PROCESS, ""); 1100 break; 1101 } 1102 } spawn launch CHILD process[128] 823 /* 824 * Fork and execute. 825 * 826 * This function is too long and indents too deep. 827 * 828 */ ch *res pid /etc/inittab si::sysinit:/etc/rc.d/rc.sysinit CHILD *ch ch->id = si