xref: /illumos-gate/usr/src/cmd/init/init.c (revision a28480fe)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
505b96de2Smjnelson  * Common Development and Distribution License (the "License").
605b96de2Smjnelson  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2105b96de2Smjnelson 
227c478bd9Sstevel@tonic-gate /*
23*a28480feSAndy Fiddaman  * Copyright 2021 OmniOS Community Edition (OmniOSce) Association.
246112cec5SJoshua M. Clulow  * Copyright 2020 Oxide Computer Company
250a1278f2SGary Mills  * Copyright (c) 2013 Gary Mills
260a1278f2SGary Mills  *
27861a9162SJohn Beck  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
287c478bd9Sstevel@tonic-gate  */
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
31*a28480feSAndy Fiddaman /*	  All Rights Reserved	*/
327c478bd9Sstevel@tonic-gate 
337c478bd9Sstevel@tonic-gate /*
347c478bd9Sstevel@tonic-gate  * University Copyright- Copyright (c) 1982, 1986, 1988
357c478bd9Sstevel@tonic-gate  * The Regents of the University of California
367c478bd9Sstevel@tonic-gate  * All Rights Reserved
377c478bd9Sstevel@tonic-gate  *
387c478bd9Sstevel@tonic-gate  * University Acknowledgment- Portions of this document are derived from
397c478bd9Sstevel@tonic-gate  * software developed by the University of California, Berkeley, and its
407c478bd9Sstevel@tonic-gate  * contributors.
417c478bd9Sstevel@tonic-gate  */
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate /*
447c478bd9Sstevel@tonic-gate  * init(1M) is the general process spawning program.  Its primary job is to
457c478bd9Sstevel@tonic-gate  * start and restart svc.startd for smf(5).  For backwards-compatibility it also
467c478bd9Sstevel@tonic-gate  * spawns and respawns processes according to /etc/inittab and the current
477c478bd9Sstevel@tonic-gate  * run-level.  It reads /etc/default/inittab for general configuration.
487c478bd9Sstevel@tonic-gate  *
497c478bd9Sstevel@tonic-gate  * To change run-levels the system administrator runs init from the command
507c478bd9Sstevel@tonic-gate  * line with a level name.  init signals svc.startd via libscf and directs the
517c478bd9Sstevel@tonic-gate  * zone's init (pid 1 in the global zone) what to do by sending it a signal;
527c478bd9Sstevel@tonic-gate  * these signal numbers are commonly refered to in the code as 'states'.  Valid
537c478bd9Sstevel@tonic-gate  * run-levels are [sS0123456].  Additionally, init can be given directives
547c478bd9Sstevel@tonic-gate  * [qQabc], which indicate actions to be taken pertaining to /etc/inittab.
557c478bd9Sstevel@tonic-gate  *
567c478bd9Sstevel@tonic-gate  * When init processes inittab entries, it finds processes that are to be
577c478bd9Sstevel@tonic-gate  * spawned at various run-levels.  inittab contains the set of the levels for
587c478bd9Sstevel@tonic-gate  * which each inittab entry is valid.
597c478bd9Sstevel@tonic-gate  *
607c478bd9Sstevel@tonic-gate  * State File and Restartability
617c478bd9Sstevel@tonic-gate  *   Premature exit by init(1M) is handled as a special case by the kernel:
627c478bd9Sstevel@tonic-gate  *   init(1M) will be immediately re-executed, retaining its original PID.  (PID
637c478bd9Sstevel@tonic-gate  *   1 in the global zone.)  To track the processes it has previously spawned,
647c478bd9Sstevel@tonic-gate  *   as well as other mutable state, init(1M) regularly updates a state file
657c478bd9Sstevel@tonic-gate  *   such that its subsequent invocations have knowledge of its various
667c478bd9Sstevel@tonic-gate  *   dependent processes and duties.
677c478bd9Sstevel@tonic-gate  *
687c478bd9Sstevel@tonic-gate  * Process Contracts
697c478bd9Sstevel@tonic-gate  *   We start svc.startd(1M) in a contract and transfer inherited contracts when
707c478bd9Sstevel@tonic-gate  *   restarting it.  Everything else is started using the legacy contract
717c478bd9Sstevel@tonic-gate  *   template, and the created contracts are abandoned when they become empty.
727c478bd9Sstevel@tonic-gate  *
737c478bd9Sstevel@tonic-gate  * utmpx Entry Handling
747c478bd9Sstevel@tonic-gate  *   Because init(1M) no longer governs the startup process, its knowledge of
757c478bd9Sstevel@tonic-gate  *   when utmpx becomes writable is indirect.  However, spawned processes
767c478bd9Sstevel@tonic-gate  *   expect to be constructed with valid utmpx entries.  As a result, attempts
777c478bd9Sstevel@tonic-gate  *   to write normal entries will be retried until successful.
787c478bd9Sstevel@tonic-gate  *
797c478bd9Sstevel@tonic-gate  * Maintenance Mode
807c478bd9Sstevel@tonic-gate  *   In certain failure scenarios, init(1M) will enter a maintenance mode, in
817c478bd9Sstevel@tonic-gate  *   which it invokes sulogin(1M) to allow the operator an opportunity to
827c478bd9Sstevel@tonic-gate  *   repair the system.  Normally, this operation is performed as a
837c478bd9Sstevel@tonic-gate  *   fork(2)-exec(2)-waitpid(3C) sequence with the parent waiting for repair or
847c478bd9Sstevel@tonic-gate  *   diagnosis to be completed.  In the cases that fork(2) requests themselves
857c478bd9Sstevel@tonic-gate  *   fail, init(1M) will directly execute sulogin(1M), and allow the kernel to
867c478bd9Sstevel@tonic-gate  *   restart init(1M) on exit from the operator session.
877c478bd9Sstevel@tonic-gate  *
887c478bd9Sstevel@tonic-gate  *   One scenario where init(1M) enters its maintenance mode is when
897c478bd9Sstevel@tonic-gate  *   svc.startd(1M) begins to fail rapidly, defined as when the average time
907c478bd9Sstevel@tonic-gate  *   between recent failures drops below a given threshold.
917c478bd9Sstevel@tonic-gate  */
927c478bd9Sstevel@tonic-gate 
937c478bd9Sstevel@tonic-gate #include <sys/contract/process.h>
947c478bd9Sstevel@tonic-gate #include <sys/ctfs.h>
957c478bd9Sstevel@tonic-gate #include <sys/stat.h>
967c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
977c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
987c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h>
997c478bd9Sstevel@tonic-gate #include <sys/time.h>
1007c478bd9Sstevel@tonic-gate #include <sys/termios.h>
1017c478bd9Sstevel@tonic-gate #include <sys/tty.h>
1027c478bd9Sstevel@tonic-gate #include <sys/types.h>
1037c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
1046112cec5SJoshua M. Clulow #include <sys/bootbanner.h>
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate #include <bsm/adt_event.h>
1077c478bd9Sstevel@tonic-gate #include <bsm/libbsm.h>
1087c478bd9Sstevel@tonic-gate #include <security/pam_appl.h>
1097c478bd9Sstevel@tonic-gate 
1107c478bd9Sstevel@tonic-gate #include <assert.h>
1117c478bd9Sstevel@tonic-gate #include <ctype.h>
112*a28480feSAndy Fiddaman #include <definit.h>
1137c478bd9Sstevel@tonic-gate #include <dirent.h>
1147c478bd9Sstevel@tonic-gate #include <errno.h>
1157c478bd9Sstevel@tonic-gate #include <fcntl.h>
1167c478bd9Sstevel@tonic-gate #include <libcontract.h>
1177c478bd9Sstevel@tonic-gate #include <libcontract_priv.h>
1187c478bd9Sstevel@tonic-gate #include <libintl.h>
1197c478bd9Sstevel@tonic-gate #include <libscf.h>
1207c478bd9Sstevel@tonic-gate #include <libscf_priv.h>
1217c478bd9Sstevel@tonic-gate #include <poll.h>
1227c478bd9Sstevel@tonic-gate #include <procfs.h>
1237c478bd9Sstevel@tonic-gate #include <signal.h>
1247c478bd9Sstevel@tonic-gate #include <stdarg.h>
1257c478bd9Sstevel@tonic-gate #include <stdio.h>
1267c478bd9Sstevel@tonic-gate #include <stdio_ext.h>
1277c478bd9Sstevel@tonic-gate #include <stdlib.h>
1287c478bd9Sstevel@tonic-gate #include <string.h>
1297c478bd9Sstevel@tonic-gate #include <strings.h>
1307c478bd9Sstevel@tonic-gate #include <syslog.h>
1317c478bd9Sstevel@tonic-gate #include <time.h>
1327c478bd9Sstevel@tonic-gate #include <ulimit.h>
1337c478bd9Sstevel@tonic-gate #include <unistd.h>
1347c478bd9Sstevel@tonic-gate #include <utmpx.h>
1357c478bd9Sstevel@tonic-gate #include <wait.h>
1367c478bd9Sstevel@tonic-gate #include <zone.h>
1377c478bd9Sstevel@tonic-gate #include <ucontext.h>
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate #undef	sleep
1407c478bd9Sstevel@tonic-gate 
1417c478bd9Sstevel@tonic-gate #define	fioctl(p, sptr, cmd)	ioctl(fileno(p), sptr, cmd)
1427c478bd9Sstevel@tonic-gate #define	min(a, b)		(((a) < (b)) ? (a) : (b))
1437c478bd9Sstevel@tonic-gate 
1447c478bd9Sstevel@tonic-gate #define	TRUE	1
1457c478bd9Sstevel@tonic-gate #define	FALSE	0
1467c478bd9Sstevel@tonic-gate #define	FAILURE	-1
1477c478bd9Sstevel@tonic-gate 
1480a1278f2SGary Mills #define	UT_USER_SZ	32	/* Size of a utmpx ut_user field */
1497c478bd9Sstevel@tonic-gate #define	UT_LINE_SZ	32	/* Size of a utmpx ut_line field */
1507c478bd9Sstevel@tonic-gate 
1517c478bd9Sstevel@tonic-gate /*
1527c478bd9Sstevel@tonic-gate  * SLEEPTIME	The number of seconds "init" sleeps between wakeups if
1537c478bd9Sstevel@tonic-gate  *		nothing else requires this "init" wakeup.
1547c478bd9Sstevel@tonic-gate  */
1557c478bd9Sstevel@tonic-gate #define	SLEEPTIME	(5 * 60)
1567c478bd9Sstevel@tonic-gate 
1577c478bd9Sstevel@tonic-gate /*
1587c478bd9Sstevel@tonic-gate  * MAXCMDL	The maximum length of a command string in inittab.
1597c478bd9Sstevel@tonic-gate  */
1607c478bd9Sstevel@tonic-gate #define	MAXCMDL	512
1617c478bd9Sstevel@tonic-gate 
1627c478bd9Sstevel@tonic-gate /*
1637c478bd9Sstevel@tonic-gate  * EXEC		The length of the prefix string added to all comamnds
1647c478bd9Sstevel@tonic-gate  *		found in inittab.
1657c478bd9Sstevel@tonic-gate  */
1667c478bd9Sstevel@tonic-gate #define	EXEC	(sizeof ("exec ") - 1)
1677c478bd9Sstevel@tonic-gate 
1687c478bd9Sstevel@tonic-gate /*
1697c478bd9Sstevel@tonic-gate  * TWARN	The amount of time between warning signal, SIGTERM,
1707c478bd9Sstevel@tonic-gate  *		and the fatal kill signal, SIGKILL.
1717c478bd9Sstevel@tonic-gate  */
1727c478bd9Sstevel@tonic-gate #define	TWARN	5
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate #define	id_eq(x, y)	((x[0] == y[0] && x[1] == y[1] && x[2] == y[2] &&\
1757c478bd9Sstevel@tonic-gate 			x[3] == y[3]) ? TRUE : FALSE)
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate /*
1787c478bd9Sstevel@tonic-gate  * The kernel's default umask is 022 these days; since some processes inherit
1797c478bd9Sstevel@tonic-gate  * their umask from init, init will set it from CMASK in /etc/default/init.
1807c478bd9Sstevel@tonic-gate  * init gets the default umask from the kernel, it sets it to 022 whenever
1817c478bd9Sstevel@tonic-gate  * it wants to create a file and reverts to CMASK afterwards.
1827c478bd9Sstevel@tonic-gate  */
1837c478bd9Sstevel@tonic-gate 
1847c478bd9Sstevel@tonic-gate static int cmask;
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate /*
1877c478bd9Sstevel@tonic-gate  * The following definitions, concluding with the 'lvls' array, provide a
1887c478bd9Sstevel@tonic-gate  * common mapping between level-name (like 'S'), signal number (state),
1897c478bd9Sstevel@tonic-gate  * run-level mask, and specific properties associated with a run-level.
1907c478bd9Sstevel@tonic-gate  * This array should be accessed using the routines lvlname_to_state(),
1917c478bd9Sstevel@tonic-gate  * lvlname_to_mask(), state_to_mask(), and state_to_flags().
1927c478bd9Sstevel@tonic-gate  */
1937c478bd9Sstevel@tonic-gate 
1947c478bd9Sstevel@tonic-gate /*
1957c478bd9Sstevel@tonic-gate  * Correspondence of signals to init actions.
1967c478bd9Sstevel@tonic-gate  */
1977c478bd9Sstevel@tonic-gate #define	LVLQ		SIGHUP
1987c478bd9Sstevel@tonic-gate #define	LVL0		SIGINT
1997c478bd9Sstevel@tonic-gate #define	LVL1		SIGQUIT
2007c478bd9Sstevel@tonic-gate #define	LVL2		SIGILL
2017c478bd9Sstevel@tonic-gate #define	LVL3		SIGTRAP
2027c478bd9Sstevel@tonic-gate #define	LVL4		SIGIOT
2037c478bd9Sstevel@tonic-gate #define	LVL5		SIGEMT
2047c478bd9Sstevel@tonic-gate #define	LVL6		SIGFPE
2057c478bd9Sstevel@tonic-gate #define	SINGLE_USER	SIGBUS
2067c478bd9Sstevel@tonic-gate #define	LVLa		SIGSEGV
2077c478bd9Sstevel@tonic-gate #define	LVLb		SIGSYS
2087c478bd9Sstevel@tonic-gate #define	LVLc		SIGPIPE
2097c478bd9Sstevel@tonic-gate 
2107c478bd9Sstevel@tonic-gate /*
2117c478bd9Sstevel@tonic-gate  * Bit Mask for each level.  Used to determine legal levels.
2127c478bd9Sstevel@tonic-gate  */
2137c478bd9Sstevel@tonic-gate #define	MASK0	0x0001
2147c478bd9Sstevel@tonic-gate #define	MASK1	0x0002
2157c478bd9Sstevel@tonic-gate #define	MASK2	0x0004
2167c478bd9Sstevel@tonic-gate #define	MASK3	0x0008
2177c478bd9Sstevel@tonic-gate #define	MASK4	0x0010
2187c478bd9Sstevel@tonic-gate #define	MASK5	0x0020
2197c478bd9Sstevel@tonic-gate #define	MASK6	0x0040
2207c478bd9Sstevel@tonic-gate #define	MASKSU	0x0080
2217c478bd9Sstevel@tonic-gate #define	MASKa	0x0100
2227c478bd9Sstevel@tonic-gate #define	MASKb	0x0200
2237c478bd9Sstevel@tonic-gate #define	MASKc	0x0400
2247c478bd9Sstevel@tonic-gate 
2257c478bd9Sstevel@tonic-gate #define	MASK_NUMERIC (MASK0 | MASK1 | MASK2 | MASK3 | MASK4 | MASK5 | MASK6)
2267c478bd9Sstevel@tonic-gate #define	MASK_abc (MASKa | MASKb | MASKc)
2277c478bd9Sstevel@tonic-gate 
2287c478bd9Sstevel@tonic-gate /*
2297c478bd9Sstevel@tonic-gate  * Flags to indicate properties of various states.
2307c478bd9Sstevel@tonic-gate  */
2317c478bd9Sstevel@tonic-gate #define	LSEL_RUNLEVEL	0x0001	/* runlevels you can transition to */
2327c478bd9Sstevel@tonic-gate 
2337c478bd9Sstevel@tonic-gate typedef struct lvl {
2347c478bd9Sstevel@tonic-gate 	int	lvl_state;
2357c478bd9Sstevel@tonic-gate 	int	lvl_mask;
2367c478bd9Sstevel@tonic-gate 	char	lvl_name;
2377c478bd9Sstevel@tonic-gate 	int	lvl_flags;
2387c478bd9Sstevel@tonic-gate } lvl_t;
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate static lvl_t lvls[] = {
2417c478bd9Sstevel@tonic-gate 	{ LVLQ,		0,	'Q', 0					},
2427c478bd9Sstevel@tonic-gate 	{ LVLQ,		0,	'q', 0					},
2436d59ee37Spaulson 	{ LVL0,		MASK0,	'0', LSEL_RUNLEVEL			},
244*a28480feSAndy Fiddaman 	{ LVL1,		MASK1,	'1', LSEL_RUNLEVEL			},
245*a28480feSAndy Fiddaman 	{ LVL2,		MASK2,	'2', LSEL_RUNLEVEL			},
246*a28480feSAndy Fiddaman 	{ LVL3,		MASK3,	'3', LSEL_RUNLEVEL			},
247*a28480feSAndy Fiddaman 	{ LVL4,		MASK4,	'4', LSEL_RUNLEVEL			},
248*a28480feSAndy Fiddaman 	{ LVL5,		MASK5,	'5', LSEL_RUNLEVEL			},
249*a28480feSAndy Fiddaman 	{ LVL6,		MASK6,	'6', LSEL_RUNLEVEL			},
250*a28480feSAndy Fiddaman 	{ SINGLE_USER,	MASKSU, 'S', LSEL_RUNLEVEL			},
251*a28480feSAndy Fiddaman 	{ SINGLE_USER,	MASKSU, 's', LSEL_RUNLEVEL			},
2527c478bd9Sstevel@tonic-gate 	{ LVLa,		MASKa,	'a', 0					},
2537c478bd9Sstevel@tonic-gate 	{ LVLb,		MASKb,	'b', 0					},
2547c478bd9Sstevel@tonic-gate 	{ LVLc,		MASKc,	'c', 0					}
2557c478bd9Sstevel@tonic-gate };
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate #define	LVL_NELEMS (sizeof (lvls) / sizeof (lvl_t))
2587c478bd9Sstevel@tonic-gate 
2597c478bd9Sstevel@tonic-gate /*
2607c478bd9Sstevel@tonic-gate  * Legal action field values.
2617c478bd9Sstevel@tonic-gate  */
2627c478bd9Sstevel@tonic-gate #define	OFF		0	/* Kill process if on, else ignore */
2637c478bd9Sstevel@tonic-gate #define	RESPAWN		1	/* Continuously restart process when it dies */
2647c478bd9Sstevel@tonic-gate #define	ONDEMAND	RESPAWN	/* Respawn for a, b, c type processes */
2657c478bd9Sstevel@tonic-gate #define	ONCE		2	/* Start process, do not respawn when dead */
2667c478bd9Sstevel@tonic-gate #define	WAIT		3	/* Perform once and wait to complete */
2677c478bd9Sstevel@tonic-gate #define	BOOT		4	/* Start at boot time only */
2687c478bd9Sstevel@tonic-gate #define	BOOTWAIT	5	/* Start at boot time and wait to complete */
2697c478bd9Sstevel@tonic-gate #define	POWERFAIL	6	/* Start on powerfail */
2707c478bd9Sstevel@tonic-gate #define	POWERWAIT	7	/* Start and wait for complete on powerfail */
2717c478bd9Sstevel@tonic-gate #define	INITDEFAULT	8	/* Default level "init" should start at */
2727c478bd9Sstevel@tonic-gate #define	SYSINIT		9	/* Actions performed before init speaks */
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate #define	M_OFF		0001
2757c478bd9Sstevel@tonic-gate #define	M_RESPAWN	0002
2767c478bd9Sstevel@tonic-gate #define	M_ONDEMAND	M_RESPAWN
2777c478bd9Sstevel@tonic-gate #define	M_ONCE		0004
2787c478bd9Sstevel@tonic-gate #define	M_WAIT		0010
2797c478bd9Sstevel@tonic-gate #define	M_BOOT		0020
2807c478bd9Sstevel@tonic-gate #define	M_BOOTWAIT	0040
2817c478bd9Sstevel@tonic-gate #define	M_PF		0100
2827c478bd9Sstevel@tonic-gate #define	M_PWAIT		0200
2837c478bd9Sstevel@tonic-gate #define	M_INITDEFAULT	0400
2847c478bd9Sstevel@tonic-gate #define	M_SYSINIT	01000
2857c478bd9Sstevel@tonic-gate 
2867c478bd9Sstevel@tonic-gate /* States for the inittab parser in getcmd(). */
2877c478bd9Sstevel@tonic-gate #define	ID	1
2887c478bd9Sstevel@tonic-gate #define	LEVELS	2
2897c478bd9Sstevel@tonic-gate #define	ACTION	3
2907c478bd9Sstevel@tonic-gate #define	COMMAND	4
2917c478bd9Sstevel@tonic-gate #define	COMMENT	5
2927c478bd9Sstevel@tonic-gate 
2937b209c2cSacruz /*
2947b209c2cSacruz  * inittab entry id constants
2957b209c2cSacruz  */
2967b209c2cSacruz #define	INITTAB_ENTRY_ID_SIZE 4
2977b209c2cSacruz #define	INITTAB_ENTRY_ID_STR_FORMAT "%.4s"	/* if INITTAB_ENTRY_ID_SIZE */
2987b209c2cSacruz 						/* changes, this should */
2997b209c2cSacruz 						/* change accordingly */
3007b209c2cSacruz 
3017c478bd9Sstevel@tonic-gate /*
3027c478bd9Sstevel@tonic-gate  * Init can be in any of three main states, "normal" mode where it is
3037c478bd9Sstevel@tonic-gate  * processing entries for the lines file in a normal fashion, "boot" mode,
3047c478bd9Sstevel@tonic-gate  * where it is only interested in the boot actions, and "powerfail" mode,
3057c478bd9Sstevel@tonic-gate  * where it is only interested in powerfail related actions. The following
3067c478bd9Sstevel@tonic-gate  * masks declare the legal actions for each mode.
3077c478bd9Sstevel@tonic-gate  */
3087c478bd9Sstevel@tonic-gate #define	NORMAL_MODES	(M_OFF | M_RESPAWN | M_ONCE | M_WAIT)
3097c478bd9Sstevel@tonic-gate #define	BOOT_MODES	(M_BOOT | M_BOOTWAIT)
3107c478bd9Sstevel@tonic-gate #define	PF_MODES	(M_PF | M_PWAIT)
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate struct PROC_TABLE {
3137b209c2cSacruz 	char	p_id[INITTAB_ENTRY_ID_SIZE];	/* Four letter unique id of */
3147b209c2cSacruz 						/* process */
3157c478bd9Sstevel@tonic-gate 	pid_t	p_pid;		/* Process id */
3167c478bd9Sstevel@tonic-gate 	short	p_count;	/* How many respawns of this command in */
3177c478bd9Sstevel@tonic-gate 				/*   the current series */
3187c478bd9Sstevel@tonic-gate 	long	p_time;		/* Start time for a series of respawns */
3197c478bd9Sstevel@tonic-gate 	short	p_flags;
3207c478bd9Sstevel@tonic-gate 	short	p_exit;		/* Exit status of a process which died */
3217c478bd9Sstevel@tonic-gate };
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate /*
3247c478bd9Sstevel@tonic-gate  * Flags for the "p_flags" word of a PROC_TABLE entry:
3257c478bd9Sstevel@tonic-gate  *
3267c478bd9Sstevel@tonic-gate  *	OCCUPIED	This slot in init's proc table is in use.
3277c478bd9Sstevel@tonic-gate  *
3287c478bd9Sstevel@tonic-gate  *	LIVING		Process is alive.
3297c478bd9Sstevel@tonic-gate  *
3307c478bd9Sstevel@tonic-gate  *	NOCLEANUP	efork() is not allowed to cleanup this entry even
3317c478bd9Sstevel@tonic-gate  *			if process is dead.
3327c478bd9Sstevel@tonic-gate  *
3337c478bd9Sstevel@tonic-gate  *	NAMED		This process has a name, i.e. came from inittab.
3347c478bd9Sstevel@tonic-gate  *
3357c478bd9Sstevel@tonic-gate  *	DEMANDREQUEST	Process started by a "telinit [abc]" command.  Processes
3367c478bd9Sstevel@tonic-gate  *			formed this way are respawnable and immune to level
3377c478bd9Sstevel@tonic-gate  *			changes as long as their entry exists in inittab.
3387c478bd9Sstevel@tonic-gate  *
3397c478bd9Sstevel@tonic-gate  *	TOUCHED		Flag used by remv() to determine whether it has looked
3407c478bd9Sstevel@tonic-gate  *			at an entry while checking for processes to be killed.
3417c478bd9Sstevel@tonic-gate  *
3427c478bd9Sstevel@tonic-gate  *	WARNED		Flag used by remv() to mark processes that have been
3437c478bd9Sstevel@tonic-gate  *			sent the SIGTERM signal.  If they don't die in 5
3447c478bd9Sstevel@tonic-gate  *			seconds, they are sent the SIGKILL signal.
3457c478bd9Sstevel@tonic-gate  *
3467c478bd9Sstevel@tonic-gate  *	KILLED		Flag used by remv() to mark procs that have been sent
3477c478bd9Sstevel@tonic-gate  *			the SIGTERM and SIGKILL signals.
3487c478bd9Sstevel@tonic-gate  *
3497c478bd9Sstevel@tonic-gate  *	PF_MASK		Bitwise or of legal flags, for sanity checking.
3507c478bd9Sstevel@tonic-gate  */
3517c478bd9Sstevel@tonic-gate #define	OCCUPIED	01
3527c478bd9Sstevel@tonic-gate #define	LIVING		02
3537c478bd9Sstevel@tonic-gate #define	NOCLEANUP	04
3547c478bd9Sstevel@tonic-gate #define	NAMED		010
3557c478bd9Sstevel@tonic-gate #define	DEMANDREQUEST	020
3567c478bd9Sstevel@tonic-gate #define	TOUCHED		040
3577c478bd9Sstevel@tonic-gate #define	WARNED		0100
3587c478bd9Sstevel@tonic-gate #define	KILLED		0200
3597c478bd9Sstevel@tonic-gate #define	PF_MASK		0377
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate /*
3627c478bd9Sstevel@tonic-gate  * Respawn limits for processes that are to be respawned:
3637c478bd9Sstevel@tonic-gate  *
3647c478bd9Sstevel@tonic-gate  *	SPAWN_INTERVAL	The number of seconds over which "init" will try to
3657c478bd9Sstevel@tonic-gate  *			respawn a process SPAWN_LIMIT times before it gets mad.
3667c478bd9Sstevel@tonic-gate  *
3677c478bd9Sstevel@tonic-gate  *	SPAWN_LIMIT	The number of respawns "init" will attempt in
3687c478bd9Sstevel@tonic-gate  *			SPAWN_INTERVAL seconds before it generates an
3697c478bd9Sstevel@tonic-gate  *			error message and inhibits further tries for
3707c478bd9Sstevel@tonic-gate  *			INHIBIT seconds.
3717c478bd9Sstevel@tonic-gate  *
3727c478bd9Sstevel@tonic-gate  *	INHIBIT		The number of seconds "init" ignores an entry it had
3737c478bd9Sstevel@tonic-gate  *			trouble spawning unless a "telinit Q" is received.
3747c478bd9Sstevel@tonic-gate  */
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate #define	SPAWN_INTERVAL	(2*60)
3777c478bd9Sstevel@tonic-gate #define	SPAWN_LIMIT	10
3787c478bd9Sstevel@tonic-gate #define	INHIBIT		(5*60)
3797c478bd9Sstevel@tonic-gate 
3807c478bd9Sstevel@tonic-gate /*
3817c478bd9Sstevel@tonic-gate  * The maximum number of decimal digits for an id_t.  (ceil(log10 (max_id)))
3827c478bd9Sstevel@tonic-gate  */
3837c478bd9Sstevel@tonic-gate #define	ID_MAX_STR_LEN	10
3847c478bd9Sstevel@tonic-gate 
3857c478bd9Sstevel@tonic-gate #define	NULLPROC	((struct PROC_TABLE *)(0))
3867c478bd9Sstevel@tonic-gate #define	NO_ROOM		((struct PROC_TABLE *)(FAILURE))
3877c478bd9Sstevel@tonic-gate 
3887c478bd9Sstevel@tonic-gate struct CMD_LINE {
3897b209c2cSacruz 	char c_id[INITTAB_ENTRY_ID_SIZE];	/* Four letter unique id of */
3907b209c2cSacruz 						/* process to be affected by */
3917b209c2cSacruz 						/* action */
3927c478bd9Sstevel@tonic-gate 	short c_levels;	/* Mask of legal levels for process */
3937c478bd9Sstevel@tonic-gate 	short c_action;	/* Mask for type of action required */
3947c478bd9Sstevel@tonic-gate 	char *c_command; /* Pointer to init command */
3957c478bd9Sstevel@tonic-gate };
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate struct	pidrec {
3987c478bd9Sstevel@tonic-gate 	int	pd_type;	/* Command type */
3997c478bd9Sstevel@tonic-gate 	pid_t	pd_pid;		/* pid to add or remove */
4007c478bd9Sstevel@tonic-gate };
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate /*
4037c478bd9Sstevel@tonic-gate  * pd_type's
4047c478bd9Sstevel@tonic-gate  */
4057c478bd9Sstevel@tonic-gate #define	ADDPID	1
4067c478bd9Sstevel@tonic-gate #define	REMPID	2
4077c478bd9Sstevel@tonic-gate 
4087c478bd9Sstevel@tonic-gate static struct	pidlist {
4097c478bd9Sstevel@tonic-gate 	pid_t	pl_pid;		/* pid to watch for */
4107c478bd9Sstevel@tonic-gate 	int	pl_dflag;	/* Flag indicating SIGCLD from this pid */
4117c478bd9Sstevel@tonic-gate 	short	pl_exit;	/* Exit status of proc */
4127c478bd9Sstevel@tonic-gate 	struct	pidlist	*pl_next; /* Next in list */
4137c478bd9Sstevel@tonic-gate } *Plhead, *Plfree;
4147c478bd9Sstevel@tonic-gate 
4157c478bd9Sstevel@tonic-gate /*
4167c478bd9Sstevel@tonic-gate  * The following structure contains a set of modes for /dev/syscon
41739cc040fSToomas Soome  * and should match the default contents of /etc/ioctl.syscon.
4187c478bd9Sstevel@tonic-gate  */
4197c478bd9Sstevel@tonic-gate static struct termios	dflt_termios = {
42039cc040fSToomas Soome 	.c_iflag = BRKINT|ICRNL|IXON|IMAXBEL,
42139cc040fSToomas Soome 	.c_oflag = OPOST|ONLCR|TAB3,
42239cc040fSToomas Soome 	.c_cflag = CS8|CREAD|B9600,
42339cc040fSToomas Soome 	.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN,
42439cc040fSToomas Soome 	.c_cc = { CINTR, CQUIT, CERASE, CKILL, CEOF, 0, 0, 0,
42539cc040fSToomas Soome 	    CSTART, CSTOP, CSWTCH, CDSUSP, CRPRNT, CFLUSH, CWERASE, CLNEXT,
42639cc040fSToomas Soome 	    CSTATUS, CERASE2, 0
42739cc040fSToomas Soome 	}
4287c478bd9Sstevel@tonic-gate };
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate static struct termios	stored_syscon_termios;
4317c478bd9Sstevel@tonic-gate static int		write_ioctl = 0;	/* Rewrite /etc/ioctl.syscon */
4327c478bd9Sstevel@tonic-gate 
4337c478bd9Sstevel@tonic-gate static union WAKEUP {
4347c478bd9Sstevel@tonic-gate 	struct WAKEFLAGS {
4357c478bd9Sstevel@tonic-gate 		unsigned w_usersignal : 1;	/* User sent signal to "init" */
4367c478bd9Sstevel@tonic-gate 		unsigned w_childdeath : 1;	/* An "init" child died */
4377c478bd9Sstevel@tonic-gate 		unsigned w_powerhit : 1;	/* OS experienced powerfail */
4387c478bd9Sstevel@tonic-gate 	}	w_flags;
4397c478bd9Sstevel@tonic-gate 	int w_mask;
4407c478bd9Sstevel@tonic-gate } wakeup;
4417c478bd9Sstevel@tonic-gate 
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate struct init_state {
4447c478bd9Sstevel@tonic-gate 	int			ist_runlevel;
4457c478bd9Sstevel@tonic-gate 	int			ist_num_proc;
4467c478bd9Sstevel@tonic-gate 	int			ist_utmpx_ok;
4477c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	ist_proc_table[1];
4487c478bd9Sstevel@tonic-gate };
4497c478bd9Sstevel@tonic-gate 
4507c478bd9Sstevel@tonic-gate #define	cur_state	(g_state->ist_runlevel)
4517c478bd9Sstevel@tonic-gate #define	num_proc	(g_state->ist_num_proc)
4527c478bd9Sstevel@tonic-gate #define	proc_table	(g_state->ist_proc_table)
4537c478bd9Sstevel@tonic-gate #define	utmpx_ok	(g_state->ist_utmpx_ok)
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate /* Contract cookies. */
4567c478bd9Sstevel@tonic-gate #define	ORDINARY_COOKIE		0
4577c478bd9Sstevel@tonic-gate #define	STARTD_COOKIE		1
4587c478bd9Sstevel@tonic-gate 
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate #ifndef NDEBUG
4617c478bd9Sstevel@tonic-gate #define	bad_error(func, err)	{					\
4627c478bd9Sstevel@tonic-gate 	(void) fprintf(stderr, "%s:%d: %s() failed with unexpected "	\
4637c478bd9Sstevel@tonic-gate 	    "error %d.  Aborting.\n", __FILE__, __LINE__, (func), (err)); \
4647c478bd9Sstevel@tonic-gate 	abort();							\
4657c478bd9Sstevel@tonic-gate }
4667c478bd9Sstevel@tonic-gate #else
4677c478bd9Sstevel@tonic-gate #define	bad_error(func, err)	abort()
4687c478bd9Sstevel@tonic-gate #endif
4697c478bd9Sstevel@tonic-gate 
4707c478bd9Sstevel@tonic-gate 
4717c478bd9Sstevel@tonic-gate /*
4727c478bd9Sstevel@tonic-gate  * Useful file and device names.
4737c478bd9Sstevel@tonic-gate  */
4747c478bd9Sstevel@tonic-gate static char *CONSOLE	  = "/dev/console";	/* Real system console */
47592ba7109Seschrock static char *INITPIPE_DIR = "/var/run";
47692ba7109Seschrock static char *INITPIPE	  = "/var/run/initpipe";
4777c478bd9Sstevel@tonic-gate 
4787c478bd9Sstevel@tonic-gate #define	INIT_STATE_DIR "/etc/svc/volatile"
4797c478bd9Sstevel@tonic-gate static const char * const init_state_file = INIT_STATE_DIR "/init.state";
4807c478bd9Sstevel@tonic-gate static const char * const init_next_state_file =
4817c478bd9Sstevel@tonic-gate 	INIT_STATE_DIR "/init-next.state";
4827c478bd9Sstevel@tonic-gate 
4837c478bd9Sstevel@tonic-gate static const int init_num_proc = 20;	/* Initial size of process table. */
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate static char *UTMPX	 = UTMPX_FILE;		/* Snapshot record file */
4867c478bd9Sstevel@tonic-gate static char *WTMPX	 = WTMPX_FILE;		/* Long term record file */
4877c478bd9Sstevel@tonic-gate static char *INITTAB	 = "/etc/inittab";	/* Script file for "init" */
4887c478bd9Sstevel@tonic-gate static char *SYSTTY	 = "/dev/systty";	/* System Console */
4897c478bd9Sstevel@tonic-gate static char *SYSCON	 = "/dev/syscon";	/* Virtual System console */
4907c478bd9Sstevel@tonic-gate static char *IOCTLSYSCON = "/etc/ioctl.syscon";	/* Last syscon modes */
491*a28480feSAndy Fiddaman static char *ENVFILE	 = DEFINIT_DEFAULT_FILE; /* Default env. */
4927c478bd9Sstevel@tonic-gate static char *SU	= "/etc/sulogin";	/* Super-user program for single user */
4937c478bd9Sstevel@tonic-gate static char *SH	= "/sbin/sh";		/* Standard shell */
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate /*
4967c478bd9Sstevel@tonic-gate  * Default Path.  /sbin is included in path only during sysinit phase
4977c478bd9Sstevel@tonic-gate  */
4987c478bd9Sstevel@tonic-gate #define	DEF_PATH	"PATH=/usr/sbin:/usr/bin"
4997c478bd9Sstevel@tonic-gate #define	INIT_PATH	"PATH=/sbin:/usr/sbin:/usr/bin"
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate static int	prior_state;
5027c478bd9Sstevel@tonic-gate static int	prev_state;	/* State "init" was in last time it woke */
5037c478bd9Sstevel@tonic-gate static int	new_state;	/* State user wants "init" to go to. */
50492ba7109Seschrock static int	lvlq_received;	/* Explicit request to examine state */
5057c478bd9Sstevel@tonic-gate static int	op_modes = BOOT_MODES; /* Current state of "init" */
5067c478bd9Sstevel@tonic-gate static int	Gchild = 0;	/* Flag to indicate "godchild" died, set in */
5077c478bd9Sstevel@tonic-gate 				/*   childeath() and cleared in cleanaux() */
5087c478bd9Sstevel@tonic-gate static int	Pfd = -1;	/* fd to receive pids thru */
5097c478bd9Sstevel@tonic-gate static unsigned int	spawncnt, pausecnt;
5107c478bd9Sstevel@tonic-gate static int	rsflag;		/* Set if a respawn has taken place */
5117c478bd9Sstevel@tonic-gate static volatile int time_up;	/* Flag set to TRUE by the alarm interrupt */
5127c478bd9Sstevel@tonic-gate 				/* routine each time an alarm interrupt */
5137c478bd9Sstevel@tonic-gate 				/* takes place. */
5147c478bd9Sstevel@tonic-gate static int	sflg = 0;	/* Set if we were booted -s to single user */
5157c478bd9Sstevel@tonic-gate static int	rflg = 0;	/* Set if booted -r, reconfigure devices */
5167c478bd9Sstevel@tonic-gate static int	bflg = 0;	/* Set if booted -b, don't run rc scripts */
5177c478bd9Sstevel@tonic-gate static pid_t	init_pid;	/* PID of "one true" init for current zone */
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate static struct init_state *g_state = NULL;
5207c478bd9Sstevel@tonic-gate static size_t	g_state_sz;
5217c478bd9Sstevel@tonic-gate static int	booting = 1;	/* Set while we're booting. */
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate /*
5247c478bd9Sstevel@tonic-gate  * Array for default global environment.
5257c478bd9Sstevel@tonic-gate  */
5267c478bd9Sstevel@tonic-gate #define	MAXENVENT	24	/* Max number of default env variables + 1 */
5277c478bd9Sstevel@tonic-gate 				/* init can use three itself, so this leaves */
5287c478bd9Sstevel@tonic-gate 				/* 20 for the administrator in ENVFILE. */
5297c478bd9Sstevel@tonic-gate static char	*glob_envp[MAXENVENT];	/* Array of environment strings */
5307c478bd9Sstevel@tonic-gate static int	glob_envn;		/* Number of environment strings */
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate static struct pollfd	poll_fds[1];
5347c478bd9Sstevel@tonic-gate static int		poll_nfds = 0;	/* poll_fds is uninitialized */
5357c478bd9Sstevel@tonic-gate 
5367b209c2cSacruz /*
5377b209c2cSacruz  * Contracts constants
5387b209c2cSacruz  */
5397b209c2cSacruz #define	SVC_INIT_PREFIX "init:/"
5407b209c2cSacruz #define	SVC_AUX_SIZE (INITTAB_ENTRY_ID_SIZE + 1)
5417b209c2cSacruz #define	SVC_FMRI_SIZE (sizeof (SVC_INIT_PREFIX) + INITTAB_ENTRY_ID_SIZE)
5427b209c2cSacruz 
5437c478bd9Sstevel@tonic-gate static int	legacy_tmpl = -1;	/* fd for legacy contract template */
5447c478bd9Sstevel@tonic-gate static int	startd_tmpl = -1;	/* fd for svc.startd's template */
5457b209c2cSacruz static char	startd_svc_aux[SVC_AUX_SIZE];
5467c478bd9Sstevel@tonic-gate 
5477c478bd9Sstevel@tonic-gate static char	startd_cline[256] = "";	/* svc.startd's command line */
5487c478bd9Sstevel@tonic-gate static int	do_restart_startd = 1;	/* Whether to restart svc.startd. */
5497c478bd9Sstevel@tonic-gate static char	*smf_options = NULL;	/* Options to give to startd. */
5507c478bd9Sstevel@tonic-gate static int	smf_debug = 0;		/* Messages for debugging smf(5) */
5517c478bd9Sstevel@tonic-gate static time_t	init_boot_time;		/* Substitute for kernel boot time. */
5527c478bd9Sstevel@tonic-gate 
5537c478bd9Sstevel@tonic-gate #define	NSTARTD_FAILURE_TIMES	3		/* trigger after 3 failures */
5547c478bd9Sstevel@tonic-gate #define	STARTD_FAILURE_RATE_NS	5000000000LL	/* 1 failure/5 seconds */
5557c478bd9Sstevel@tonic-gate 
5567c478bd9Sstevel@tonic-gate static hrtime_t	startd_failure_time[NSTARTD_FAILURE_TIMES];
5577c478bd9Sstevel@tonic-gate static uint_t	startd_failure_index;
5587c478bd9Sstevel@tonic-gate 
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate static char	*prog_name(char *);
5617c478bd9Sstevel@tonic-gate static int	state_to_mask(int);
5627c478bd9Sstevel@tonic-gate static int	lvlname_to_mask(char, int *);
5637c478bd9Sstevel@tonic-gate static void	lscf_set_runlevel(char);
5647c478bd9Sstevel@tonic-gate static int	state_to_flags(int);
5657c478bd9Sstevel@tonic-gate static char	state_to_name(int);
5667c478bd9Sstevel@tonic-gate static int	lvlname_to_state(char);
5677c478bd9Sstevel@tonic-gate static int	getcmd(struct CMD_LINE *, char *);
5687c478bd9Sstevel@tonic-gate static int	realcon();
5697c478bd9Sstevel@tonic-gate static int	spawn_processes();
5707c478bd9Sstevel@tonic-gate static int	get_ioctl_syscon();
5717c478bd9Sstevel@tonic-gate static int	account(short, struct PROC_TABLE *, char *);
5727c478bd9Sstevel@tonic-gate static void	alarmclk();
5737c478bd9Sstevel@tonic-gate static void	childeath(int);
5747c478bd9Sstevel@tonic-gate static void	cleanaux();
5757c478bd9Sstevel@tonic-gate static void	clearent(pid_t, short);
5767c478bd9Sstevel@tonic-gate static void	console(boolean_t, char *, ...);
5777c478bd9Sstevel@tonic-gate static void	init_signals(void);
5787c478bd9Sstevel@tonic-gate static void	setup_pipe();
5797c478bd9Sstevel@tonic-gate static void	killproc(pid_t);
5807c478bd9Sstevel@tonic-gate static void	init_env();
5817c478bd9Sstevel@tonic-gate static void	boot_init();
5827c478bd9Sstevel@tonic-gate static void	powerfail();
5837c478bd9Sstevel@tonic-gate static void	remv();
5847c478bd9Sstevel@tonic-gate static void	write_ioctl_syscon();
5857c478bd9Sstevel@tonic-gate static void	spawn(struct PROC_TABLE *, struct CMD_LINE *);
5867c478bd9Sstevel@tonic-gate static void	setimer(int);
5877c478bd9Sstevel@tonic-gate static void	siglvl(int, siginfo_t *, ucontext_t *);
5887c478bd9Sstevel@tonic-gate static void	sigpoll(int);
5897c478bd9Sstevel@tonic-gate static void	enter_maintenance(void);
5907c478bd9Sstevel@tonic-gate static void	timer(int);
5917c478bd9Sstevel@tonic-gate static void	userinit(int, char **);
5927c478bd9Sstevel@tonic-gate static void	notify_pam_dead(struct utmpx *);
5937c478bd9Sstevel@tonic-gate static long	waitproc(struct PROC_TABLE *);
5947c478bd9Sstevel@tonic-gate static struct PROC_TABLE *efork(int, struct PROC_TABLE *, int);
5957c478bd9Sstevel@tonic-gate static struct PROC_TABLE *findpslot(struct CMD_LINE *);
5967c478bd9Sstevel@tonic-gate static void	increase_proc_table_size();
5977c478bd9Sstevel@tonic-gate static void	st_init();
5987c478bd9Sstevel@tonic-gate static void	st_write();
5997c478bd9Sstevel@tonic-gate static void	contracts_init();
6007c478bd9Sstevel@tonic-gate static void	contract_event(struct pollfd *);
6017c478bd9Sstevel@tonic-gate static int	startd_run(const char *, int, ctid_t);
6027c478bd9Sstevel@tonic-gate static void	startd_record_failure();
6037c478bd9Sstevel@tonic-gate static int	startd_failure_rate_critical();
6047c478bd9Sstevel@tonic-gate static char	*audit_boot_msg();
6057c478bd9Sstevel@tonic-gate static int	audit_put_record(int, int, char *);
6067c478bd9Sstevel@tonic-gate static void	update_boot_archive(int new_state);
6076112cec5SJoshua M. Clulow static void	init_bootbanner_print(const char *, uint_t);
6087c478bd9Sstevel@tonic-gate 
6097c478bd9Sstevel@tonic-gate int
6107c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
6117c478bd9Sstevel@tonic-gate {
6127c478bd9Sstevel@tonic-gate 	int	chg_lvl_flag = FALSE, print_banner = FALSE;
6137c478bd9Sstevel@tonic-gate 	int	may_need_audit = 1;
6147c478bd9Sstevel@tonic-gate 	int	c;
6157c478bd9Sstevel@tonic-gate 	char	*msg;
6167c478bd9Sstevel@tonic-gate 
6177c478bd9Sstevel@tonic-gate 	/* Get a timestamp for use as boot time, if needed. */
6187c478bd9Sstevel@tonic-gate 	(void) time(&init_boot_time);
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	/* Get the default umask */
6217c478bd9Sstevel@tonic-gate 	cmask = umask(022);
6227c478bd9Sstevel@tonic-gate 	(void) umask(cmask);
6237c478bd9Sstevel@tonic-gate 
6247c478bd9Sstevel@tonic-gate 	/* Parse the arguments to init. Check for single user */
6257c478bd9Sstevel@tonic-gate 	opterr = 0;
6267c478bd9Sstevel@tonic-gate 	while ((c = getopt(argc, argv, "brsm:")) != EOF) {
6277c478bd9Sstevel@tonic-gate 		switch (c) {
6287c478bd9Sstevel@tonic-gate 		case 'b':
6297c478bd9Sstevel@tonic-gate 			rflg = 0;
6307c478bd9Sstevel@tonic-gate 			bflg = 1;
6317c478bd9Sstevel@tonic-gate 			if (!sflg)
6327c478bd9Sstevel@tonic-gate 				sflg++;
6337c478bd9Sstevel@tonic-gate 			break;
6347c478bd9Sstevel@tonic-gate 		case 'r':
6357c478bd9Sstevel@tonic-gate 			bflg = 0;
6367c478bd9Sstevel@tonic-gate 			rflg++;
6377c478bd9Sstevel@tonic-gate 			break;
6387c478bd9Sstevel@tonic-gate 		case 's':
6397c478bd9Sstevel@tonic-gate 			if (!bflg)
6407c478bd9Sstevel@tonic-gate 				sflg++;
6417c478bd9Sstevel@tonic-gate 			break;
6427c478bd9Sstevel@tonic-gate 		case 'm':
6437c478bd9Sstevel@tonic-gate 			smf_options = optarg;
6447c478bd9Sstevel@tonic-gate 			smf_debug = (strstr(smf_options, "debug") != NULL);
6457c478bd9Sstevel@tonic-gate 			break;
6467c478bd9Sstevel@tonic-gate 		}
6477c478bd9Sstevel@tonic-gate 	}
6487c478bd9Sstevel@tonic-gate 
6497c478bd9Sstevel@tonic-gate 	/*
6507c478bd9Sstevel@tonic-gate 	 * Determine if we are the main init, or a user invoked init, whose job
6517c478bd9Sstevel@tonic-gate 	 * it is to inform init to change levels or perform some other action.
6527c478bd9Sstevel@tonic-gate 	 */
6537c478bd9Sstevel@tonic-gate 	if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
6547c478bd9Sstevel@tonic-gate 	    sizeof (init_pid)) != sizeof (init_pid)) {
6557c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, "could not get pid for init\n");
6567c478bd9Sstevel@tonic-gate 		return (1);
6577c478bd9Sstevel@tonic-gate 	}
6587c478bd9Sstevel@tonic-gate 
6597c478bd9Sstevel@tonic-gate 	/*
6607c478bd9Sstevel@tonic-gate 	 * If this PID is not the same as the "true" init for the zone, then we
6617c478bd9Sstevel@tonic-gate 	 * must be in 'user' mode.
6627c478bd9Sstevel@tonic-gate 	 */
6637c478bd9Sstevel@tonic-gate 	if (getpid() != init_pid) {
6647c478bd9Sstevel@tonic-gate 		userinit(argc, argv);
6657c478bd9Sstevel@tonic-gate 	}
6667c478bd9Sstevel@tonic-gate 
6677c478bd9Sstevel@tonic-gate 	if (getzoneid() != GLOBAL_ZONEID) {
6687c478bd9Sstevel@tonic-gate 		print_banner = TRUE;
6697c478bd9Sstevel@tonic-gate 	}
6707c478bd9Sstevel@tonic-gate 
6717c478bd9Sstevel@tonic-gate 	/*
6727c478bd9Sstevel@tonic-gate 	 * Initialize state (and set "booting").
6737c478bd9Sstevel@tonic-gate 	 */
6747c478bd9Sstevel@tonic-gate 	st_init();
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 	if (booting && print_banner) {
6777c478bd9Sstevel@tonic-gate 		/*
6787c478bd9Sstevel@tonic-gate 		 * We want to print the boot banner as soon as
6797c478bd9Sstevel@tonic-gate 		 * possible.  In the global zone, the kernel does it,
6807c478bd9Sstevel@tonic-gate 		 * but we do not have that luxury in non-global zones,
6817c478bd9Sstevel@tonic-gate 		 * so we will print it here.
6827c478bd9Sstevel@tonic-gate 		 */
6836112cec5SJoshua M. Clulow #ifdef	LEGACY_BANNER
6846112cec5SJoshua M. Clulow 		struct utsname un;
6856112cec5SJoshua M. Clulow 		char buf[BUFSIZ];
6866112cec5SJoshua M. Clulow 		const char *bits;
6876112cec5SJoshua M. Clulow 		int r;
6886112cec5SJoshua M. Clulow 
6897c478bd9Sstevel@tonic-gate 		(void) uname(&un);
6906112cec5SJoshua M. Clulow 		if ((r = sysinfo(SI_ADDRESS_WIDTH, buf, sizeof (buf))) > 0 &&
6916112cec5SJoshua M. Clulow 		    r < sizeof (buf)) {
6926112cec5SJoshua M. Clulow 			bits = buf;
6936112cec5SJoshua M. Clulow 		} else {
6946112cec5SJoshua M. Clulow 			bits = "64";
6957c478bd9Sstevel@tonic-gate 		}
6967c478bd9Sstevel@tonic-gate 
6977c478bd9Sstevel@tonic-gate 		console(B_FALSE,
6986112cec5SJoshua M. Clulow 		    "\n\n%s Release %s Version %s %s-bit\r\n",
6997c478bd9Sstevel@tonic-gate 		    un.sysname, un.release, un.version, bits);
7007c478bd9Sstevel@tonic-gate 		console(B_FALSE,
701861a9162SJohn Beck 		    "Copyright (c) 1983, 2010, Oracle and/or its affiliates."
7027c478bd9Sstevel@tonic-gate 		    " All rights reserved.\r\n");
7036112cec5SJoshua M. Clulow #else
7046112cec5SJoshua M. Clulow 		bootbanner_print(init_bootbanner_print, 0);
7056112cec5SJoshua M. Clulow #endif
7067c478bd9Sstevel@tonic-gate 	}
7077c478bd9Sstevel@tonic-gate 
7087c478bd9Sstevel@tonic-gate 	/*
7097c478bd9Sstevel@tonic-gate 	 * Get the ioctl settings for /dev/syscon from /etc/ioctl.syscon
7107c478bd9Sstevel@tonic-gate 	 * so that it can be brought up in the state it was in when the
7117c478bd9Sstevel@tonic-gate 	 * system went down; or set to defaults if ioctl.syscon isn't
7127c478bd9Sstevel@tonic-gate 	 * valid.
7137c478bd9Sstevel@tonic-gate 	 *
7147c478bd9Sstevel@tonic-gate 	 * This needs to be done even if we're restarting so reset_modes()
7157c478bd9Sstevel@tonic-gate 	 * will work in case we need to go down to single user mode.
7167c478bd9Sstevel@tonic-gate 	 */
7177c478bd9Sstevel@tonic-gate 	write_ioctl = get_ioctl_syscon();
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 	/*
7207c478bd9Sstevel@tonic-gate 	 * Set up all signals to be caught or ignored as appropriate.
7217c478bd9Sstevel@tonic-gate 	 */
7227c478bd9Sstevel@tonic-gate 	init_signals();
7237c478bd9Sstevel@tonic-gate 
7247c478bd9Sstevel@tonic-gate 	/* Load glob_envp from ENVFILE. */
7257c478bd9Sstevel@tonic-gate 	init_env();
7267c478bd9Sstevel@tonic-gate 
7277c478bd9Sstevel@tonic-gate 	contracts_init();
7287c478bd9Sstevel@tonic-gate 
7297c478bd9Sstevel@tonic-gate 	if (!booting) {
7307c478bd9Sstevel@tonic-gate 		/* cur_state should have been read in. */
7317c478bd9Sstevel@tonic-gate 
7327c478bd9Sstevel@tonic-gate 		op_modes = NORMAL_MODES;
7337c478bd9Sstevel@tonic-gate 
7347c478bd9Sstevel@tonic-gate 		/* Rewrite the ioctl file if it was bad. */
7357c478bd9Sstevel@tonic-gate 		if (write_ioctl)
7367c478bd9Sstevel@tonic-gate 			write_ioctl_syscon();
7377c478bd9Sstevel@tonic-gate 	} else {
7387c478bd9Sstevel@tonic-gate 		/*
7397c478bd9Sstevel@tonic-gate 		 * It's fine to boot up with state as zero, because
7407c478bd9Sstevel@tonic-gate 		 * startd will later tell us the real state.
7417c478bd9Sstevel@tonic-gate 		 */
7427c478bd9Sstevel@tonic-gate 		cur_state = 0;
7437c478bd9Sstevel@tonic-gate 		op_modes = BOOT_MODES;
7447c478bd9Sstevel@tonic-gate 
7457c478bd9Sstevel@tonic-gate 		boot_init();
7467c478bd9Sstevel@tonic-gate 	}
7477c478bd9Sstevel@tonic-gate 
7487c478bd9Sstevel@tonic-gate 	prev_state = prior_state = cur_state;
7497c478bd9Sstevel@tonic-gate 
75092ba7109Seschrock 	setup_pipe();
75192ba7109Seschrock 
7527c478bd9Sstevel@tonic-gate 	/*
7537c478bd9Sstevel@tonic-gate 	 * Here is the beginning of the main process loop.
7547c478bd9Sstevel@tonic-gate 	 */
7557c478bd9Sstevel@tonic-gate 	for (;;) {
75692ba7109Seschrock 		if (lvlq_received) {
7577c478bd9Sstevel@tonic-gate 			setup_pipe();
75892ba7109Seschrock 			lvlq_received = B_FALSE;
75992ba7109Seschrock 		}
7607c478bd9Sstevel@tonic-gate 
7617c478bd9Sstevel@tonic-gate 		/*
7627c478bd9Sstevel@tonic-gate 		 * Clean up any accounting records for dead "godchildren".
7637c478bd9Sstevel@tonic-gate 		 */
7647c478bd9Sstevel@tonic-gate 		if (Gchild)
7657c478bd9Sstevel@tonic-gate 			cleanaux();
7667c478bd9Sstevel@tonic-gate 
7677c478bd9Sstevel@tonic-gate 		/*
7687c478bd9Sstevel@tonic-gate 		 * If in "normal" mode, check all living processes and initiate
7697c478bd9Sstevel@tonic-gate 		 * kill sequence on those that should not be there anymore.
7707c478bd9Sstevel@tonic-gate 		 */
7717c478bd9Sstevel@tonic-gate 		if (op_modes == NORMAL_MODES && cur_state != LVLa &&
7727c478bd9Sstevel@tonic-gate 		    cur_state != LVLb && cur_state != LVLc)
7737c478bd9Sstevel@tonic-gate 			remv();
7747c478bd9Sstevel@tonic-gate 
7757c478bd9Sstevel@tonic-gate 		/*
7767c478bd9Sstevel@tonic-gate 		 * If a change in run levels is the reason we awoke, now do
7777c478bd9Sstevel@tonic-gate 		 * the accounting to report the change in the utmp file.
7787c478bd9Sstevel@tonic-gate 		 * Also report the change on the system console.
7797c478bd9Sstevel@tonic-gate 		 */
7807c478bd9Sstevel@tonic-gate 		if (chg_lvl_flag) {
7817c478bd9Sstevel@tonic-gate 			chg_lvl_flag = FALSE;
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate 			if (state_to_flags(cur_state) & LSEL_RUNLEVEL) {
7847c478bd9Sstevel@tonic-gate 				char rl = state_to_name(cur_state);
7857c478bd9Sstevel@tonic-gate 
7867c478bd9Sstevel@tonic-gate 				if (rl != -1)
7877c478bd9Sstevel@tonic-gate 					lscf_set_runlevel(rl);
7887c478bd9Sstevel@tonic-gate 			}
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate 			may_need_audit = 1;
7917c478bd9Sstevel@tonic-gate 		}
7927c478bd9Sstevel@tonic-gate 
7937c478bd9Sstevel@tonic-gate 		/*
7947c478bd9Sstevel@tonic-gate 		 * Scan the inittab file and spawn and respawn processes that
7957c478bd9Sstevel@tonic-gate 		 * should be alive in the current state. If inittab does not
7967c478bd9Sstevel@tonic-gate 		 * exist default to  single user mode.
7977c478bd9Sstevel@tonic-gate 		 */
7987c478bd9Sstevel@tonic-gate 		if (spawn_processes() == FAILURE) {
7997c478bd9Sstevel@tonic-gate 			prior_state = prev_state;
8007c478bd9Sstevel@tonic-gate 			cur_state = SINGLE_USER;
8017c478bd9Sstevel@tonic-gate 		}
8027c478bd9Sstevel@tonic-gate 
8037c478bd9Sstevel@tonic-gate 		/* If any respawns occurred, take note. */
8047c478bd9Sstevel@tonic-gate 		if (rsflag) {
8057c478bd9Sstevel@tonic-gate 			rsflag = 0;
8067c478bd9Sstevel@tonic-gate 			spawncnt++;
8077c478bd9Sstevel@tonic-gate 		}
8087c478bd9Sstevel@tonic-gate 
8097c478bd9Sstevel@tonic-gate 		/*
8107c478bd9Sstevel@tonic-gate 		 * If a powerfail signal was received during the last
8117c478bd9Sstevel@tonic-gate 		 * sequence, set mode to powerfail.  When spawn_processes() is
8127c478bd9Sstevel@tonic-gate 		 * entered the first thing it does is to check "powerhit".  If
8137c478bd9Sstevel@tonic-gate 		 * it is in PF_MODES then it clears "powerhit" and does
8147c478bd9Sstevel@tonic-gate 		 * a powerfail sequence.  If it is not in PF_MODES, then it
8157c478bd9Sstevel@tonic-gate 		 * puts itself in PF_MODES and then clears "powerhit".  Should
8167c478bd9Sstevel@tonic-gate 		 * "powerhit" get set again while spawn_processes() is working
8177c478bd9Sstevel@tonic-gate 		 * on a powerfail sequence, the following code  will see that
8187c478bd9Sstevel@tonic-gate 		 * spawn_processes() tries to execute the powerfail sequence
8197c478bd9Sstevel@tonic-gate 		 * again.  This guarantees that the powerfail sequence will be
8207c478bd9Sstevel@tonic-gate 		 * successfully completed before further processing takes
8217c478bd9Sstevel@tonic-gate 		 * place.
8227c478bd9Sstevel@tonic-gate 		 */
8237c478bd9Sstevel@tonic-gate 		if (wakeup.w_flags.w_powerhit) {
8247c478bd9Sstevel@tonic-gate 			op_modes = PF_MODES;
8257c478bd9Sstevel@tonic-gate 			/*
8267c478bd9Sstevel@tonic-gate 			 * Make sure that cur_state != prev_state so that
8277c478bd9Sstevel@tonic-gate 			 * ONCE and WAIT types work.
8287c478bd9Sstevel@tonic-gate 			 */
8297c478bd9Sstevel@tonic-gate 			prev_state = 0;
8307c478bd9Sstevel@tonic-gate 		} else if (op_modes != NORMAL_MODES) {
8317c478bd9Sstevel@tonic-gate 			/*
8327c478bd9Sstevel@tonic-gate 			 * If spawn_processes() was not just called while in
8337c478bd9Sstevel@tonic-gate 			 * normal mode, we set the mode to normal and it will
8347c478bd9Sstevel@tonic-gate 			 * be called again to check normal modes.  If we have
8357c478bd9Sstevel@tonic-gate 			 * just finished a powerfail sequence with prev_state
8367c478bd9Sstevel@tonic-gate 			 * equal to zero, we set prev_state equal to cur_state
8377c478bd9Sstevel@tonic-gate 			 * before the next pass through.
8387c478bd9Sstevel@tonic-gate 			 */
8397c478bd9Sstevel@tonic-gate 			if (op_modes == PF_MODES)
8407c478bd9Sstevel@tonic-gate 				prev_state = cur_state;
8417c478bd9Sstevel@tonic-gate 			op_modes = NORMAL_MODES;
8427c478bd9Sstevel@tonic-gate 		} else if (cur_state == LVLa || cur_state == LVLb ||
8437c478bd9Sstevel@tonic-gate 		    cur_state == LVLc) {
8447c478bd9Sstevel@tonic-gate 			/*
8457c478bd9Sstevel@tonic-gate 			 * If it was a change of levels that awakened us and the
8467c478bd9Sstevel@tonic-gate 			 * new level is one of the demand levels then reset
8477c478bd9Sstevel@tonic-gate 			 * cur_state to the previous state and do another scan
8487c478bd9Sstevel@tonic-gate 			 * to take care of the usual respawn actions.
8497c478bd9Sstevel@tonic-gate 			 */
8507c478bd9Sstevel@tonic-gate 			cur_state = prior_state;
8517c478bd9Sstevel@tonic-gate 			prior_state = prev_state;
8527c478bd9Sstevel@tonic-gate 			prev_state = cur_state;
8537c478bd9Sstevel@tonic-gate 		} else {
8547c478bd9Sstevel@tonic-gate 			prev_state = cur_state;
8557c478bd9Sstevel@tonic-gate 
8567c478bd9Sstevel@tonic-gate 			if (wakeup.w_mask == 0) {
8577c478bd9Sstevel@tonic-gate 				int ret;
8587c478bd9Sstevel@tonic-gate 
8597c478bd9Sstevel@tonic-gate 				if (may_need_audit && (cur_state == LVL3)) {
8607c478bd9Sstevel@tonic-gate 					msg = audit_boot_msg();
8617c478bd9Sstevel@tonic-gate 
8627c478bd9Sstevel@tonic-gate 					may_need_audit = 0;
8637c478bd9Sstevel@tonic-gate 					(void) audit_put_record(ADT_SUCCESS,
8647c478bd9Sstevel@tonic-gate 					    ADT_SUCCESS, msg);
8657c478bd9Sstevel@tonic-gate 					free(msg);
8667c478bd9Sstevel@tonic-gate 				}
8677c478bd9Sstevel@tonic-gate 
8687c478bd9Sstevel@tonic-gate 				/*
8697c478bd9Sstevel@tonic-gate 				 * "init" is finished with all actions for
8707c478bd9Sstevel@tonic-gate 				 * the current wakeup.
8717c478bd9Sstevel@tonic-gate 				 */
8727c478bd9Sstevel@tonic-gate 				ret = poll(poll_fds, poll_nfds,
8737c478bd9Sstevel@tonic-gate 				    SLEEPTIME * MILLISEC);
8747c478bd9Sstevel@tonic-gate 				pausecnt++;
8757c478bd9Sstevel@tonic-gate 				if (ret > 0)
8767c478bd9Sstevel@tonic-gate 					contract_event(&poll_fds[0]);
8777c478bd9Sstevel@tonic-gate 				else if (ret < 0 && errno != EINTR)
8787c478bd9Sstevel@tonic-gate 					console(B_TRUE, "poll() error: %s\n",
8797c478bd9Sstevel@tonic-gate 					    strerror(errno));
8807c478bd9Sstevel@tonic-gate 			}
8817c478bd9Sstevel@tonic-gate 
8827c478bd9Sstevel@tonic-gate 			if (wakeup.w_flags.w_usersignal) {
8837c478bd9Sstevel@tonic-gate 				/*
8847c478bd9Sstevel@tonic-gate 				 * Install the new level.  This could be a real
8857c478bd9Sstevel@tonic-gate 				 * change in levels  or a telinit [Q|a|b|c] or
8867c478bd9Sstevel@tonic-gate 				 * just a telinit to the same level at which
8877c478bd9Sstevel@tonic-gate 				 * we are running.
8887c478bd9Sstevel@tonic-gate 				 */
8897c478bd9Sstevel@tonic-gate 				if (new_state != cur_state) {
8907c478bd9Sstevel@tonic-gate 					if (new_state == LVLa ||
8917c478bd9Sstevel@tonic-gate 					    new_state == LVLb ||
8927c478bd9Sstevel@tonic-gate 					    new_state == LVLc) {
8937c478bd9Sstevel@tonic-gate 						prev_state = prior_state;
8947c478bd9Sstevel@tonic-gate 						prior_state = cur_state;
8957c478bd9Sstevel@tonic-gate 						cur_state = new_state;
8967c478bd9Sstevel@tonic-gate 					} else {
8977c478bd9Sstevel@tonic-gate 						prev_state = cur_state;
8987c478bd9Sstevel@tonic-gate 						if (cur_state >= 0)
8997c478bd9Sstevel@tonic-gate 							prior_state = cur_state;
9007c478bd9Sstevel@tonic-gate 						cur_state = new_state;
9017c478bd9Sstevel@tonic-gate 						chg_lvl_flag = TRUE;
9027c478bd9Sstevel@tonic-gate 					}
9037c478bd9Sstevel@tonic-gate 				}
9047c478bd9Sstevel@tonic-gate 
9057c478bd9Sstevel@tonic-gate 				new_state = 0;
9067c478bd9Sstevel@tonic-gate 			}
9077c478bd9Sstevel@tonic-gate 
9087c478bd9Sstevel@tonic-gate 			if (wakeup.w_flags.w_powerhit)
9097c478bd9Sstevel@tonic-gate 				op_modes = PF_MODES;
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate 			/*
9127c478bd9Sstevel@tonic-gate 			 * Clear all wakeup reasons.
9137c478bd9Sstevel@tonic-gate 			 */
9147c478bd9Sstevel@tonic-gate 			wakeup.w_mask = 0;
9157c478bd9Sstevel@tonic-gate 		}
9167c478bd9Sstevel@tonic-gate 	}
9177c478bd9Sstevel@tonic-gate 
9187c478bd9Sstevel@tonic-gate 	/*NOTREACHED*/
9197c478bd9Sstevel@tonic-gate }
9207c478bd9Sstevel@tonic-gate 
9216112cec5SJoshua M. Clulow static void
9226112cec5SJoshua M. Clulow init_bootbanner_print(const char *line, uint_t num)
9236112cec5SJoshua M. Clulow {
9246112cec5SJoshua M. Clulow 	const char *pfx = (num == 0) ? "\n\n" : "";
9256112cec5SJoshua M. Clulow 
9266112cec5SJoshua M. Clulow 	console(B_FALSE, "%s%s\r\n", pfx, line);
9276112cec5SJoshua M. Clulow }
9286112cec5SJoshua M. Clulow 
9297c478bd9Sstevel@tonic-gate static void
9307c478bd9Sstevel@tonic-gate update_boot_archive(int new_state)
9317c478bd9Sstevel@tonic-gate {
9327c478bd9Sstevel@tonic-gate 	if (new_state != LVL0 && new_state != LVL5 && new_state != LVL6)
9337c478bd9Sstevel@tonic-gate 		return;
9347c478bd9Sstevel@tonic-gate 
9357c478bd9Sstevel@tonic-gate 	if (getzoneid() != GLOBAL_ZONEID)
9367c478bd9Sstevel@tonic-gate 		return;
9377c478bd9Sstevel@tonic-gate 
93848847494SEnrico Perla - Sun Microsystems 	(void) system("/sbin/bootadm -ea update_all");
9397c478bd9Sstevel@tonic-gate }
9407c478bd9Sstevel@tonic-gate 
9417c478bd9Sstevel@tonic-gate /*
9427c478bd9Sstevel@tonic-gate  * void enter_maintenance()
9437c478bd9Sstevel@tonic-gate  *   A simple invocation of sulogin(1M), with no baggage, in the case that we
9447c478bd9Sstevel@tonic-gate  *   are unable to activate svc.startd(1M).  We fork; the child runs sulogin;
9457c478bd9Sstevel@tonic-gate  *   we wait for it to exit.
9467c478bd9Sstevel@tonic-gate  */
9477c478bd9Sstevel@tonic-gate static void
9487c478bd9Sstevel@tonic-gate enter_maintenance()
9497c478bd9Sstevel@tonic-gate {
9507c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*su_process;
9517c478bd9Sstevel@tonic-gate 
9527c478bd9Sstevel@tonic-gate 	console(B_FALSE, "Requesting maintenance mode\n"
9537c478bd9Sstevel@tonic-gate 	    "(See /lib/svc/share/README for additional information.)\n");
954c39ec064SRoger A. Faulkner 	(void) sighold(SIGCLD);
9557c478bd9Sstevel@tonic-gate 	while ((su_process = efork(M_OFF, NULLPROC, NOCLEANUP)) == NO_ROOM)
9567c478bd9Sstevel@tonic-gate 		(void) pause();
957c39ec064SRoger A. Faulkner 	(void) sigrelse(SIGCLD);
9587c478bd9Sstevel@tonic-gate 	if (su_process == NULLPROC) {
9597c478bd9Sstevel@tonic-gate 		int fd;
9607c478bd9Sstevel@tonic-gate 
9617c478bd9Sstevel@tonic-gate 		(void) fclose(stdin);
9627c478bd9Sstevel@tonic-gate 		(void) fclose(stdout);
9637c478bd9Sstevel@tonic-gate 		(void) fclose(stderr);
9647c478bd9Sstevel@tonic-gate 		closefrom(0);
9657c478bd9Sstevel@tonic-gate 
9667c478bd9Sstevel@tonic-gate 		fd = open(SYSCON, O_RDWR | O_NOCTTY);
9677c478bd9Sstevel@tonic-gate 		if (fd >= 0) {
9687c478bd9Sstevel@tonic-gate 			(void) dup2(fd, 1);
9697c478bd9Sstevel@tonic-gate 			(void) dup2(fd, 2);
9707c478bd9Sstevel@tonic-gate 		} else {
9717c478bd9Sstevel@tonic-gate 			/*
9727c478bd9Sstevel@tonic-gate 			 * Need to issue an error message somewhere.
9737c478bd9Sstevel@tonic-gate 			 */
9747c478bd9Sstevel@tonic-gate 			syslog(LOG_CRIT, "init[%d]: cannot open %s; %s\n",
9757c478bd9Sstevel@tonic-gate 			    getpid(), SYSCON, strerror(errno));
9767c478bd9Sstevel@tonic-gate 		}
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate 		/*
9797c478bd9Sstevel@tonic-gate 		 * Execute the "su" program.
9807c478bd9Sstevel@tonic-gate 		 */
9817c478bd9Sstevel@tonic-gate 		(void) execle(SU, SU, "-", (char *)0, glob_envp);
9827c478bd9Sstevel@tonic-gate 		console(B_TRUE, "execle of %s failed: %s\n", SU,
9837c478bd9Sstevel@tonic-gate 		    strerror(errno));
9847c478bd9Sstevel@tonic-gate 		timer(5);
9857c478bd9Sstevel@tonic-gate 		exit(1);
9867c478bd9Sstevel@tonic-gate 	}
9877c478bd9Sstevel@tonic-gate 
9887c478bd9Sstevel@tonic-gate 	/*
9897c478bd9Sstevel@tonic-gate 	 * If we are the parent, wait around for the child to die
9907c478bd9Sstevel@tonic-gate 	 * or for "init" to be signaled to change levels.
9917c478bd9Sstevel@tonic-gate 	 */
9927c478bd9Sstevel@tonic-gate 	while (waitproc(su_process) == FAILURE) {
9937c478bd9Sstevel@tonic-gate 		/*
9947c478bd9Sstevel@tonic-gate 		 * All other reasons for waking are ignored when in
9957c478bd9Sstevel@tonic-gate 		 * single-user mode.  The only child we are interested
9967c478bd9Sstevel@tonic-gate 		 * in is being waited for explicitly by waitproc().
9977c478bd9Sstevel@tonic-gate 		 */
9987c478bd9Sstevel@tonic-gate 		wakeup.w_mask = 0;
9997c478bd9Sstevel@tonic-gate 	}
10007c478bd9Sstevel@tonic-gate }
10017c478bd9Sstevel@tonic-gate 
10027c478bd9Sstevel@tonic-gate /*
10037c478bd9Sstevel@tonic-gate  * remv() scans through "proc_table" and performs cleanup.  If
10047c478bd9Sstevel@tonic-gate  * there is a process in the table, which shouldn't be here at
10057c478bd9Sstevel@tonic-gate  * the current run level, then remv() kills the process.
10067c478bd9Sstevel@tonic-gate  */
10077c478bd9Sstevel@tonic-gate static void
10087c478bd9Sstevel@tonic-gate remv()
10097c478bd9Sstevel@tonic-gate {
10107c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*process;
10117c478bd9Sstevel@tonic-gate 	struct CMD_LINE		cmd;
10127c478bd9Sstevel@tonic-gate 	char			cmd_string[MAXCMDL];
10137c478bd9Sstevel@tonic-gate 	int			change_level;
10147c478bd9Sstevel@tonic-gate 
10157c478bd9Sstevel@tonic-gate 	change_level = (cur_state != prev_state ? TRUE : FALSE);
10167c478bd9Sstevel@tonic-gate 
10177c478bd9Sstevel@tonic-gate 	/*
10187c478bd9Sstevel@tonic-gate 	 * Clear the TOUCHED flag on all entries so that when we have
10197c478bd9Sstevel@tonic-gate 	 * finished scanning inittab, we will be able to tell if we
10207c478bd9Sstevel@tonic-gate 	 * have any processes for which there is no entry in inittab.
10217c478bd9Sstevel@tonic-gate 	 */
10227c478bd9Sstevel@tonic-gate 	for (process = proc_table;
10237c478bd9Sstevel@tonic-gate 	    (process < proc_table + num_proc); process++) {
10247c478bd9Sstevel@tonic-gate 		process->p_flags &= ~TOUCHED;
10257c478bd9Sstevel@tonic-gate 	}
10267c478bd9Sstevel@tonic-gate 
10277c478bd9Sstevel@tonic-gate 	/*
10287c478bd9Sstevel@tonic-gate 	 * Scan all inittab entries.
10297c478bd9Sstevel@tonic-gate 	 */
10307c478bd9Sstevel@tonic-gate 	while (getcmd(&cmd, &cmd_string[0]) == TRUE) {
10317c478bd9Sstevel@tonic-gate 		/* Scan for process which goes with this entry in inittab. */
10327c478bd9Sstevel@tonic-gate 		for (process = proc_table;
10337c478bd9Sstevel@tonic-gate 		    (process < proc_table + num_proc); process++) {
10347c478bd9Sstevel@tonic-gate 			if ((process->p_flags & OCCUPIED) == 0 ||
10357c478bd9Sstevel@tonic-gate 			    !id_eq(process->p_id, cmd.c_id))
10367c478bd9Sstevel@tonic-gate 				continue;
10377c478bd9Sstevel@tonic-gate 
10387c478bd9Sstevel@tonic-gate 			/*
10397c478bd9Sstevel@tonic-gate 			 * This slot contains the process we are looking for.
10407c478bd9Sstevel@tonic-gate 			 */
10417c478bd9Sstevel@tonic-gate 
10427c478bd9Sstevel@tonic-gate 			/*
10437c478bd9Sstevel@tonic-gate 			 * Is the cur_state SINGLE_USER or is this process
10447c478bd9Sstevel@tonic-gate 			 * marked as "off" or was this proc started by some
10457c478bd9Sstevel@tonic-gate 			 * mechanism other than LVL{a|b|c} and the current level
10467c478bd9Sstevel@tonic-gate 			 * does not support this process?
10477c478bd9Sstevel@tonic-gate 			 */
10487c478bd9Sstevel@tonic-gate 			if (cur_state == SINGLE_USER ||
10497c478bd9Sstevel@tonic-gate 			    cmd.c_action == M_OFF ||
10507c478bd9Sstevel@tonic-gate 			    ((cmd.c_levels & state_to_mask(cur_state)) == 0 &&
10517c478bd9Sstevel@tonic-gate 			    (process->p_flags & DEMANDREQUEST) == 0)) {
10527c478bd9Sstevel@tonic-gate 				if (process->p_flags & LIVING) {
10537c478bd9Sstevel@tonic-gate 					/*
10547c478bd9Sstevel@tonic-gate 					 * Touch this entry so we know we have
10557c478bd9Sstevel@tonic-gate 					 * treated it.  Note that procs which
10567c478bd9Sstevel@tonic-gate 					 * are already dead at this point and
10577c478bd9Sstevel@tonic-gate 					 * should not be restarted are left
10587c478bd9Sstevel@tonic-gate 					 * untouched.  This causes their slot to
10597c478bd9Sstevel@tonic-gate 					 * be freed later after dead accounting
10607c478bd9Sstevel@tonic-gate 					 * is done.
10617c478bd9Sstevel@tonic-gate 					 */
10627c478bd9Sstevel@tonic-gate 					process->p_flags |= TOUCHED;
10637c478bd9Sstevel@tonic-gate 
10647c478bd9Sstevel@tonic-gate 					if ((process->p_flags & KILLED) == 0) {
10657c478bd9Sstevel@tonic-gate 						if (change_level) {
10667c478bd9Sstevel@tonic-gate 							process->p_flags
10677c478bd9Sstevel@tonic-gate 							    |= WARNED;
10687c478bd9Sstevel@tonic-gate 							(void) kill(
10697c478bd9Sstevel@tonic-gate 							    process->p_pid,
10707c478bd9Sstevel@tonic-gate 							    SIGTERM);
10717c478bd9Sstevel@tonic-gate 						} else {
10727c478bd9Sstevel@tonic-gate 							/*
10737c478bd9Sstevel@tonic-gate 							 * Fork a killing proc
10747c478bd9Sstevel@tonic-gate 							 * so "init" can
10757c478bd9Sstevel@tonic-gate 							 * continue without
10767c478bd9Sstevel@tonic-gate 							 * having to pause for
10777c478bd9Sstevel@tonic-gate 							 * TWARN seconds.
10787c478bd9Sstevel@tonic-gate 							 */
10797c478bd9Sstevel@tonic-gate 							killproc(
10807c478bd9Sstevel@tonic-gate 							    process->p_pid);
10817c478bd9Sstevel@tonic-gate 						}
10827c478bd9Sstevel@tonic-gate 						process->p_flags |= KILLED;
10837c478bd9Sstevel@tonic-gate 					}
10847c478bd9Sstevel@tonic-gate 				}
10857c478bd9Sstevel@tonic-gate 			} else {
10867c478bd9Sstevel@tonic-gate 				/*
10877c478bd9Sstevel@tonic-gate 				 * Process can exist at current level.  If it is
10887c478bd9Sstevel@tonic-gate 				 * still alive or a DEMANDREQUEST we touch it so
10897c478bd9Sstevel@tonic-gate 				 * it will be left alone.  Otherwise we leave it
10907c478bd9Sstevel@tonic-gate 				 * untouched so it will be accounted for and
10917c478bd9Sstevel@tonic-gate 				 * cleaned up later in remv().  Dead
10927c478bd9Sstevel@tonic-gate 				 * DEMANDREQUESTs will be accounted but not
10937c478bd9Sstevel@tonic-gate 				 * freed.
10947c478bd9Sstevel@tonic-gate 				 */
10957c478bd9Sstevel@tonic-gate 				if (process->p_flags &
10967c478bd9Sstevel@tonic-gate 				    (LIVING|NOCLEANUP|DEMANDREQUEST))
10977c478bd9Sstevel@tonic-gate 					process->p_flags |= TOUCHED;
10987c478bd9Sstevel@tonic-gate 			}
10997c478bd9Sstevel@tonic-gate 
11007c478bd9Sstevel@tonic-gate 			break;
11017c478bd9Sstevel@tonic-gate 		}
11027c478bd9Sstevel@tonic-gate 	}
11037c478bd9Sstevel@tonic-gate 
11047c478bd9Sstevel@tonic-gate 	st_write();
11057c478bd9Sstevel@tonic-gate 
11067c478bd9Sstevel@tonic-gate 	/*
11077c478bd9Sstevel@tonic-gate 	 * If this was a change of levels call, scan through the
11087c478bd9Sstevel@tonic-gate 	 * process table for processes that were warned to die.  If any
11097c478bd9Sstevel@tonic-gate 	 * are found that haven't left yet, sleep for TWARN seconds and
11107c478bd9Sstevel@tonic-gate 	 * then send final terminations to any that haven't died yet.
11117c478bd9Sstevel@tonic-gate 	 */
11127c478bd9Sstevel@tonic-gate 	if (change_level) {
11137c478bd9Sstevel@tonic-gate 
11147c478bd9Sstevel@tonic-gate 		/*
11157c478bd9Sstevel@tonic-gate 		 * Set the alarm for TWARN seconds on the assumption
11167c478bd9Sstevel@tonic-gate 		 * that there will be some that need to be waited for.
11177c478bd9Sstevel@tonic-gate 		 * This won't harm anything except we are guaranteed to
11187c478bd9Sstevel@tonic-gate 		 * wakeup in TWARN seconds whether we need to or not.
11197c478bd9Sstevel@tonic-gate 		 */
11207c478bd9Sstevel@tonic-gate 		setimer(TWARN);
11217c478bd9Sstevel@tonic-gate 
11227c478bd9Sstevel@tonic-gate 		/*
11237c478bd9Sstevel@tonic-gate 		 * Scan for processes which should be dying.  We hope they
11247c478bd9Sstevel@tonic-gate 		 * will die without having to be sent a SIGKILL signal.
11257c478bd9Sstevel@tonic-gate 		 */
11267c478bd9Sstevel@tonic-gate 		for (process = proc_table;
11277c478bd9Sstevel@tonic-gate 		    (process < proc_table + num_proc); process++) {
11287c478bd9Sstevel@tonic-gate 			/*
11297c478bd9Sstevel@tonic-gate 			 * If this process should die, hasn't yet, and the
11307c478bd9Sstevel@tonic-gate 			 * TWARN time hasn't expired yet, wait for process
11317c478bd9Sstevel@tonic-gate 			 * to die or for timer to expire.
11327c478bd9Sstevel@tonic-gate 			 */
11337c478bd9Sstevel@tonic-gate 			while (time_up == FALSE &&
11347c478bd9Sstevel@tonic-gate 			    (process->p_flags & (WARNED|LIVING|OCCUPIED)) ==
11357c478bd9Sstevel@tonic-gate 			    (WARNED|LIVING|OCCUPIED))
11367c478bd9Sstevel@tonic-gate 				(void) pause();
11377c478bd9Sstevel@tonic-gate 
11387c478bd9Sstevel@tonic-gate 			if (time_up == TRUE)
11397c478bd9Sstevel@tonic-gate 				break;
11407c478bd9Sstevel@tonic-gate 		}
11417c478bd9Sstevel@tonic-gate 
11427c478bd9Sstevel@tonic-gate 		/*
11437c478bd9Sstevel@tonic-gate 		 * If we reached the end of the table without the timer
11447c478bd9Sstevel@tonic-gate 		 * expiring, then there are no procs which will have to be
11457c478bd9Sstevel@tonic-gate 		 * sent the SIGKILL signal.  If the timer has expired, then
11467c478bd9Sstevel@tonic-gate 		 * it is necessary to scan the table again and send signals
11477c478bd9Sstevel@tonic-gate 		 * to all processes which aren't going away nicely.
11487c478bd9Sstevel@tonic-gate 		 */
11497c478bd9Sstevel@tonic-gate 		if (time_up == TRUE) {
11507c478bd9Sstevel@tonic-gate 			for (process = proc_table;
11517c478bd9Sstevel@tonic-gate 			    (process < proc_table + num_proc); process++) {
11527c478bd9Sstevel@tonic-gate 				if ((process->p_flags &
11537c478bd9Sstevel@tonic-gate 				    (WARNED|LIVING|OCCUPIED)) ==
11547c478bd9Sstevel@tonic-gate 				    (WARNED|LIVING|OCCUPIED))
11557c478bd9Sstevel@tonic-gate 					(void) kill(process->p_pid, SIGKILL);
11567c478bd9Sstevel@tonic-gate 			}
11577c478bd9Sstevel@tonic-gate 		}
11587c478bd9Sstevel@tonic-gate 		setimer(0);
11597c478bd9Sstevel@tonic-gate 	}
11607c478bd9Sstevel@tonic-gate 
11617c478bd9Sstevel@tonic-gate 	/*
11627c478bd9Sstevel@tonic-gate 	 * Rescan the proc_table for two kinds of entry, those marked LIVING,
11637c478bd9Sstevel@tonic-gate 	 * NAMED, which don't have an entry in inittab (haven't been TOUCHED
11647c478bd9Sstevel@tonic-gate 	 * by the above scanning), and haven't been sent kill signals, and
11657c478bd9Sstevel@tonic-gate 	 * those entries marked not LIVING, NAMED.  The former procs are killed.
11667c478bd9Sstevel@tonic-gate 	 * The latter have DEAD_PROCESS accounting done and the slot cleared.
11677c478bd9Sstevel@tonic-gate 	 */
11687c478bd9Sstevel@tonic-gate 	for (process = proc_table;
11697c478bd9Sstevel@tonic-gate 	    (process < proc_table + num_proc); process++) {
11707c478bd9Sstevel@tonic-gate 		if ((process->p_flags & (LIVING|NAMED|TOUCHED|KILLED|OCCUPIED))
11717c478bd9Sstevel@tonic-gate 		    == (LIVING|NAMED|OCCUPIED)) {
11727c478bd9Sstevel@tonic-gate 			killproc(process->p_pid);
11737c478bd9Sstevel@tonic-gate 			process->p_flags |= KILLED;
11747c478bd9Sstevel@tonic-gate 		} else if ((process->p_flags & (LIVING|NAMED|OCCUPIED)) ==
11757c478bd9Sstevel@tonic-gate 		    (NAMED|OCCUPIED)) {
11767c478bd9Sstevel@tonic-gate 			(void) account(DEAD_PROCESS, process, NULL);
11777c478bd9Sstevel@tonic-gate 			/*
11787c478bd9Sstevel@tonic-gate 			 * If this named proc hasn't been TOUCHED, then free the
11797c478bd9Sstevel@tonic-gate 			 * space. It has either died of it's own accord, but
11807c478bd9Sstevel@tonic-gate 			 * isn't respawnable or it was killed because it
11817c478bd9Sstevel@tonic-gate 			 * shouldn't exist at this level.
11827c478bd9Sstevel@tonic-gate 			 */
11837c478bd9Sstevel@tonic-gate 			if ((process->p_flags & TOUCHED) == 0)
11847c478bd9Sstevel@tonic-gate 				process->p_flags = 0;
11857c478bd9Sstevel@tonic-gate 		}
11867c478bd9Sstevel@tonic-gate 	}
11877c478bd9Sstevel@tonic-gate 
11887c478bd9Sstevel@tonic-gate 	st_write();
11897c478bd9Sstevel@tonic-gate }
11907c478bd9Sstevel@tonic-gate 
11917c478bd9Sstevel@tonic-gate /*
11927c478bd9Sstevel@tonic-gate  * Extract the svc.startd command line and whether to restart it from its
11937c478bd9Sstevel@tonic-gate  * inittab entry.
11947c478bd9Sstevel@tonic-gate  */
11957c478bd9Sstevel@tonic-gate /*ARGSUSED*/
11967c478bd9Sstevel@tonic-gate static void
11977c478bd9Sstevel@tonic-gate process_startd_line(struct CMD_LINE *cmd, char *cmd_string)
11987c478bd9Sstevel@tonic-gate {
11997c478bd9Sstevel@tonic-gate 	size_t sz;
12007c478bd9Sstevel@tonic-gate 
12017c478bd9Sstevel@tonic-gate 	/* Save the command line. */
12027c478bd9Sstevel@tonic-gate 	if (sflg || rflg) {
12037c478bd9Sstevel@tonic-gate 		/* Also append -r or -s. */
12047c478bd9Sstevel@tonic-gate 		(void) strlcpy(startd_cline, cmd_string, sizeof (startd_cline));
12057c478bd9Sstevel@tonic-gate 		(void) strlcat(startd_cline, " -", sizeof (startd_cline));
12067c478bd9Sstevel@tonic-gate 		if (sflg)
12077c478bd9Sstevel@tonic-gate 			sz = strlcat(startd_cline, "s", sizeof (startd_cline));
12087c478bd9Sstevel@tonic-gate 		if (rflg)
12097c478bd9Sstevel@tonic-gate 			sz = strlcat(startd_cline, "r", sizeof (startd_cline));
12107c478bd9Sstevel@tonic-gate 	} else {
12117c478bd9Sstevel@tonic-gate 		sz = strlcpy(startd_cline, cmd_string, sizeof (startd_cline));
12127c478bd9Sstevel@tonic-gate 	}
12137c478bd9Sstevel@tonic-gate 
12147c478bd9Sstevel@tonic-gate 	if (sz >= sizeof (startd_cline)) {
12157c478bd9Sstevel@tonic-gate 		console(B_TRUE,
12167c478bd9Sstevel@tonic-gate 		    "svc.startd command line too long.  Ignoring.\n");
12177c478bd9Sstevel@tonic-gate 		startd_cline[0] = '\0';
12187c478bd9Sstevel@tonic-gate 		return;
12197c478bd9Sstevel@tonic-gate 	}
12207c478bd9Sstevel@tonic-gate }
12217c478bd9Sstevel@tonic-gate 
12227c478bd9Sstevel@tonic-gate /*
12237c478bd9Sstevel@tonic-gate  * spawn_processes() scans inittab for entries which should be run at this
12247c478bd9Sstevel@tonic-gate  * mode.  Processes which should be running but are not, are started.
12257c478bd9Sstevel@tonic-gate  */
12267c478bd9Sstevel@tonic-gate static int
12277c478bd9Sstevel@tonic-gate spawn_processes()
12287c478bd9Sstevel@tonic-gate {
12297c478bd9Sstevel@tonic-gate 	struct PROC_TABLE		*pp;
12307c478bd9Sstevel@tonic-gate 	struct CMD_LINE			cmd;
12317c478bd9Sstevel@tonic-gate 	char				cmd_string[MAXCMDL];
12327c478bd9Sstevel@tonic-gate 	short				lvl_mask;
12337c478bd9Sstevel@tonic-gate 	int				status;
12347c478bd9Sstevel@tonic-gate 
12357c478bd9Sstevel@tonic-gate 	/*
12367c478bd9Sstevel@tonic-gate 	 * First check the "powerhit" flag.  If it is set, make sure the modes
12377c478bd9Sstevel@tonic-gate 	 * are PF_MODES and clear the "powerhit" flag.  Avoid the possible race
12387c478bd9Sstevel@tonic-gate 	 * on the "powerhit" flag by disallowing a new powerfail interrupt
12397c478bd9Sstevel@tonic-gate 	 * between the test of the powerhit flag and the clearing of it.
12407c478bd9Sstevel@tonic-gate 	 */
12417c478bd9Sstevel@tonic-gate 	if (wakeup.w_flags.w_powerhit) {
12427c478bd9Sstevel@tonic-gate 		wakeup.w_flags.w_powerhit = 0;
12437c478bd9Sstevel@tonic-gate 		op_modes = PF_MODES;
12447c478bd9Sstevel@tonic-gate 	}
12457c478bd9Sstevel@tonic-gate 	lvl_mask = state_to_mask(cur_state);
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate 	/*
12487c478bd9Sstevel@tonic-gate 	 * Scan through all the entries in inittab.
12497c478bd9Sstevel@tonic-gate 	 */
12507c478bd9Sstevel@tonic-gate 	while ((status = getcmd(&cmd, &cmd_string[0])) == TRUE) {
12517c478bd9Sstevel@tonic-gate 		if (id_eq(cmd.c_id, "smf")) {
12527c478bd9Sstevel@tonic-gate 			process_startd_line(&cmd, cmd_string);
12537c478bd9Sstevel@tonic-gate 			continue;
12547c478bd9Sstevel@tonic-gate 		}
12557c478bd9Sstevel@tonic-gate 
12567c478bd9Sstevel@tonic-gate retry_for_proc_slot:
12577c478bd9Sstevel@tonic-gate 
12587c478bd9Sstevel@tonic-gate 		/*
12597c478bd9Sstevel@tonic-gate 		 * Find out if there is a process slot for this entry already.
12607c478bd9Sstevel@tonic-gate 		 */
12617c478bd9Sstevel@tonic-gate 		if ((pp = findpslot(&cmd)) == NULLPROC) {
12627c478bd9Sstevel@tonic-gate 			/*
12637c478bd9Sstevel@tonic-gate 			 * we've run out of proc table entries
12647c478bd9Sstevel@tonic-gate 			 * increase proc_table.
12657c478bd9Sstevel@tonic-gate 			 */
12667c478bd9Sstevel@tonic-gate 			increase_proc_table_size();
12677c478bd9Sstevel@tonic-gate 
12687c478bd9Sstevel@tonic-gate 			/*
12697c478bd9Sstevel@tonic-gate 			 * Retry now as we have an empty proc slot.
12707c478bd9Sstevel@tonic-gate 			 * In case increase_proc_table_size() fails,
12717c478bd9Sstevel@tonic-gate 			 * we will keep retrying.
12727c478bd9Sstevel@tonic-gate 			 */
12737c478bd9Sstevel@tonic-gate 			goto retry_for_proc_slot;
12747c478bd9Sstevel@tonic-gate 		}
12757c478bd9Sstevel@tonic-gate 
12767c478bd9Sstevel@tonic-gate 		/*
12777c478bd9Sstevel@tonic-gate 		 * If there is an entry, and it is marked as DEMANDREQUEST,
12787c478bd9Sstevel@tonic-gate 		 * one of the levels a, b, or c is in its levels mask, and
12797c478bd9Sstevel@tonic-gate 		 * the action field is ONDEMAND and ONDEMAND is a permissable
12807c478bd9Sstevel@tonic-gate 		 * mode, and the process is dead, then respawn it.
12817c478bd9Sstevel@tonic-gate 		 */
12827c478bd9Sstevel@tonic-gate 		if (((pp->p_flags & (LIVING|DEMANDREQUEST)) == DEMANDREQUEST) &&
12837c478bd9Sstevel@tonic-gate 		    (cmd.c_levels & MASK_abc) &&
12847c478bd9Sstevel@tonic-gate 		    (cmd.c_action & op_modes) == M_ONDEMAND) {
12857c478bd9Sstevel@tonic-gate 			spawn(pp, &cmd);
12867c478bd9Sstevel@tonic-gate 			continue;
12877c478bd9Sstevel@tonic-gate 		}
12887c478bd9Sstevel@tonic-gate 
12897c478bd9Sstevel@tonic-gate 		/*
12907c478bd9Sstevel@tonic-gate 		 * If the action is not an action we are interested in,
12917c478bd9Sstevel@tonic-gate 		 * skip the entry.
12927c478bd9Sstevel@tonic-gate 		 */
12937c478bd9Sstevel@tonic-gate 		if ((cmd.c_action & op_modes) == 0 || pp->p_flags & LIVING ||
12947c478bd9Sstevel@tonic-gate 		    (cmd.c_levels & lvl_mask) == 0)
12957c478bd9Sstevel@tonic-gate 			continue;
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate 		/*
12987c478bd9Sstevel@tonic-gate 		 * If the modes are the normal modes (ONCE, WAIT, RESPAWN, OFF,
12997c478bd9Sstevel@tonic-gate 		 * ONDEMAND) and the action field is either OFF or the action
13007c478bd9Sstevel@tonic-gate 		 * field is ONCE or WAIT and the current level is the same as
13017c478bd9Sstevel@tonic-gate 		 * the last level, then skip this entry.  ONCE and WAIT only
13027c478bd9Sstevel@tonic-gate 		 * get run when the level changes.
13037c478bd9Sstevel@tonic-gate 		 */
13047c478bd9Sstevel@tonic-gate 		if (op_modes == NORMAL_MODES &&
13057c478bd9Sstevel@tonic-gate 		    (cmd.c_action == M_OFF ||
130648847494SEnrico Perla - Sun Microsystems 		    (cmd.c_action & (M_ONCE|M_WAIT)) &&
130748847494SEnrico Perla - Sun Microsystems 		    cur_state == prev_state))
13087c478bd9Sstevel@tonic-gate 			continue;
13097c478bd9Sstevel@tonic-gate 
13107c478bd9Sstevel@tonic-gate 		/*
13117c478bd9Sstevel@tonic-gate 		 * At this point we are interested in performing the action for
13127c478bd9Sstevel@tonic-gate 		 * this entry.  Actions fall into two categories, spinning off
13137c478bd9Sstevel@tonic-gate 		 * a process and not waiting, and spinning off a process and
13147c478bd9Sstevel@tonic-gate 		 * waiting for it to die.  If the action is ONCE, RESPAWN,
13157c478bd9Sstevel@tonic-gate 		 * ONDEMAND, POWERFAIL, or BOOT we don't wait for the process
13167c478bd9Sstevel@tonic-gate 		 * to die, for all other actions we do wait.
13177c478bd9Sstevel@tonic-gate 		 */
13187c478bd9Sstevel@tonic-gate 		if (cmd.c_action & (M_ONCE | M_RESPAWN | M_PF | M_BOOT)) {
13197c478bd9Sstevel@tonic-gate 			spawn(pp, &cmd);
13207c478bd9Sstevel@tonic-gate 
13217c478bd9Sstevel@tonic-gate 		} else {
13227c478bd9Sstevel@tonic-gate 			spawn(pp, &cmd);
132348847494SEnrico Perla - Sun Microsystems 			while (waitproc(pp) == FAILURE)
132448847494SEnrico Perla - Sun Microsystems 				;
13257c478bd9Sstevel@tonic-gate 			(void) account(DEAD_PROCESS, pp, NULL);
13267c478bd9Sstevel@tonic-gate 			pp->p_flags = 0;
13277c478bd9Sstevel@tonic-gate 		}
13287c478bd9Sstevel@tonic-gate 	}
13297c478bd9Sstevel@tonic-gate 	return (status);
13307c478bd9Sstevel@tonic-gate }
13317c478bd9Sstevel@tonic-gate 
13327c478bd9Sstevel@tonic-gate /*
13337c478bd9Sstevel@tonic-gate  * spawn() spawns a shell, inserts the information about the process
13347c478bd9Sstevel@tonic-gate  * process into the proc_table, and does the startup accounting.
13357c478bd9Sstevel@tonic-gate  */
13367c478bd9Sstevel@tonic-gate static void
13377c478bd9Sstevel@tonic-gate spawn(struct PROC_TABLE *process, struct CMD_LINE *cmd)
13387c478bd9Sstevel@tonic-gate {
13397c478bd9Sstevel@tonic-gate 	int		i;
13407c478bd9Sstevel@tonic-gate 	int		modes, maxfiles;
13417c478bd9Sstevel@tonic-gate 	time_t		now;
13427c478bd9Sstevel@tonic-gate 	struct PROC_TABLE tmproc, *oprocess;
13437c478bd9Sstevel@tonic-gate 
13447c478bd9Sstevel@tonic-gate 	/*
13457c478bd9Sstevel@tonic-gate 	 * The modes to be sent to efork() are 0 unless we are
13467c478bd9Sstevel@tonic-gate 	 * spawning a LVLa, LVLb, or LVLc entry or we will be
13477c478bd9Sstevel@tonic-gate 	 * waiting for the death of the child before continuing.
13487c478bd9Sstevel@tonic-gate 	 */
13497c478bd9Sstevel@tonic-gate 	modes = NAMED;
13507c478bd9Sstevel@tonic-gate 	if (process->p_flags & DEMANDREQUEST || cur_state == LVLa ||
13517c478bd9Sstevel@tonic-gate 	    cur_state == LVLb || cur_state == LVLc)
13527c478bd9Sstevel@tonic-gate 		modes |= DEMANDREQUEST;
13537c478bd9Sstevel@tonic-gate 	if ((cmd->c_action & (M_SYSINIT | M_WAIT | M_BOOTWAIT | M_PWAIT)) != 0)
13547c478bd9Sstevel@tonic-gate 		modes |= NOCLEANUP;
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 	/*
13577c478bd9Sstevel@tonic-gate 	 * If this is a respawnable process, check the threshold
13587c478bd9Sstevel@tonic-gate 	 * information to avoid excessive respawns.
13597c478bd9Sstevel@tonic-gate 	 */
13607c478bd9Sstevel@tonic-gate 	if (cmd->c_action & M_RESPAWN) {
13617c478bd9Sstevel@tonic-gate 		/*
13627c478bd9Sstevel@tonic-gate 		 * Add NOCLEANUP to all respawnable commands so that the
13637c478bd9Sstevel@tonic-gate 		 * information about the frequency of respawns isn't lost.
13647c478bd9Sstevel@tonic-gate 		 */
13657c478bd9Sstevel@tonic-gate 		modes |= NOCLEANUP;
13667c478bd9Sstevel@tonic-gate 		(void) time(&now);
13677c478bd9Sstevel@tonic-gate 
13687c478bd9Sstevel@tonic-gate 		/*
13697c478bd9Sstevel@tonic-gate 		 * If no time is assigned, then this is the first time
13707c478bd9Sstevel@tonic-gate 		 * this command is being processed in this series.  Assign
13717c478bd9Sstevel@tonic-gate 		 * the current time.
13727c478bd9Sstevel@tonic-gate 		 */
13737c478bd9Sstevel@tonic-gate 		if (process->p_time == 0L)
13747c478bd9Sstevel@tonic-gate 			process->p_time = now;
13757c478bd9Sstevel@tonic-gate 
13767c478bd9Sstevel@tonic-gate 		if (process->p_count++ == SPAWN_LIMIT) {
13777c478bd9Sstevel@tonic-gate 
13787c478bd9Sstevel@tonic-gate 			if ((now - process->p_time) < SPAWN_INTERVAL) {
13797c478bd9Sstevel@tonic-gate 				/*
13807c478bd9Sstevel@tonic-gate 				 * Process is respawning too rapidly.  Print
13817c478bd9Sstevel@tonic-gate 				 * message and refuse to respawn it for now.
13827c478bd9Sstevel@tonic-gate 				 */
13837c478bd9Sstevel@tonic-gate 				console(B_TRUE, "Command is respawning too "
13847c478bd9Sstevel@tonic-gate 				    "rapidly. Check for possible errors.\n"
13857c478bd9Sstevel@tonic-gate 				    "id:%4s \"%s\"\n",
13867c478bd9Sstevel@tonic-gate 				    &cmd->c_id[0], &cmd->c_command[EXEC]);
13877c478bd9Sstevel@tonic-gate 				return;
13887c478bd9Sstevel@tonic-gate 			}
13897c478bd9Sstevel@tonic-gate 			process->p_time = now;
13907c478bd9Sstevel@tonic-gate 			process->p_count = 0;
13917c478bd9Sstevel@tonic-gate 
13927c478bd9Sstevel@tonic-gate 		} else if (process->p_count > SPAWN_LIMIT) {
13937c478bd9Sstevel@tonic-gate 			/*
13947c478bd9Sstevel@tonic-gate 			 * If process has been respawning too rapidly and
13957c478bd9Sstevel@tonic-gate 			 * the inhibit time limit hasn't expired yet, we
13967c478bd9Sstevel@tonic-gate 			 * refuse to respawn.
13977c478bd9Sstevel@tonic-gate 			 */
13987c478bd9Sstevel@tonic-gate 			if (now - process->p_time < SPAWN_INTERVAL + INHIBIT)
13997c478bd9Sstevel@tonic-gate 				return;
14007c478bd9Sstevel@tonic-gate 			process->p_time = now;
14017c478bd9Sstevel@tonic-gate 			process->p_count = 0;
14027c478bd9Sstevel@tonic-gate 		}
14037c478bd9Sstevel@tonic-gate 		rsflag = TRUE;
14047c478bd9Sstevel@tonic-gate 	}
14057c478bd9Sstevel@tonic-gate 
14067c478bd9Sstevel@tonic-gate 	/*
14077c478bd9Sstevel@tonic-gate 	 * Spawn a child process to execute this command.
14087c478bd9Sstevel@tonic-gate 	 */
1409c39ec064SRoger A. Faulkner 	(void) sighold(SIGCLD);
14107c478bd9Sstevel@tonic-gate 	oprocess = process;
14117c478bd9Sstevel@tonic-gate 	while ((process = efork(cmd->c_action, oprocess, modes)) == NO_ROOM)
14127c478bd9Sstevel@tonic-gate 		(void) pause();
14137c478bd9Sstevel@tonic-gate 
14147c478bd9Sstevel@tonic-gate 	if (process == NULLPROC) {
14157c478bd9Sstevel@tonic-gate 
14167c478bd9Sstevel@tonic-gate 		/*
14177c478bd9Sstevel@tonic-gate 		 * We are the child.  We must make sure we get a different
14187c478bd9Sstevel@tonic-gate 		 * file pointer for our references to utmpx.  Otherwise our
14197c478bd9Sstevel@tonic-gate 		 * seeks and reads will compete with those of the parent.
14207c478bd9Sstevel@tonic-gate 		 */
14217c478bd9Sstevel@tonic-gate 		endutxent();
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 		/*
14247c478bd9Sstevel@tonic-gate 		 * Perform the accounting for the beginning of a process.
14257c478bd9Sstevel@tonic-gate 		 * Note that all processes are initially "INIT_PROCESS"es.
14267c478bd9Sstevel@tonic-gate 		 */
14277c478bd9Sstevel@tonic-gate 		tmproc.p_id[0] = cmd->c_id[0];
14287c478bd9Sstevel@tonic-gate 		tmproc.p_id[1] = cmd->c_id[1];
14297c478bd9Sstevel@tonic-gate 		tmproc.p_id[2] = cmd->c_id[2];
14307c478bd9Sstevel@tonic-gate 		tmproc.p_id[3] = cmd->c_id[3];
14317c478bd9Sstevel@tonic-gate 		tmproc.p_pid = getpid();
14327c478bd9Sstevel@tonic-gate 		tmproc.p_exit = 0;
14337c478bd9Sstevel@tonic-gate 		(void) account(INIT_PROCESS, &tmproc,
14347c478bd9Sstevel@tonic-gate 		    prog_name(&cmd->c_command[EXEC]));
14357c478bd9Sstevel@tonic-gate 		maxfiles = ulimit(UL_GDESLIM, 0);
14367c478bd9Sstevel@tonic-gate 		for (i = 0; i < maxfiles; i++)
14377c478bd9Sstevel@tonic-gate 			(void) fcntl(i, F_SETFD, FD_CLOEXEC);
14387c478bd9Sstevel@tonic-gate 
14397c478bd9Sstevel@tonic-gate 		/*
14407c478bd9Sstevel@tonic-gate 		 * Now exec a shell with the -c option and the command
14417c478bd9Sstevel@tonic-gate 		 * from inittab.
14427c478bd9Sstevel@tonic-gate 		 */
14437c478bd9Sstevel@tonic-gate 		(void) execle(SH, "INITSH", "-c", cmd->c_command, (char *)0,
14447c478bd9Sstevel@tonic-gate 		    glob_envp);
14457c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Command\n\"%s\"\n failed to execute.  errno "
14467c478bd9Sstevel@tonic-gate 		    "= %d (exec of shell failed)\n", cmd->c_command, errno);
14477c478bd9Sstevel@tonic-gate 
14487c478bd9Sstevel@tonic-gate 		/*
14497c478bd9Sstevel@tonic-gate 		 * Don't come back so quickly that "init" doesn't have a
14507c478bd9Sstevel@tonic-gate 		 * chance to finish putting this child in "proc_table".
14517c478bd9Sstevel@tonic-gate 		 */
14527c478bd9Sstevel@tonic-gate 		timer(20);
14537c478bd9Sstevel@tonic-gate 		exit(1);
14547c478bd9Sstevel@tonic-gate 
14557c478bd9Sstevel@tonic-gate 	}
14567c478bd9Sstevel@tonic-gate 
14577c478bd9Sstevel@tonic-gate 	/*
14587c478bd9Sstevel@tonic-gate 	 * We are the parent.  Insert the necessary
14597c478bd9Sstevel@tonic-gate 	 * information in the proc_table.
14607c478bd9Sstevel@tonic-gate 	 */
14617c478bd9Sstevel@tonic-gate 	process->p_id[0] = cmd->c_id[0];
14627c478bd9Sstevel@tonic-gate 	process->p_id[1] = cmd->c_id[1];
14637c478bd9Sstevel@tonic-gate 	process->p_id[2] = cmd->c_id[2];
14647c478bd9Sstevel@tonic-gate 	process->p_id[3] = cmd->c_id[3];
14657c478bd9Sstevel@tonic-gate 
14667c478bd9Sstevel@tonic-gate 	st_write();
14677c478bd9Sstevel@tonic-gate 
1468c39ec064SRoger A. Faulkner 	(void) sigrelse(SIGCLD);
14697c478bd9Sstevel@tonic-gate }
14707c478bd9Sstevel@tonic-gate 
14717c478bd9Sstevel@tonic-gate /*
14727c478bd9Sstevel@tonic-gate  * findpslot() finds the old slot in the process table for the
14737c478bd9Sstevel@tonic-gate  * command with the same id, or it finds an empty slot.
14747c478bd9Sstevel@tonic-gate  */
14757c478bd9Sstevel@tonic-gate static struct PROC_TABLE *
14767c478bd9Sstevel@tonic-gate findpslot(struct CMD_LINE *cmd)
14777c478bd9Sstevel@tonic-gate {
14787c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*process;
14797c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*empty = NULLPROC;
14807c478bd9Sstevel@tonic-gate 
14817c478bd9Sstevel@tonic-gate 	for (process = proc_table;
14827c478bd9Sstevel@tonic-gate 	    (process < proc_table + num_proc); process++) {
14837c478bd9Sstevel@tonic-gate 		if (process->p_flags & OCCUPIED &&
14847c478bd9Sstevel@tonic-gate 		    id_eq(process->p_id, cmd->c_id))
14857c478bd9Sstevel@tonic-gate 			break;
14867c478bd9Sstevel@tonic-gate 
14877c478bd9Sstevel@tonic-gate 		/*
14887c478bd9Sstevel@tonic-gate 		 * If the entry is totally empty and "empty" is still 0,
14897c478bd9Sstevel@tonic-gate 		 * remember where this hole is and make sure the slot is
14907c478bd9Sstevel@tonic-gate 		 * zeroed out.
14917c478bd9Sstevel@tonic-gate 		 */
14927c478bd9Sstevel@tonic-gate 		if (empty == NULLPROC && (process->p_flags & OCCUPIED) == 0) {
14937c478bd9Sstevel@tonic-gate 			empty = process;
14947c478bd9Sstevel@tonic-gate 			process->p_id[0] = '\0';
14957c478bd9Sstevel@tonic-gate 			process->p_id[1] = '\0';
14967c478bd9Sstevel@tonic-gate 			process->p_id[2] = '\0';
14977c478bd9Sstevel@tonic-gate 			process->p_id[3] = '\0';
14987c478bd9Sstevel@tonic-gate 			process->p_pid = 0;
14997c478bd9Sstevel@tonic-gate 			process->p_time = 0L;
15007c478bd9Sstevel@tonic-gate 			process->p_count = 0;
15017c478bd9Sstevel@tonic-gate 			process->p_flags = 0;
15027c478bd9Sstevel@tonic-gate 			process->p_exit = 0;
15037c478bd9Sstevel@tonic-gate 		}
15047c478bd9Sstevel@tonic-gate 	}
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	/*
15077c478bd9Sstevel@tonic-gate 	 * If there is no entry for this slot, then there should be an
15087c478bd9Sstevel@tonic-gate 	 * empty slot.  If there is no empty slot, then we've run out
15097c478bd9Sstevel@tonic-gate 	 * of proc_table space.  If the latter is true, empty will be
15107c478bd9Sstevel@tonic-gate 	 * NULL and the caller will have to complain.
15117c478bd9Sstevel@tonic-gate 	 */
15127c478bd9Sstevel@tonic-gate 	if (process == (proc_table + num_proc))
15137c478bd9Sstevel@tonic-gate 		process = empty;
15147c478bd9Sstevel@tonic-gate 
15157c478bd9Sstevel@tonic-gate 	return (process);
15167c478bd9Sstevel@tonic-gate }
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate /*
15197c478bd9Sstevel@tonic-gate  * getcmd() parses lines from inittab.  Each time it finds a command line
15207c478bd9Sstevel@tonic-gate  * it will return TRUE as well as fill the passed CMD_LINE structure and
15217c478bd9Sstevel@tonic-gate  * the shell command string.  When the end of inittab is reached, FALSE
15227c478bd9Sstevel@tonic-gate  * is returned inittab is automatically opened if it is not currently open
15237c478bd9Sstevel@tonic-gate  * and is closed when the end of the file is reached.
15247c478bd9Sstevel@tonic-gate  */
15257c478bd9Sstevel@tonic-gate static FILE *fp_inittab = NULL;
15267c478bd9Sstevel@tonic-gate 
15277c478bd9Sstevel@tonic-gate static int
15287c478bd9Sstevel@tonic-gate getcmd(struct CMD_LINE *cmd, char *shcmd)
15297c478bd9Sstevel@tonic-gate {
15307c478bd9Sstevel@tonic-gate 	char	*ptr;
15317c478bd9Sstevel@tonic-gate 	int	c, lastc, state;
1532*a28480feSAndy Fiddaman 	char	*ptr1;
15337c478bd9Sstevel@tonic-gate 	int	answer, i, proceed;
15347c478bd9Sstevel@tonic-gate 	struct	stat	sbuf;
15357c478bd9Sstevel@tonic-gate 	static char *actions[] = {
15367c478bd9Sstevel@tonic-gate 		"off", "respawn", "ondemand", "once", "wait", "boot",
15377c478bd9Sstevel@tonic-gate 		"bootwait", "powerfail", "powerwait", "initdefault",
15387c478bd9Sstevel@tonic-gate 		"sysinit",
15397c478bd9Sstevel@tonic-gate 	};
15407c478bd9Sstevel@tonic-gate 	static short act_masks[] = {
15417c478bd9Sstevel@tonic-gate 		M_OFF, M_RESPAWN, M_ONDEMAND, M_ONCE, M_WAIT, M_BOOT,
15427c478bd9Sstevel@tonic-gate 		M_BOOTWAIT, M_PF, M_PWAIT, M_INITDEFAULT, M_SYSINIT,
15437c478bd9Sstevel@tonic-gate 	};
15447c478bd9Sstevel@tonic-gate 	/*
15457c478bd9Sstevel@tonic-gate 	 * Only these actions will be allowed for entries which
15467c478bd9Sstevel@tonic-gate 	 * are specified for single-user mode.
15477c478bd9Sstevel@tonic-gate 	 */
15487c478bd9Sstevel@tonic-gate 	short su_acts = M_INITDEFAULT | M_PF | M_PWAIT | M_WAIT;
15497c478bd9Sstevel@tonic-gate 
15507c478bd9Sstevel@tonic-gate 	if (fp_inittab == NULL) {
15517c478bd9Sstevel@tonic-gate 		/*
15527c478bd9Sstevel@tonic-gate 		 * Before attempting to open inittab we stat it to make
15537c478bd9Sstevel@tonic-gate 		 * sure it currently exists and is not empty.  We try
15547c478bd9Sstevel@tonic-gate 		 * several times because someone may have temporarily
15557c478bd9Sstevel@tonic-gate 		 * unlinked or truncated the file.
15567c478bd9Sstevel@tonic-gate 		 */
15577c478bd9Sstevel@tonic-gate 		for (i = 0; i < 3; i++) {
15587c478bd9Sstevel@tonic-gate 			if (stat(INITTAB, &sbuf) == -1) {
15597c478bd9Sstevel@tonic-gate 				if (i == 2) {
15607c478bd9Sstevel@tonic-gate 					console(B_TRUE,
15617c478bd9Sstevel@tonic-gate 					    "Cannot stat %s, errno: %d\n",
15627c478bd9Sstevel@tonic-gate 					    INITTAB, errno);
15637c478bd9Sstevel@tonic-gate 					return (FAILURE);
15647c478bd9Sstevel@tonic-gate 				} else {
15657c478bd9Sstevel@tonic-gate 					timer(3);
15667c478bd9Sstevel@tonic-gate 				}
15677c478bd9Sstevel@tonic-gate 			} else if (sbuf.st_size < 10) {
15687c478bd9Sstevel@tonic-gate 				if (i == 2) {
15697c478bd9Sstevel@tonic-gate 					console(B_TRUE,
15707c478bd9Sstevel@tonic-gate 					    "%s truncated or corrupted\n",
15717c478bd9Sstevel@tonic-gate 					    INITTAB);
15727c478bd9Sstevel@tonic-gate 					return (FAILURE);
15737c478bd9Sstevel@tonic-gate 				} else {
15747c478bd9Sstevel@tonic-gate 					timer(3);
15757c478bd9Sstevel@tonic-gate 				}
15767c478bd9Sstevel@tonic-gate 			} else {
15777c478bd9Sstevel@tonic-gate 				break;
15787c478bd9Sstevel@tonic-gate 			}
15797c478bd9Sstevel@tonic-gate 		}
15807c478bd9Sstevel@tonic-gate 
15817c478bd9Sstevel@tonic-gate 		/*
15827c478bd9Sstevel@tonic-gate 		 * If unable to open inittab, print error message and
15837c478bd9Sstevel@tonic-gate 		 * return FAILURE to caller.
15847c478bd9Sstevel@tonic-gate 		 */
15857c478bd9Sstevel@tonic-gate 		if ((fp_inittab = fopen(INITTAB, "r")) == NULL) {
15867c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Cannot open %s errno: %d\n", INITTAB,
15877c478bd9Sstevel@tonic-gate 			    errno);
15887c478bd9Sstevel@tonic-gate 			return (FAILURE);
15897c478bd9Sstevel@tonic-gate 		}
15907c478bd9Sstevel@tonic-gate 	}
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate 	/*
15937c478bd9Sstevel@tonic-gate 	 * Keep getting commands from inittab until you find a
15947c478bd9Sstevel@tonic-gate 	 * good one or run out of file.
15957c478bd9Sstevel@tonic-gate 	 */
15967c478bd9Sstevel@tonic-gate 	for (answer = FALSE; answer == FALSE; ) {
15977c478bd9Sstevel@tonic-gate 		/*
15987c478bd9Sstevel@tonic-gate 		 * Zero out the cmd itself before trying next line.
15997c478bd9Sstevel@tonic-gate 		 */
16007c478bd9Sstevel@tonic-gate 		bzero(cmd, sizeof (struct CMD_LINE));
16017c478bd9Sstevel@tonic-gate 
16027c478bd9Sstevel@tonic-gate 		/*
16037c478bd9Sstevel@tonic-gate 		 * Read in lines of inittab, parsing at colons, until a line is
16047c478bd9Sstevel@tonic-gate 		 * read in which doesn't end with a backslash.  Do not start if
16057c478bd9Sstevel@tonic-gate 		 * the first character read is an EOF.  Note that this means
16067c478bd9Sstevel@tonic-gate 		 * that lines which don't end in a newline are still processed,
16077c478bd9Sstevel@tonic-gate 		 * since the "for" will terminate normally once started,
16087c478bd9Sstevel@tonic-gate 		 * regardless of whether line terminates with a newline or EOF.
16097c478bd9Sstevel@tonic-gate 		 */
16107c478bd9Sstevel@tonic-gate 		state = FAILURE;
16117c478bd9Sstevel@tonic-gate 		if ((c = fgetc(fp_inittab)) == EOF) {
16127c478bd9Sstevel@tonic-gate 			answer = FALSE;
16137c478bd9Sstevel@tonic-gate 			(void) fclose(fp_inittab);
16147c478bd9Sstevel@tonic-gate 			fp_inittab = NULL;
16157c478bd9Sstevel@tonic-gate 			break;
16167c478bd9Sstevel@tonic-gate 		}
16177c478bd9Sstevel@tonic-gate 
16187c478bd9Sstevel@tonic-gate 		for (proceed = TRUE, ptr = shcmd, state = ID, lastc = '\0';
16197c478bd9Sstevel@tonic-gate 		    proceed && c != EOF;
16207c478bd9Sstevel@tonic-gate 		    lastc = c, c = fgetc(fp_inittab)) {
16210a1278f2SGary Mills 			/* If we're not in the FAILURE state and haven't */
16220a1278f2SGary Mills 			/* yet reached the shell command field, process	 */
16230a1278f2SGary Mills 			/* the line, otherwise just look for a real end	 */
16240a1278f2SGary Mills 			/* of line.					 */
16250a1278f2SGary Mills 			if (state != FAILURE && state != COMMAND) {
16267c478bd9Sstevel@tonic-gate 			/*
16277c478bd9Sstevel@tonic-gate 			 * Squeeze out spaces and tabs.
16287c478bd9Sstevel@tonic-gate 			 */
16297c478bd9Sstevel@tonic-gate 			if (c == ' ' || c == '\t')
16307c478bd9Sstevel@tonic-gate 				continue;
16317c478bd9Sstevel@tonic-gate 
16327c478bd9Sstevel@tonic-gate 			/*
16337c478bd9Sstevel@tonic-gate 			 * Ignore characters in a comment, except for the \n.
16347c478bd9Sstevel@tonic-gate 			 */
16357c478bd9Sstevel@tonic-gate 			if (state == COMMENT) {
16367c478bd9Sstevel@tonic-gate 				if (c == '\n') {
16377c478bd9Sstevel@tonic-gate 					lastc = ' ';
16387c478bd9Sstevel@tonic-gate 					break;
16397c478bd9Sstevel@tonic-gate 				} else {
16407c478bd9Sstevel@tonic-gate 					continue;
16417c478bd9Sstevel@tonic-gate 				}
16427c478bd9Sstevel@tonic-gate 			}
16437c478bd9Sstevel@tonic-gate 
16447c478bd9Sstevel@tonic-gate 			/*
16457c478bd9Sstevel@tonic-gate 			 * Detect comments (lines whose first non-whitespace
16467c478bd9Sstevel@tonic-gate 			 * character is '#') by checking that we're at the
16477c478bd9Sstevel@tonic-gate 			 * beginning of a line, have seen a '#', and haven't
16487c478bd9Sstevel@tonic-gate 			 * yet accumulated any characters.
16497c478bd9Sstevel@tonic-gate 			 */
16507c478bd9Sstevel@tonic-gate 			if (state == ID && c == '#' && ptr == shcmd) {
16517c478bd9Sstevel@tonic-gate 				state = COMMENT;
16527c478bd9Sstevel@tonic-gate 				continue;
16537c478bd9Sstevel@tonic-gate 			}
16547c478bd9Sstevel@tonic-gate 
16557c478bd9Sstevel@tonic-gate 			/*
16567c478bd9Sstevel@tonic-gate 			 * If the character is a ':', then check the
16577c478bd9Sstevel@tonic-gate 			 * previous field for correctness and advance
16587c478bd9Sstevel@tonic-gate 			 * to the next field.
16597c478bd9Sstevel@tonic-gate 			 */
16607c478bd9Sstevel@tonic-gate 			if (c == ':') {
16610a1278f2SGary Mills 				switch (state) {
16627c478bd9Sstevel@tonic-gate 
16630a1278f2SGary Mills 				case ID :
16647c478bd9Sstevel@tonic-gate 				/*
16657c478bd9Sstevel@tonic-gate 				 * Check to see that there are only
16667c478bd9Sstevel@tonic-gate 				 * 1 to 4 characters for the id.
16677c478bd9Sstevel@tonic-gate 				 */
16687c478bd9Sstevel@tonic-gate 				if ((i = ptr - shcmd) < 1 || i > 4) {
16697c478bd9Sstevel@tonic-gate 					state = FAILURE;
16707c478bd9Sstevel@tonic-gate 				} else {
16717c478bd9Sstevel@tonic-gate 					bcopy(shcmd, &cmd->c_id[0], i);
16727c478bd9Sstevel@tonic-gate 					ptr = shcmd;
16737c478bd9Sstevel@tonic-gate 					state = LEVELS;
16747c478bd9Sstevel@tonic-gate 				}
16757c478bd9Sstevel@tonic-gate 				break;
16767c478bd9Sstevel@tonic-gate 
16770a1278f2SGary Mills 				case LEVELS :
16787c478bd9Sstevel@tonic-gate 				/*
16797c478bd9Sstevel@tonic-gate 				 * Build a mask for all the levels for
16807c478bd9Sstevel@tonic-gate 				 * which this command will be legal.
16817c478bd9Sstevel@tonic-gate 				 */
16827c478bd9Sstevel@tonic-gate 				for (cmd->c_levels = 0, ptr1 = shcmd;
16837c478bd9Sstevel@tonic-gate 				    ptr1 < ptr; ptr1++) {
16847c478bd9Sstevel@tonic-gate 					int mask;
16857c478bd9Sstevel@tonic-gate 					if (lvlname_to_mask(*ptr1,
16867c478bd9Sstevel@tonic-gate 					    &mask) == -1) {
16877c478bd9Sstevel@tonic-gate 						state = FAILURE;
16887c478bd9Sstevel@tonic-gate 						break;
16897c478bd9Sstevel@tonic-gate 					}
16907c478bd9Sstevel@tonic-gate 					cmd->c_levels |= mask;
16917c478bd9Sstevel@tonic-gate 				}
16927c478bd9Sstevel@tonic-gate 				if (state != FAILURE) {
16937c478bd9Sstevel@tonic-gate 					state = ACTION;
16947c478bd9Sstevel@tonic-gate 					ptr = shcmd;	/* Reset the buffer */
16957c478bd9Sstevel@tonic-gate 				}
16967c478bd9Sstevel@tonic-gate 				break;
16977c478bd9Sstevel@tonic-gate 
16980a1278f2SGary Mills 				case ACTION :
16997c478bd9Sstevel@tonic-gate 				/*
17007c478bd9Sstevel@tonic-gate 				 * Null terminate the string in shcmd buffer and
17017c478bd9Sstevel@tonic-gate 				 * then try to match against legal actions.  If
17027c478bd9Sstevel@tonic-gate 				 * the field is of length 0, then the default of
17037c478bd9Sstevel@tonic-gate 				 * "RESPAWN" is used if the id is numeric,
17047c478bd9Sstevel@tonic-gate 				 * otherwise the default is "OFF".
17057c478bd9Sstevel@tonic-gate 				 */
17067c478bd9Sstevel@tonic-gate 				if (ptr == shcmd) {
17077c478bd9Sstevel@tonic-gate 					if (isdigit(cmd->c_id[0]) &&
17087c478bd9Sstevel@tonic-gate 					    (cmd->c_id[1] == '\0' ||
17090a1278f2SGary Mills 					    isdigit(cmd->c_id[1])) &&
17107c478bd9Sstevel@tonic-gate 					    (cmd->c_id[2] == '\0' ||
17110a1278f2SGary Mills 					    isdigit(cmd->c_id[2])) &&
17127c478bd9Sstevel@tonic-gate 					    (cmd->c_id[3] == '\0' ||
17130a1278f2SGary Mills 					    isdigit(cmd->c_id[3])))
17140a1278f2SGary Mills 						cmd->c_action = M_RESPAWN;
17157c478bd9Sstevel@tonic-gate 					else
17160a1278f2SGary Mills 						cmd->c_action = M_OFF;
17177c478bd9Sstevel@tonic-gate 				} else {
17180a1278f2SGary Mills 					for (cmd->c_action = 0, i = 0,
17190a1278f2SGary Mills 					    *ptr = '\0';
17200a1278f2SGary Mills 					    i <
17210a1278f2SGary Mills 					    sizeof (actions)/sizeof (char *);
17220a1278f2SGary Mills 					    i++) {
17237c478bd9Sstevel@tonic-gate 					if (strcmp(shcmd, actions[i]) == 0) {
17240a1278f2SGary Mills 						if ((cmd->c_levels & MASKSU) &&
17250a1278f2SGary Mills 						    !(act_masks[i] & su_acts))
17260a1278f2SGary Mills 							cmd->c_action = 0;
17270a1278f2SGary Mills 						else
17280a1278f2SGary Mills 							cmd->c_action =
17290a1278f2SGary Mills 							    act_masks[i];
17300a1278f2SGary Mills 						break;
17310a1278f2SGary Mills 					}
17327c478bd9Sstevel@tonic-gate 					}
17337c478bd9Sstevel@tonic-gate 				}
17347c478bd9Sstevel@tonic-gate 
17357c478bd9Sstevel@tonic-gate 				/*
17367c478bd9Sstevel@tonic-gate 				 * If the action didn't match any legal action,
17377c478bd9Sstevel@tonic-gate 				 * set state to FAILURE.
17387c478bd9Sstevel@tonic-gate 				 */
17397c478bd9Sstevel@tonic-gate 				if (cmd->c_action == 0) {
17407c478bd9Sstevel@tonic-gate 					state = FAILURE;
17417c478bd9Sstevel@tonic-gate 				} else {
17427c478bd9Sstevel@tonic-gate 					state = COMMAND;
17437c478bd9Sstevel@tonic-gate 					(void) strcpy(shcmd, "exec ");
17447c478bd9Sstevel@tonic-gate 				}
17457c478bd9Sstevel@tonic-gate 				ptr = shcmd + EXEC;
17467c478bd9Sstevel@tonic-gate 				break;
17470a1278f2SGary Mills 				}
17480a1278f2SGary Mills 				continue;
17497c478bd9Sstevel@tonic-gate 			}
17500a1278f2SGary Mills 		}
17510a1278f2SGary Mills 
17520a1278f2SGary Mills 		/* If the character is a '\n', then this is the end of a */
17530a1278f2SGary Mills 		/* line.  If the '\n' wasn't preceded by a backslash, */
17540a1278f2SGary Mills 		/* it is also the end of an inittab command.  If it was */
17550a1278f2SGary Mills 		/* preceded by a backslash then the next line is a */
17560a1278f2SGary Mills 		/* continuation.  Note that the continuation '\n' falls */
17570a1278f2SGary Mills 		/* through and is treated like other characters and is */
17580a1278f2SGary Mills 		/* stored in the shell command line. */
17590a1278f2SGary Mills 		if (c == '\n' && lastc != '\\') {
17600a1278f2SGary Mills 			proceed = FALSE;
17610a1278f2SGary Mills 			*ptr = '\0';
17620a1278f2SGary Mills 			break;
17630a1278f2SGary Mills 		}
17647c478bd9Sstevel@tonic-gate 
17650a1278f2SGary Mills 		/* For all other characters just stuff them into the */
17660a1278f2SGary Mills 		/* command as long as there aren't too many of them. */
17670a1278f2SGary Mills 		/* Make sure there is room for a terminating '\0' also. */
17680a1278f2SGary Mills 		if (ptr >= shcmd + MAXCMDL - 1)
17697c478bd9Sstevel@tonic-gate 			state = FAILURE;
17700a1278f2SGary Mills 		else
17717c478bd9Sstevel@tonic-gate 			*ptr++ = (char)c;
17727c478bd9Sstevel@tonic-gate 
17730a1278f2SGary Mills 		/* If the character we just stored was a quoted	*/
17740a1278f2SGary Mills 		/* backslash, then change "c" to '\0', so that this	*/
17750a1278f2SGary Mills 		/* backslash will not cause a subsequent '\n' to appear */
17760a1278f2SGary Mills 		/* quoted.  In otherwords '\' '\' '\n' is the real end */
17770a1278f2SGary Mills 		/* of a command, while '\' '\n' is a continuation. */
17780a1278f2SGary Mills 		if (c == '\\' && lastc == '\\')
17797c478bd9Sstevel@tonic-gate 			c = '\0';
17807c478bd9Sstevel@tonic-gate 		}
17817c478bd9Sstevel@tonic-gate 
17827c478bd9Sstevel@tonic-gate 		/*
17837c478bd9Sstevel@tonic-gate 		 * Make sure all the fields are properly specified
17847c478bd9Sstevel@tonic-gate 		 * for a good command line.
17857c478bd9Sstevel@tonic-gate 		 */
17867c478bd9Sstevel@tonic-gate 		if (state == COMMAND) {
17877c478bd9Sstevel@tonic-gate 			answer = TRUE;
17887c478bd9Sstevel@tonic-gate 			cmd->c_command = shcmd;
17897c478bd9Sstevel@tonic-gate 
17907c478bd9Sstevel@tonic-gate 			/*
17917c478bd9Sstevel@tonic-gate 			 * If no default level was supplied, insert
17927c478bd9Sstevel@tonic-gate 			 * all numerical levels.
17937c478bd9Sstevel@tonic-gate 			 */
17947c478bd9Sstevel@tonic-gate 			if (cmd->c_levels == 0)
17957c478bd9Sstevel@tonic-gate 				cmd->c_levels = MASK_NUMERIC;
17967c478bd9Sstevel@tonic-gate 
17977c478bd9Sstevel@tonic-gate 			/*
17987c478bd9Sstevel@tonic-gate 			 * If no action has been supplied, declare this
17997c478bd9Sstevel@tonic-gate 			 * entry to be OFF.
18007c478bd9Sstevel@tonic-gate 			 */
18017c478bd9Sstevel@tonic-gate 			if (cmd->c_action == 0)
18027c478bd9Sstevel@tonic-gate 				cmd->c_action = M_OFF;
18037c478bd9Sstevel@tonic-gate 
18047c478bd9Sstevel@tonic-gate 			/*
18057c478bd9Sstevel@tonic-gate 			 * If no shell command has been supplied, make sure
18067c478bd9Sstevel@tonic-gate 			 * there is a null string in the command field.
18077c478bd9Sstevel@tonic-gate 			 */
18087c478bd9Sstevel@tonic-gate 			if (ptr == shcmd + EXEC)
18097c478bd9Sstevel@tonic-gate 				*shcmd = '\0';
18107c478bd9Sstevel@tonic-gate 		} else
18117c478bd9Sstevel@tonic-gate 			answer = FALSE;
18127c478bd9Sstevel@tonic-gate 
18137c478bd9Sstevel@tonic-gate 		/*
18147c478bd9Sstevel@tonic-gate 		 * If we have reached the end of inittab, then close it
18157c478bd9Sstevel@tonic-gate 		 * and quit trying to find a good command line.
18167c478bd9Sstevel@tonic-gate 		 */
18177c478bd9Sstevel@tonic-gate 		if (c == EOF) {
18187c478bd9Sstevel@tonic-gate 			(void) fclose(fp_inittab);
18197c478bd9Sstevel@tonic-gate 			fp_inittab = NULL;
18207c478bd9Sstevel@tonic-gate 			break;
18217c478bd9Sstevel@tonic-gate 		}
18227c478bd9Sstevel@tonic-gate 	}
18237c478bd9Sstevel@tonic-gate 	return (answer);
18247c478bd9Sstevel@tonic-gate }
18257c478bd9Sstevel@tonic-gate 
18267c478bd9Sstevel@tonic-gate /*
18277c478bd9Sstevel@tonic-gate  * lvlname_to_state(): convert the character name of a state to its level
18287c478bd9Sstevel@tonic-gate  * (its corresponding signal number).
18297c478bd9Sstevel@tonic-gate  */
18307c478bd9Sstevel@tonic-gate static int
18317c478bd9Sstevel@tonic-gate lvlname_to_state(char name)
18327c478bd9Sstevel@tonic-gate {
18337c478bd9Sstevel@tonic-gate 	int i;
18347c478bd9Sstevel@tonic-gate 	for (i = 0; i < LVL_NELEMS; i++) {
18357c478bd9Sstevel@tonic-gate 		if (lvls[i].lvl_name == name)
18367c478bd9Sstevel@tonic-gate 			return (lvls[i].lvl_state);
18377c478bd9Sstevel@tonic-gate 	}
18387c478bd9Sstevel@tonic-gate 	return (-1);
18397c478bd9Sstevel@tonic-gate }
18407c478bd9Sstevel@tonic-gate 
18417c478bd9Sstevel@tonic-gate /*
18427c478bd9Sstevel@tonic-gate  * state_to_name(): convert the level to the character name.
18437c478bd9Sstevel@tonic-gate  */
18447c478bd9Sstevel@tonic-gate static char
18457c478bd9Sstevel@tonic-gate state_to_name(int state)
18467c478bd9Sstevel@tonic-gate {
18477c478bd9Sstevel@tonic-gate 	int i;
18487c478bd9Sstevel@tonic-gate 	for (i = 0; i < LVL_NELEMS; i++) {
18497c478bd9Sstevel@tonic-gate 		if (lvls[i].lvl_state == state)
18507c478bd9Sstevel@tonic-gate 			return (lvls[i].lvl_name);
18517c478bd9Sstevel@tonic-gate 	}
18527c478bd9Sstevel@tonic-gate 	return (-1);
18537c478bd9Sstevel@tonic-gate }
18547c478bd9Sstevel@tonic-gate 
18557c478bd9Sstevel@tonic-gate /*
18567c478bd9Sstevel@tonic-gate  * state_to_mask(): return the mask corresponding to a signal number
18577c478bd9Sstevel@tonic-gate  */
18587c478bd9Sstevel@tonic-gate static int
18597c478bd9Sstevel@tonic-gate state_to_mask(int state)
18607c478bd9Sstevel@tonic-gate {
18617c478bd9Sstevel@tonic-gate 	int i;
18627c478bd9Sstevel@tonic-gate 	for (i = 0; i < LVL_NELEMS; i++) {
18637c478bd9Sstevel@tonic-gate 		if (lvls[i].lvl_state == state)
18647c478bd9Sstevel@tonic-gate 			return (lvls[i].lvl_mask);
18657c478bd9Sstevel@tonic-gate 	}
18667c478bd9Sstevel@tonic-gate 	return (0);	/* return 0, since that represents an empty mask */
18677c478bd9Sstevel@tonic-gate }
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate /*
18707c478bd9Sstevel@tonic-gate  * lvlname_to_mask(): return the mask corresponding to a levels character name
18717c478bd9Sstevel@tonic-gate  */
18727c478bd9Sstevel@tonic-gate static int
18737c478bd9Sstevel@tonic-gate lvlname_to_mask(char name, int *mask)
18747c478bd9Sstevel@tonic-gate {
18757c478bd9Sstevel@tonic-gate 	int i;
18767c478bd9Sstevel@tonic-gate 	for (i = 0; i < LVL_NELEMS; i++) {
18777c478bd9Sstevel@tonic-gate 		if (lvls[i].lvl_name == name) {
18787c478bd9Sstevel@tonic-gate 			*mask = lvls[i].lvl_mask;
18797c478bd9Sstevel@tonic-gate 			return (0);
18807c478bd9Sstevel@tonic-gate 		}
18817c478bd9Sstevel@tonic-gate 	}
18827c478bd9Sstevel@tonic-gate 	return (-1);
18837c478bd9Sstevel@tonic-gate }
18847c478bd9Sstevel@tonic-gate 
18857c478bd9Sstevel@tonic-gate /*
18867c478bd9Sstevel@tonic-gate  * state_to_flags(): return the flags corresponding to a runlevel.  These
18877c478bd9Sstevel@tonic-gate  * indicate properties of that runlevel.
18887c478bd9Sstevel@tonic-gate  */
18897c478bd9Sstevel@tonic-gate static int
18907c478bd9Sstevel@tonic-gate state_to_flags(int state)
18917c478bd9Sstevel@tonic-gate {
18927c478bd9Sstevel@tonic-gate 	int i;
18937c478bd9Sstevel@tonic-gate 	for (i = 0; i < LVL_NELEMS; i++) {
18947c478bd9Sstevel@tonic-gate 		if (lvls[i].lvl_state == state)
18957c478bd9Sstevel@tonic-gate 			return (lvls[i].lvl_flags);
18967c478bd9Sstevel@tonic-gate 	}
18977c478bd9Sstevel@tonic-gate 	return (0);
18987c478bd9Sstevel@tonic-gate }
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate /*
19017c478bd9Sstevel@tonic-gate  * killproc() creates a child which kills the process specified by pid.
19027c478bd9Sstevel@tonic-gate  */
19037c478bd9Sstevel@tonic-gate void
19047c478bd9Sstevel@tonic-gate killproc(pid_t pid)
19057c478bd9Sstevel@tonic-gate {
19067c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*process;
19077c478bd9Sstevel@tonic-gate 
1908c39ec064SRoger A. Faulkner 	(void) sighold(SIGCLD);
19097c478bd9Sstevel@tonic-gate 	while ((process = efork(M_OFF, NULLPROC, 0)) == NO_ROOM)
19107c478bd9Sstevel@tonic-gate 		(void) pause();
1911c39ec064SRoger A. Faulkner 	(void) sigrelse(SIGCLD);
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 	if (process == NULLPROC) {
19147c478bd9Sstevel@tonic-gate 		/*
19157c478bd9Sstevel@tonic-gate 		 * efork() sets all signal handlers to the default, so reset
19167c478bd9Sstevel@tonic-gate 		 * the ALRM handler to make timer() work as expected.
19177c478bd9Sstevel@tonic-gate 		 */
19187c478bd9Sstevel@tonic-gate 		(void) sigset(SIGALRM, alarmclk);
19197c478bd9Sstevel@tonic-gate 
19207c478bd9Sstevel@tonic-gate 		/*
19217c478bd9Sstevel@tonic-gate 		 * We are the child.  Try to terminate the process nicely
19227c478bd9Sstevel@tonic-gate 		 * first using SIGTERM and if it refuses to die in TWARN
19237c478bd9Sstevel@tonic-gate 		 * seconds kill it with SIGKILL.
19247c478bd9Sstevel@tonic-gate 		 */
19257c478bd9Sstevel@tonic-gate 		(void) kill(pid, SIGTERM);
19267c478bd9Sstevel@tonic-gate 		(void) timer(TWARN);
19277c478bd9Sstevel@tonic-gate 		(void) kill(pid, SIGKILL);
19287c478bd9Sstevel@tonic-gate 		(void) exit(0);
19297c478bd9Sstevel@tonic-gate 	}
19307c478bd9Sstevel@tonic-gate }
19317c478bd9Sstevel@tonic-gate 
19327c478bd9Sstevel@tonic-gate /*
19337c478bd9Sstevel@tonic-gate  * Set up the default environment for all procs to be forked from init.
19347c478bd9Sstevel@tonic-gate  * Read the values from the /etc/default/init file, except for PATH.  If
1935*a28480feSAndy Fiddaman  * there is not enough room in the environment array, the environment
1936*a28480feSAndy Fiddaman  * lines that don't fit are discarded and a message is written to the console.
19377c478bd9Sstevel@tonic-gate  */
19387c478bd9Sstevel@tonic-gate void
19397c478bd9Sstevel@tonic-gate init_env()
19407c478bd9Sstevel@tonic-gate {
1941*a28480feSAndy Fiddaman 	void		*dstate;
1942*a28480feSAndy Fiddaman 	const char	*tokp;
19437c478bd9Sstevel@tonic-gate 
19447c478bd9Sstevel@tonic-gate 	glob_envp[0] = malloc((unsigned)(strlen(DEF_PATH)+2));
19457c478bd9Sstevel@tonic-gate 	(void) strcpy(glob_envp[0], DEF_PATH);
19467c478bd9Sstevel@tonic-gate 	glob_envn = 1;
19477c478bd9Sstevel@tonic-gate 
19487c478bd9Sstevel@tonic-gate 	if (rflg) {
19497c478bd9Sstevel@tonic-gate 		glob_envp[1] =
195048847494SEnrico Perla - Sun Microsystems 		    malloc((unsigned)(strlen("_DVFS_RECONFIG=YES")+2));
19517c478bd9Sstevel@tonic-gate 		(void) strcpy(glob_envp[1], "_DVFS_RECONFIG=YES");
19527c478bd9Sstevel@tonic-gate 		++glob_envn;
19537c478bd9Sstevel@tonic-gate 	} else if (bflg == 1) {
19547c478bd9Sstevel@tonic-gate 		glob_envp[1] =
195548847494SEnrico Perla - Sun Microsystems 		    malloc((unsigned)(strlen("RB_NOBOOTRC=YES")+2));
19567c478bd9Sstevel@tonic-gate 		(void) strcpy(glob_envp[1], "RB_NOBOOTRC=YES");
19577c478bd9Sstevel@tonic-gate 		++glob_envn;
19587c478bd9Sstevel@tonic-gate 	}
19597c478bd9Sstevel@tonic-gate 
1960*a28480feSAndy Fiddaman 	if (definit_open(ENVFILE, &dstate) != 0) {
19617c478bd9Sstevel@tonic-gate 		console(B_TRUE,
19627c478bd9Sstevel@tonic-gate 		    "Cannot open %s. Environment not initialized.\n",
19637c478bd9Sstevel@tonic-gate 		    ENVFILE);
1964*a28480feSAndy Fiddaman 		return;
1965*a28480feSAndy Fiddaman 	}
19667c478bd9Sstevel@tonic-gate 
1967*a28480feSAndy Fiddaman 	while ((tokp = definit_token(dstate)) != NULL &&
1968*a28480feSAndy Fiddaman 	    glob_envn < MAXENVENT - 2) {
19697c478bd9Sstevel@tonic-gate 
1970*a28480feSAndy Fiddaman 		if (strncmp(tokp, "CMASK=", sizeof ("CMASK=") - 1) == 0) {
1971*a28480feSAndy Fiddaman 			long t;
19727c478bd9Sstevel@tonic-gate 
1973*a28480feSAndy Fiddaman 			/* We know there's an = */
1974*a28480feSAndy Fiddaman 			t = strtol(strchr(tokp, '=') + 1, NULL, 8);
19757c478bd9Sstevel@tonic-gate 
1976*a28480feSAndy Fiddaman 			/* Sanity */
1977*a28480feSAndy Fiddaman 			if (t >= DEFINIT_MIN_UMASK && t <= DEFINIT_MAX_UMASK)
1978*a28480feSAndy Fiddaman 				cmask = (int)t;
1979*a28480feSAndy Fiddaman 			(void) umask(cmask);
1980*a28480feSAndy Fiddaman 			continue;
1981*a28480feSAndy Fiddaman 		}
1982*a28480feSAndy Fiddaman 		glob_envp[glob_envn] = strdup(tokp);
1983*a28480feSAndy Fiddaman 		if (glob_envp[glob_envn] == NULL) {
1984*a28480feSAndy Fiddaman 			console(B_TRUE, "Out of memory building environment, "
1985*a28480feSAndy Fiddaman 			    "truncated.\n");
1986*a28480feSAndy Fiddaman 			break;
1987*a28480feSAndy Fiddaman 		}
1988*a28480feSAndy Fiddaman 		if (++glob_envn >= MAXENVENT - 1) {
1989*a28480feSAndy Fiddaman 			console(B_TRUE, "Too many variables in %s; "
1990*a28480feSAndy Fiddaman 			    "environment not fully initialized.\n", ENVFILE);
1991*a28480feSAndy Fiddaman 			break;
19927c478bd9Sstevel@tonic-gate 		}
19937c478bd9Sstevel@tonic-gate 	}
1994*a28480feSAndy Fiddaman 
1995*a28480feSAndy Fiddaman 	/*
1996*a28480feSAndy Fiddaman 	 * Append a null pointer to the environment array to mark its end.
1997*a28480feSAndy Fiddaman 	 */
1998*a28480feSAndy Fiddaman 	glob_envp[glob_envn] = NULL;
1999*a28480feSAndy Fiddaman 
2000*a28480feSAndy Fiddaman 	definit_close(dstate);
20017c478bd9Sstevel@tonic-gate }
20027c478bd9Sstevel@tonic-gate 
20037c478bd9Sstevel@tonic-gate /*
20047c478bd9Sstevel@tonic-gate  * boot_init(): Do initialization things that should be done at boot.
20057c478bd9Sstevel@tonic-gate  */
20067c478bd9Sstevel@tonic-gate void
20077c478bd9Sstevel@tonic-gate boot_init()
20087c478bd9Sstevel@tonic-gate {
20097c478bd9Sstevel@tonic-gate 	int i;
20107c478bd9Sstevel@tonic-gate 	struct PROC_TABLE *process, *oprocess;
20117c478bd9Sstevel@tonic-gate 	struct CMD_LINE	cmd;
20127c478bd9Sstevel@tonic-gate 	char	line[MAXCMDL];
20137b209c2cSacruz 	char	svc_aux[SVC_AUX_SIZE];
20147b209c2cSacruz 	char	init_svc_fmri[SVC_FMRI_SIZE];
20157c478bd9Sstevel@tonic-gate 	char *old_path;
20167c478bd9Sstevel@tonic-gate 	int maxfiles;
20177c478bd9Sstevel@tonic-gate 
20187c478bd9Sstevel@tonic-gate 	/* Use INIT_PATH for sysinit cmds */
20197c478bd9Sstevel@tonic-gate 	old_path = glob_envp[0];
20207c478bd9Sstevel@tonic-gate 	glob_envp[0] = malloc((unsigned)(strlen(INIT_PATH)+2));
20217c478bd9Sstevel@tonic-gate 	(void) strcpy(glob_envp[0], INIT_PATH);
20227c478bd9Sstevel@tonic-gate 
20237c478bd9Sstevel@tonic-gate 	/*
20247c478bd9Sstevel@tonic-gate 	 * Scan inittab(4) and process the special svc.startd entry, initdefault
20257c478bd9Sstevel@tonic-gate 	 * and sysinit entries.
20267c478bd9Sstevel@tonic-gate 	 */
20277c478bd9Sstevel@tonic-gate 	while (getcmd(&cmd, &line[0]) == TRUE) {
20287b209c2cSacruz 		if (startd_tmpl >= 0 && id_eq(cmd.c_id, "smf")) {
20297c478bd9Sstevel@tonic-gate 			process_startd_line(&cmd, line);
20307b209c2cSacruz 			(void) snprintf(startd_svc_aux, SVC_AUX_SIZE,
20317b209c2cSacruz 			    INITTAB_ENTRY_ID_STR_FORMAT, cmd.c_id);
20327b209c2cSacruz 		} else if (cmd.c_action == M_INITDEFAULT) {
20337c478bd9Sstevel@tonic-gate 			/*
20347c478bd9Sstevel@tonic-gate 			 * initdefault is no longer meaningful, as the SMF
20357c478bd9Sstevel@tonic-gate 			 * milestone controls what (legacy) run level we
20367c478bd9Sstevel@tonic-gate 			 * boot to.
20377c478bd9Sstevel@tonic-gate 			 */
20387c478bd9Sstevel@tonic-gate 			console(B_TRUE,
20397c478bd9Sstevel@tonic-gate 			    "Ignoring legacy \"initdefault\" entry.\n");
20407c478bd9Sstevel@tonic-gate 		} else if (cmd.c_action == M_SYSINIT) {
20417c478bd9Sstevel@tonic-gate 			/*
20427c478bd9Sstevel@tonic-gate 			 * Execute the "sysinit" entry and wait for it to
20437c478bd9Sstevel@tonic-gate 			 * complete.  No bookkeeping is performed on these
20447c478bd9Sstevel@tonic-gate 			 * entries because we avoid writing to the file system
20457c478bd9Sstevel@tonic-gate 			 * until after there has been an chance to check it.
20467c478bd9Sstevel@tonic-gate 			 */
20477c478bd9Sstevel@tonic-gate 			if (process = findpslot(&cmd)) {
2048c39ec064SRoger A. Faulkner 				(void) sighold(SIGCLD);
20497b209c2cSacruz 				(void) snprintf(svc_aux, SVC_AUX_SIZE,
20507b209c2cSacruz 				    INITTAB_ENTRY_ID_STR_FORMAT, cmd.c_id);
20517b209c2cSacruz 				(void) snprintf(init_svc_fmri, SVC_FMRI_SIZE,
20527b209c2cSacruz 				    SVC_INIT_PREFIX INITTAB_ENTRY_ID_STR_FORMAT,
20537b209c2cSacruz 				    cmd.c_id);
20547b209c2cSacruz 				if (legacy_tmpl >= 0) {
20557b209c2cSacruz 					(void) ct_pr_tmpl_set_svc_fmri(
20567b209c2cSacruz 					    legacy_tmpl, init_svc_fmri);
20577b209c2cSacruz 					(void) ct_pr_tmpl_set_svc_aux(
20587b209c2cSacruz 					    legacy_tmpl, svc_aux);
20597b209c2cSacruz 				}
20607c478bd9Sstevel@tonic-gate 
20617c478bd9Sstevel@tonic-gate 				for (oprocess = process;
20627c478bd9Sstevel@tonic-gate 				    (process = efork(M_OFF, oprocess,
20637c478bd9Sstevel@tonic-gate 				    (NAMED|NOCLEANUP))) == NO_ROOM;
20647c478bd9Sstevel@tonic-gate 				    /* CSTYLED */)
20657c478bd9Sstevel@tonic-gate 					;
2066c39ec064SRoger A. Faulkner 				(void) sigrelse(SIGCLD);
20677c478bd9Sstevel@tonic-gate 
20687c478bd9Sstevel@tonic-gate 				if (process == NULLPROC) {
20697c478bd9Sstevel@tonic-gate 					maxfiles = ulimit(UL_GDESLIM, 0);
20707c478bd9Sstevel@tonic-gate 
20717c478bd9Sstevel@tonic-gate 					for (i = 0; i < maxfiles; i++)
20727c478bd9Sstevel@tonic-gate 						(void) fcntl(i, F_SETFD,
20737c478bd9Sstevel@tonic-gate 						    FD_CLOEXEC);
20747c478bd9Sstevel@tonic-gate 					(void) execle(SH, "INITSH", "-c",
20757c478bd9Sstevel@tonic-gate 					    cmd.c_command,
20767c478bd9Sstevel@tonic-gate 					    (char *)0, glob_envp);
20777c478bd9Sstevel@tonic-gate 					console(B_TRUE,
20787c478bd9Sstevel@tonic-gate "Command\n\"%s\"\n failed to execute.  errno = %d (exec of shell failed)\n",
207948847494SEnrico Perla - Sun Microsystems 					    cmd.c_command, errno);
20807c478bd9Sstevel@tonic-gate 					exit(1);
20810a1278f2SGary Mills 				} else
20820a1278f2SGary Mills 					while (waitproc(process) == FAILURE)
20830a1278f2SGary Mills 						;
20847c478bd9Sstevel@tonic-gate 				process->p_flags = 0;
20857c478bd9Sstevel@tonic-gate 				st_write();
20867c478bd9Sstevel@tonic-gate 			}
20877c478bd9Sstevel@tonic-gate 		}
20887c478bd9Sstevel@tonic-gate 	}
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	/* Restore the path. */
20917c478bd9Sstevel@tonic-gate 	free(glob_envp[0]);
20927c478bd9Sstevel@tonic-gate 	glob_envp[0] = old_path;
20937c478bd9Sstevel@tonic-gate 
20947c478bd9Sstevel@tonic-gate 	/*
20957c478bd9Sstevel@tonic-gate 	 * This will enable st_write() to complain about init_state_file.
20967c478bd9Sstevel@tonic-gate 	 */
20977c478bd9Sstevel@tonic-gate 	booting = 0;
20987c478bd9Sstevel@tonic-gate 
20997c478bd9Sstevel@tonic-gate 	/*
21007c478bd9Sstevel@tonic-gate 	 * If the /etc/ioctl.syscon didn't exist or had invalid contents write
21017c478bd9Sstevel@tonic-gate 	 * out a correct version.
21027c478bd9Sstevel@tonic-gate 	 */
21037c478bd9Sstevel@tonic-gate 	if (write_ioctl)
21047c478bd9Sstevel@tonic-gate 		write_ioctl_syscon();
21057c478bd9Sstevel@tonic-gate 
21067c478bd9Sstevel@tonic-gate 	/*
21077c478bd9Sstevel@tonic-gate 	 * Start svc.startd(1M), which does most of the work.
21087c478bd9Sstevel@tonic-gate 	 */
21097c478bd9Sstevel@tonic-gate 	if (startd_cline[0] != '\0' && startd_tmpl >= 0) {
21107c478bd9Sstevel@tonic-gate 		/* Start svc.startd. */
21117c478bd9Sstevel@tonic-gate 		if (startd_run(startd_cline, startd_tmpl, 0) == -1)
21127c478bd9Sstevel@tonic-gate 			cur_state = SINGLE_USER;
21137c478bd9Sstevel@tonic-gate 	} else {
21147c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Absent svc.startd entry or bad "
21157c478bd9Sstevel@tonic-gate 		    "contract template.  Not starting svc.startd.\n");
21167c478bd9Sstevel@tonic-gate 		enter_maintenance();
21177c478bd9Sstevel@tonic-gate 	}
21187c478bd9Sstevel@tonic-gate }
21197c478bd9Sstevel@tonic-gate 
21207c478bd9Sstevel@tonic-gate /*
21217c478bd9Sstevel@tonic-gate  * init_signals(): Initialize all signals to either be caught or ignored.
21227c478bd9Sstevel@tonic-gate  */
21237c478bd9Sstevel@tonic-gate void
21247c478bd9Sstevel@tonic-gate init_signals(void)
21257c478bd9Sstevel@tonic-gate {
21267c478bd9Sstevel@tonic-gate 	struct sigaction act;
21277c478bd9Sstevel@tonic-gate 	int i;
21287c478bd9Sstevel@tonic-gate 
21297c478bd9Sstevel@tonic-gate 	/*
21307c478bd9Sstevel@tonic-gate 	 * Start by ignoring all signals, then selectively re-enable some.
21317c478bd9Sstevel@tonic-gate 	 * The SIG_IGN disposition will only affect asynchronous signals:
21327c478bd9Sstevel@tonic-gate 	 * any signal that we trigger synchronously that doesn't end up
21337c478bd9Sstevel@tonic-gate 	 * being handled by siglvl() will be forcibly delivered by the kernel.
21347c478bd9Sstevel@tonic-gate 	 */
21357c478bd9Sstevel@tonic-gate 	for (i = SIGHUP; i <= SIGRTMAX; i++)
21367c478bd9Sstevel@tonic-gate 		(void) sigset(i, SIG_IGN);
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate 	/*
21397c478bd9Sstevel@tonic-gate 	 * Handle all level-changing signals using siglvl() and set sa_mask so
21407c478bd9Sstevel@tonic-gate 	 * that all level-changing signals are blocked while in siglvl().
21417c478bd9Sstevel@tonic-gate 	 */
21427c478bd9Sstevel@tonic-gate 	act.sa_handler = siglvl;
21437c478bd9Sstevel@tonic-gate 	act.sa_flags = SA_SIGINFO;
21447c478bd9Sstevel@tonic-gate 	(void) sigemptyset(&act.sa_mask);
21457c478bd9Sstevel@tonic-gate 
21467c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVLQ);
21477c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL0);
21487c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL1);
21497c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL2);
21507c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL3);
21517c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL4);
21527c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL5);
21537c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVL6);
21547c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, SINGLE_USER);
21557c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVLa);
21567c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVLb);
21577c478bd9Sstevel@tonic-gate 	(void) sigaddset(&act.sa_mask, LVLc);
21587c478bd9Sstevel@tonic-gate 
21597c478bd9Sstevel@tonic-gate 	(void) sigaction(LVLQ, &act, NULL);
21607c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL0, &act, NULL);
21617c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL1, &act, NULL);
21627c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL2, &act, NULL);
21637c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL3, &act, NULL);
21647c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL4, &act, NULL);
21657c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL5, &act, NULL);
21667c478bd9Sstevel@tonic-gate 	(void) sigaction(LVL6, &act, NULL);
21677c478bd9Sstevel@tonic-gate 	(void) sigaction(SINGLE_USER, &act, NULL);
21687c478bd9Sstevel@tonic-gate 	(void) sigaction(LVLa, &act, NULL);
21697c478bd9Sstevel@tonic-gate 	(void) sigaction(LVLb, &act, NULL);
21707c478bd9Sstevel@tonic-gate 	(void) sigaction(LVLc, &act, NULL);
21717c478bd9Sstevel@tonic-gate 
21727c478bd9Sstevel@tonic-gate 	(void) sigset(SIGALRM, alarmclk);
21737c478bd9Sstevel@tonic-gate 	alarmclk();
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate 	(void) sigset(SIGCLD, childeath);
21767c478bd9Sstevel@tonic-gate 	(void) sigset(SIGPWR, powerfail);
21777c478bd9Sstevel@tonic-gate }
21787c478bd9Sstevel@tonic-gate 
21797c478bd9Sstevel@tonic-gate /*
21807c478bd9Sstevel@tonic-gate  * Set up pipe for "godchildren". If the file exists and is a pipe just open
21817c478bd9Sstevel@tonic-gate  * it. Else, if the file system is r/w create it.  Otherwise, defer its
218292ba7109Seschrock  * creation and open until after /var/run has been mounted.  This function is
218392ba7109Seschrock  * only called on startup and when explicitly requested via LVLQ.
21847c478bd9Sstevel@tonic-gate  */
21857c478bd9Sstevel@tonic-gate void
21867c478bd9Sstevel@tonic-gate setup_pipe()
21877c478bd9Sstevel@tonic-gate {
21887c478bd9Sstevel@tonic-gate 	struct stat stat_buf;
21897c478bd9Sstevel@tonic-gate 	struct statvfs statvfs_buf;
2190dd965b2fSnakanon 	struct sigaction act;
21917c478bd9Sstevel@tonic-gate 
219292ba7109Seschrock 	/*
219392ba7109Seschrock 	 * Always close the previous pipe descriptor as the mounted filesystems
219492ba7109Seschrock 	 * may have changed.
219592ba7109Seschrock 	 */
219692ba7109Seschrock 	if (Pfd >= 0)
219792ba7109Seschrock 		(void) close(Pfd);
219892ba7109Seschrock 
21997c478bd9Sstevel@tonic-gate 	if ((stat(INITPIPE, &stat_buf) == 0) &&
22007c478bd9Sstevel@tonic-gate 	    ((stat_buf.st_mode & (S_IFMT|S_IRUSR)) == (S_IFIFO|S_IRUSR)))
22017c478bd9Sstevel@tonic-gate 		Pfd = open(INITPIPE, O_RDWR | O_NDELAY);
22027c478bd9Sstevel@tonic-gate 	else
22037c478bd9Sstevel@tonic-gate 		if ((statvfs(INITPIPE_DIR, &statvfs_buf) == 0) &&
22047c478bd9Sstevel@tonic-gate 		    ((statvfs_buf.f_flag & ST_RDONLY) == 0)) {
22057c478bd9Sstevel@tonic-gate 			(void) unlink(INITPIPE);
22067c478bd9Sstevel@tonic-gate 			(void) mknod(INITPIPE, S_IFIFO | 0600, 0);
22077c478bd9Sstevel@tonic-gate 			Pfd = open(INITPIPE, O_RDWR | O_NDELAY);
22087c478bd9Sstevel@tonic-gate 		}
22097c478bd9Sstevel@tonic-gate 
22107c478bd9Sstevel@tonic-gate 	if (Pfd >= 0) {
22117c478bd9Sstevel@tonic-gate 		(void) ioctl(Pfd, I_SETSIG, S_INPUT);
22127c478bd9Sstevel@tonic-gate 		/*
22137c478bd9Sstevel@tonic-gate 		 * Read pipe in message discard mode.
22147c478bd9Sstevel@tonic-gate 		 */
22157c478bd9Sstevel@tonic-gate 		(void) ioctl(Pfd, I_SRDOPT, RMSGD);
2216dd965b2fSnakanon 
2217dd965b2fSnakanon 		act.sa_handler = sigpoll;
2218dd965b2fSnakanon 		act.sa_flags = 0;
2219dd965b2fSnakanon 		(void) sigemptyset(&act.sa_mask);
2220dd965b2fSnakanon 		(void) sigaddset(&act.sa_mask, SIGCLD);
2221dd965b2fSnakanon 		(void) sigaction(SIGPOLL, &act, NULL);
22227c478bd9Sstevel@tonic-gate 	}
22237c478bd9Sstevel@tonic-gate }
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate /*
22267c478bd9Sstevel@tonic-gate  * siglvl - handle an asynchronous signal from init(1M) telling us that we
22277c478bd9Sstevel@tonic-gate  * should change the current run level.  We set new_state accordingly.
22287c478bd9Sstevel@tonic-gate  */
22297c478bd9Sstevel@tonic-gate void
22307c478bd9Sstevel@tonic-gate siglvl(int sig, siginfo_t *sip, ucontext_t *ucp)
22317c478bd9Sstevel@tonic-gate {
22327c478bd9Sstevel@tonic-gate 	struct PROC_TABLE *process;
22337c478bd9Sstevel@tonic-gate 	struct sigaction act;
22347c478bd9Sstevel@tonic-gate 
22357c478bd9Sstevel@tonic-gate 	/*
22367c478bd9Sstevel@tonic-gate 	 * If the signal was from the kernel (rather than init(1M)) then init
22377c478bd9Sstevel@tonic-gate 	 * itself tripped the signal.  That is, we might have a bug and tripped
22387c478bd9Sstevel@tonic-gate 	 * a real SIGSEGV instead of receiving it as an alias for SIGLVLa.  In
22397c478bd9Sstevel@tonic-gate 	 * such a case we reset the disposition to SIG_DFL, block all signals
22407c478bd9Sstevel@tonic-gate 	 * in uc_mask but the current one, and return to the interrupted ucp
22417c478bd9Sstevel@tonic-gate 	 * to effect an appropriate death.  The kernel will then restart us.
22427c478bd9Sstevel@tonic-gate 	 *
22437c478bd9Sstevel@tonic-gate 	 * The one exception to SI_FROMKERNEL() is SIGFPE (a.k.a. LVL6), which
22447c478bd9Sstevel@tonic-gate 	 * the kernel can send us when it wants to effect an orderly reboot.
22457c478bd9Sstevel@tonic-gate 	 * For this case we must also verify si_code is zero, rather than a
22467c478bd9Sstevel@tonic-gate 	 * code such as FPE_INTDIV which a bug might have triggered.
22477c478bd9Sstevel@tonic-gate 	 */
22487c478bd9Sstevel@tonic-gate 	if (sip != NULL && SI_FROMKERNEL(sip) &&
22497c478bd9Sstevel@tonic-gate 	    (sig != SIGFPE || sip->si_code == 0)) {
22507c478bd9Sstevel@tonic-gate 
22517c478bd9Sstevel@tonic-gate 		(void) sigemptyset(&act.sa_mask);
22527c478bd9Sstevel@tonic-gate 		act.sa_handler = SIG_DFL;
22537c478bd9Sstevel@tonic-gate 		act.sa_flags = 0;
22547c478bd9Sstevel@tonic-gate 		(void) sigaction(sig, &act, NULL);
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate 		(void) sigfillset(&ucp->uc_sigmask);
22577c478bd9Sstevel@tonic-gate 		(void) sigdelset(&ucp->uc_sigmask, sig);
22587c478bd9Sstevel@tonic-gate 		ucp->uc_flags |= UC_SIGMASK;
22597c478bd9Sstevel@tonic-gate 
22607c478bd9Sstevel@tonic-gate 		(void) setcontext(ucp);
22617c478bd9Sstevel@tonic-gate 	}
22627c478bd9Sstevel@tonic-gate 
22637c478bd9Sstevel@tonic-gate 	/*
22647c478bd9Sstevel@tonic-gate 	 * If the signal received is a LVLQ signal, do not really
22657c478bd9Sstevel@tonic-gate 	 * change levels, just restate the current level.  If the
22667c478bd9Sstevel@tonic-gate 	 * signal is not a LVLQ, set the new level to the signal
22677c478bd9Sstevel@tonic-gate 	 * received.
22687c478bd9Sstevel@tonic-gate 	 */
226992ba7109Seschrock 	if (sig == LVLQ) {
22707c478bd9Sstevel@tonic-gate 		new_state = cur_state;
227192ba7109Seschrock 		lvlq_received = B_TRUE;
227292ba7109Seschrock 	} else {
22737c478bd9Sstevel@tonic-gate 		new_state = sig;
227492ba7109Seschrock 	}
22757c478bd9Sstevel@tonic-gate 
22767c478bd9Sstevel@tonic-gate 	/*
22777c478bd9Sstevel@tonic-gate 	 * Clear all times and repeat counts in the process table
22787c478bd9Sstevel@tonic-gate 	 * since either the level is changing or the user has editted
22797c478bd9Sstevel@tonic-gate 	 * the inittab file and wants us to look at it again.
22807c478bd9Sstevel@tonic-gate 	 * If the user has fixed a typo, we don't want residual timing
22817c478bd9Sstevel@tonic-gate 	 * data preventing the fixed command line from executing.
22827c478bd9Sstevel@tonic-gate 	 */
22837c478bd9Sstevel@tonic-gate 	for (process = proc_table;
228448847494SEnrico Perla - Sun Microsystems 	    (process < proc_table + num_proc); process++) {
22857c478bd9Sstevel@tonic-gate 		process->p_time = 0L;
22867c478bd9Sstevel@tonic-gate 		process->p_count = 0;
22877c478bd9Sstevel@tonic-gate 	}
22887c478bd9Sstevel@tonic-gate 
22897c478bd9Sstevel@tonic-gate 	/*
22907c478bd9Sstevel@tonic-gate 	 * Set the flag to indicate that a "user signal" was received.
22917c478bd9Sstevel@tonic-gate 	 */
22927c478bd9Sstevel@tonic-gate 	wakeup.w_flags.w_usersignal = 1;
22937c478bd9Sstevel@tonic-gate }
22947c478bd9Sstevel@tonic-gate 
22957c478bd9Sstevel@tonic-gate 
22967c478bd9Sstevel@tonic-gate /*
22977c478bd9Sstevel@tonic-gate  * alarmclk
22987c478bd9Sstevel@tonic-gate  */
22997c478bd9Sstevel@tonic-gate static void
23007c478bd9Sstevel@tonic-gate alarmclk()
23017c478bd9Sstevel@tonic-gate {
23027c478bd9Sstevel@tonic-gate 	time_up = TRUE;
23037c478bd9Sstevel@tonic-gate }
23047c478bd9Sstevel@tonic-gate 
23057c478bd9Sstevel@tonic-gate /*
23067c478bd9Sstevel@tonic-gate  * childeath_single():
23077c478bd9Sstevel@tonic-gate  *
23087c478bd9Sstevel@tonic-gate  * This used to be the SIGCLD handler and it was set with signal()
23097c478bd9Sstevel@tonic-gate  * (as opposed to sigset()).  When a child exited we'd come to the
23107c478bd9Sstevel@tonic-gate  * handler, wait for the child, and reenable the handler with
23117c478bd9Sstevel@tonic-gate  * signal() just before returning.  The implementation of signal()
23127c478bd9Sstevel@tonic-gate  * checks with waitid() for waitable children and sends a SIGCLD
23137c478bd9Sstevel@tonic-gate  * if there are some.  If children are exiting faster than the
23147c478bd9Sstevel@tonic-gate  * handler can run we keep sending signals and the handler never
23157c478bd9Sstevel@tonic-gate  * gets to return and eventually the stack runs out and init dies.
23167c478bd9Sstevel@tonic-gate  * To prevent that we set the handler with sigset() so the handler
23177c478bd9Sstevel@tonic-gate  * doesn't need to be reset, and in childeath() (see below) we
23187c478bd9Sstevel@tonic-gate  * call childeath_single() as long as there are children to be
23197c478bd9Sstevel@tonic-gate  * waited for.  If a child exits while init is in the handler a
23207c478bd9Sstevel@tonic-gate  * SIGCLD will be pending and delivered on return from the handler.
23217c478bd9Sstevel@tonic-gate  * If the child was already waited for the handler will have nothing
23227c478bd9Sstevel@tonic-gate  * to do and return, otherwise the child will be waited for.
23237c478bd9Sstevel@tonic-gate  */
23247c478bd9Sstevel@tonic-gate static void
2325c39ec064SRoger A. Faulkner childeath_single(pid_t pid, int status)
23267c478bd9Sstevel@tonic-gate {
23277c478bd9Sstevel@tonic-gate 	struct PROC_TABLE	*process;
23287c478bd9Sstevel@tonic-gate 	struct pidlist		*pp;
23297c478bd9Sstevel@tonic-gate 
23307c478bd9Sstevel@tonic-gate 	/*
2331c39ec064SRoger A. Faulkner 	 * Scan the process table to see if we are interested in this process.
23327c478bd9Sstevel@tonic-gate 	 */
23337c478bd9Sstevel@tonic-gate 	for (process = proc_table;
233448847494SEnrico Perla - Sun Microsystems 	    (process < proc_table + num_proc); process++) {
23357c478bd9Sstevel@tonic-gate 		if ((process->p_flags & (LIVING|OCCUPIED)) ==
23367c478bd9Sstevel@tonic-gate 		    (LIVING|OCCUPIED) && process->p_pid == pid) {
23377c478bd9Sstevel@tonic-gate 
23387c478bd9Sstevel@tonic-gate 			/*
23397c478bd9Sstevel@tonic-gate 			 * Mark this process as having died and store the exit
23407c478bd9Sstevel@tonic-gate 			 * status.  Also set the wakeup flag for a dead child
23417c478bd9Sstevel@tonic-gate 			 * and break out of the loop.
23427c478bd9Sstevel@tonic-gate 			 */
23437c478bd9Sstevel@tonic-gate 			process->p_flags &= ~LIVING;
23447c478bd9Sstevel@tonic-gate 			process->p_exit = (short)status;
23457c478bd9Sstevel@tonic-gate 			wakeup.w_flags.w_childdeath = 1;
23467c478bd9Sstevel@tonic-gate 
23477c478bd9Sstevel@tonic-gate 			return;
23487c478bd9Sstevel@tonic-gate 		}
23497c478bd9Sstevel@tonic-gate 	}
23507c478bd9Sstevel@tonic-gate 
23517c478bd9Sstevel@tonic-gate 	/*
23527c478bd9Sstevel@tonic-gate 	 * No process was found above, look through auxiliary list.
23537c478bd9Sstevel@tonic-gate 	 */
23547c478bd9Sstevel@tonic-gate 	(void) sighold(SIGPOLL);
23557c478bd9Sstevel@tonic-gate 	pp = Plhead;
23567c478bd9Sstevel@tonic-gate 	while (pp) {
23577c478bd9Sstevel@tonic-gate 		if (pid > pp->pl_pid) {
23587c478bd9Sstevel@tonic-gate 			/*
23597c478bd9Sstevel@tonic-gate 			 * Keep on looking.
23607c478bd9Sstevel@tonic-gate 			 */
23617c478bd9Sstevel@tonic-gate 			pp = pp->pl_next;
23627c478bd9Sstevel@tonic-gate 			continue;
23637c478bd9Sstevel@tonic-gate 		} else if (pid < pp->pl_pid) {
23647c478bd9Sstevel@tonic-gate 			/*
23657c478bd9Sstevel@tonic-gate 			 * Not in the list.
23667c478bd9Sstevel@tonic-gate 			 */
23677c478bd9Sstevel@tonic-gate 			break;
23687c478bd9Sstevel@tonic-gate 		} else {
23697c478bd9Sstevel@tonic-gate 			/*
23707c478bd9Sstevel@tonic-gate 			 * This is a dead "godchild".
23717c478bd9Sstevel@tonic-gate 			 */
23727c478bd9Sstevel@tonic-gate 			pp->pl_dflag = 1;
23737c478bd9Sstevel@tonic-gate 			pp->pl_exit = (short)status;
23747c478bd9Sstevel@tonic-gate 			wakeup.w_flags.w_childdeath = 1;
23757c478bd9Sstevel@tonic-gate 			Gchild = 1;	/* Notice to call cleanaux(). */
23767c478bd9Sstevel@tonic-gate 			break;
23777c478bd9Sstevel@tonic-gate 		}
23787c478bd9Sstevel@tonic-gate 	}
23797c478bd9Sstevel@tonic-gate 
23807c478bd9Sstevel@tonic-gate 	(void) sigrelse(SIGPOLL);
23817c478bd9Sstevel@tonic-gate }
23827c478bd9Sstevel@tonic-gate 
23837c478bd9Sstevel@tonic-gate /* ARGSUSED */
23847c478bd9Sstevel@tonic-gate static void
23857c478bd9Sstevel@tonic-gate childeath(int signo)
23867c478bd9Sstevel@tonic-gate {
2387c39ec064SRoger A. Faulkner 	pid_t pid;
2388c39ec064SRoger A. Faulkner 	int status;
23897c478bd9Sstevel@tonic-gate 
2390c39ec064SRoger A. Faulkner 	while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
2391c39ec064SRoger A. Faulkner 		childeath_single(pid, status);
23927c478bd9Sstevel@tonic-gate }
23937c478bd9Sstevel@tonic-gate 
23947c478bd9Sstevel@tonic-gate static void
23957c478bd9Sstevel@tonic-gate powerfail()
23967c478bd9Sstevel@tonic-gate {
23977c478bd9Sstevel@tonic-gate 	(void) nice(-19);
23987c478bd9Sstevel@tonic-gate 	wakeup.w_flags.w_powerhit = 1;
23997c478bd9Sstevel@tonic-gate }
24007c478bd9Sstevel@tonic-gate 
24017c478bd9Sstevel@tonic-gate /*
24027c478bd9Sstevel@tonic-gate  * efork() forks a child and the parent inserts the process in its table
24037c478bd9Sstevel@tonic-gate  * of processes that are directly a result of forks that it has performed.
24047c478bd9Sstevel@tonic-gate  * The child just changes the "global" with the process id for this process
24057c478bd9Sstevel@tonic-gate  * to it's new value.
24067c478bd9Sstevel@tonic-gate  * If efork() is called with a pointer into the proc_table it uses that slot,
24077c478bd9Sstevel@tonic-gate  * otherwise it searches for a free slot.  Regardless of how it was called,
24087c478bd9Sstevel@tonic-gate  * it returns the pointer to the proc_table entry
24097c478bd9Sstevel@tonic-gate  *
2410c39ec064SRoger A. Faulkner  * The SIGCLD signal is blocked (held) before calling efork()
2411c39ec064SRoger A. Faulkner  * and is unblocked (released) after efork() returns.
24127c478bd9Sstevel@tonic-gate  *
24137c478bd9Sstevel@tonic-gate  * Ideally, this should be rewritten to use modern signal semantics.
24147c478bd9Sstevel@tonic-gate  */
24157c478bd9Sstevel@tonic-gate static struct PROC_TABLE *
24167c478bd9Sstevel@tonic-gate efork(int action, struct PROC_TABLE *process, int modes)
24177c478bd9Sstevel@tonic-gate {
24187c478bd9Sstevel@tonic-gate 	pid_t	childpid;
24197c478bd9Sstevel@tonic-gate 	struct PROC_TABLE *proc;
24207c478bd9Sstevel@tonic-gate 	int		i;
24217c478bd9Sstevel@tonic-gate 	/*
24227c478bd9Sstevel@tonic-gate 	 * Freshen up the proc_table, removing any entries for dead processes
24237c478bd9Sstevel@tonic-gate 	 * that don't have NOCLEANUP set.  Perform the necessary accounting.
24247c478bd9Sstevel@tonic-gate 	 */
24257c478bd9Sstevel@tonic-gate 	for (proc = proc_table; (proc < proc_table + num_proc); proc++) {
24267c478bd9Sstevel@tonic-gate 		if ((proc->p_flags & (OCCUPIED|LIVING|NOCLEANUP)) ==
24277c478bd9Sstevel@tonic-gate 		    (OCCUPIED)) {
24287c478bd9Sstevel@tonic-gate 			/*
24297c478bd9Sstevel@tonic-gate 			 * Is this a named process?
24307c478bd9Sstevel@tonic-gate 			 * If so, do the necessary bookkeeping.
24317c478bd9Sstevel@tonic-gate 			 */
24327c478bd9Sstevel@tonic-gate 			if (proc->p_flags & NAMED)
24337c478bd9Sstevel@tonic-gate 				(void) account(DEAD_PROCESS, proc, NULL);
24347c478bd9Sstevel@tonic-gate 
24357c478bd9Sstevel@tonic-gate 			/*
24367c478bd9Sstevel@tonic-gate 			 * Free this entry for new usage.
24377c478bd9Sstevel@tonic-gate 			 */
24387c478bd9Sstevel@tonic-gate 			proc->p_flags = 0;
24397c478bd9Sstevel@tonic-gate 		}
24407c478bd9Sstevel@tonic-gate 	}
24417c478bd9Sstevel@tonic-gate 
24427c478bd9Sstevel@tonic-gate 	while ((childpid = fork()) == FAILURE) {
24437c478bd9Sstevel@tonic-gate 		/*
24447c478bd9Sstevel@tonic-gate 		 * Shorten the alarm timer in case someone else's child dies
24457c478bd9Sstevel@tonic-gate 		 * and free up a slot in the process table.
24467c478bd9Sstevel@tonic-gate 		 */
24477c478bd9Sstevel@tonic-gate 		setimer(5);
24487c478bd9Sstevel@tonic-gate 
24497c478bd9Sstevel@tonic-gate 		/*
2450c39ec064SRoger A. Faulkner 		 * Wait for some children to die.  Since efork()
2451c39ec064SRoger A. Faulkner 		 * is always called with SIGCLD blocked, unblock
2452c39ec064SRoger A. Faulkner 		 * it here so that child death signals can come in.
24537c478bd9Sstevel@tonic-gate 		 */
2454c39ec064SRoger A. Faulkner 		(void) sigrelse(SIGCLD);
24557c478bd9Sstevel@tonic-gate 		(void) pause();
2456c39ec064SRoger A. Faulkner 		(void) sighold(SIGCLD);
24577c478bd9Sstevel@tonic-gate 		setimer(0);
24587c478bd9Sstevel@tonic-gate 	}
24597c478bd9Sstevel@tonic-gate 
24607c478bd9Sstevel@tonic-gate 	if (childpid != 0) {
24617c478bd9Sstevel@tonic-gate 
24627c478bd9Sstevel@tonic-gate 		if (process == NULLPROC) {
24637c478bd9Sstevel@tonic-gate 			/*
24647c478bd9Sstevel@tonic-gate 			 * No proc table pointer specified so search
24657c478bd9Sstevel@tonic-gate 			 * for a free slot.
24667c478bd9Sstevel@tonic-gate 			 */
24677c478bd9Sstevel@tonic-gate 			for (process = proc_table;  process->p_flags != 0 &&
246848847494SEnrico Perla - Sun Microsystems 			    (process < proc_table + num_proc); process++)
24697c478bd9Sstevel@tonic-gate 					;
24707c478bd9Sstevel@tonic-gate 
24717c478bd9Sstevel@tonic-gate 			if (process == (proc_table + num_proc)) {
24727c478bd9Sstevel@tonic-gate 				int old_proc_table_size = num_proc;
24737c478bd9Sstevel@tonic-gate 
24747c478bd9Sstevel@tonic-gate 				/* Increase the process table size */
24757c478bd9Sstevel@tonic-gate 				increase_proc_table_size();
24767c478bd9Sstevel@tonic-gate 				if (old_proc_table_size == num_proc) {
24777c478bd9Sstevel@tonic-gate 					/* didn't grow: memory failure */
24787c478bd9Sstevel@tonic-gate 					return (NO_ROOM);
24797c478bd9Sstevel@tonic-gate 				} else {
24807c478bd9Sstevel@tonic-gate 					process =
24817c478bd9Sstevel@tonic-gate 					    proc_table + old_proc_table_size;
24827c478bd9Sstevel@tonic-gate 				}
24837c478bd9Sstevel@tonic-gate 			}
24847c478bd9Sstevel@tonic-gate 
24857c478bd9Sstevel@tonic-gate 			process->p_time = 0L;
24867c478bd9Sstevel@tonic-gate 			process->p_count = 0;
24877c478bd9Sstevel@tonic-gate 		}
24887c478bd9Sstevel@tonic-gate 		process->p_id[0] = '\0';
24897c478bd9Sstevel@tonic-gate 		process->p_id[1] = '\0';
24907c478bd9Sstevel@tonic-gate 		process->p_id[2] = '\0';
24917c478bd9Sstevel@tonic-gate 		process->p_id[3] = '\0';
24927c478bd9Sstevel@tonic-gate 		process->p_pid = childpid;
24937c478bd9Sstevel@tonic-gate 		process->p_flags = (LIVING | OCCUPIED | modes);
24947c478bd9Sstevel@tonic-gate 		process->p_exit = 0;
24957c478bd9Sstevel@tonic-gate 
24967c478bd9Sstevel@tonic-gate 		st_write();
24977c478bd9Sstevel@tonic-gate 	} else {
24987c478bd9Sstevel@tonic-gate 		if ((action & (M_WAIT | M_BOOTWAIT)) == 0)
24997c478bd9Sstevel@tonic-gate 			(void) setpgrp();
25007c478bd9Sstevel@tonic-gate 
25017c478bd9Sstevel@tonic-gate 		process = NULLPROC;
25027c478bd9Sstevel@tonic-gate 
25037c478bd9Sstevel@tonic-gate 		/*
25047c478bd9Sstevel@tonic-gate 		 * Reset all signals to the system defaults.
25057c478bd9Sstevel@tonic-gate 		 */
25067c478bd9Sstevel@tonic-gate 		for (i = SIGHUP; i <= SIGRTMAX; i++)
25077c478bd9Sstevel@tonic-gate 			(void) sigset(i, SIG_DFL);
25087c478bd9Sstevel@tonic-gate 
25097c478bd9Sstevel@tonic-gate 		/*
25107c478bd9Sstevel@tonic-gate 		 * POSIX B.2.2.2 advises that init should set SIGTTOU,
25117c478bd9Sstevel@tonic-gate 		 * SIGTTIN, and SIGTSTP to SIG_IGN.
25127c478bd9Sstevel@tonic-gate 		 *
25137c478bd9Sstevel@tonic-gate 		 * Make sure that SIGXCPU and SIGXFSZ also remain ignored,
25147c478bd9Sstevel@tonic-gate 		 * for backward compatibility.
25157c478bd9Sstevel@tonic-gate 		 */
25167c478bd9Sstevel@tonic-gate 		(void) sigset(SIGTTIN, SIG_IGN);
25177c478bd9Sstevel@tonic-gate 		(void) sigset(SIGTTOU, SIG_IGN);
25187c478bd9Sstevel@tonic-gate 		(void) sigset(SIGTSTP, SIG_IGN);
25197c478bd9Sstevel@tonic-gate 		(void) sigset(SIGXCPU, SIG_IGN);
25207c478bd9Sstevel@tonic-gate 		(void) sigset(SIGXFSZ, SIG_IGN);
25217c478bd9Sstevel@tonic-gate 	}
25227c478bd9Sstevel@tonic-gate 	return (process);
25237c478bd9Sstevel@tonic-gate }
25247c478bd9Sstevel@tonic-gate 
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate /*
25277c478bd9Sstevel@tonic-gate  * waitproc() waits for a specified process to die.  For this function to
25287c478bd9Sstevel@tonic-gate  * work, the specified process must already in the proc_table.  waitproc()
25297c478bd9Sstevel@tonic-gate  * returns the exit status of the specified process when it dies.
25307c478bd9Sstevel@tonic-gate  */
25317c478bd9Sstevel@tonic-gate static long
25327c478bd9Sstevel@tonic-gate waitproc(struct PROC_TABLE *process)
25337c478bd9Sstevel@tonic-gate {
25347c478bd9Sstevel@tonic-gate 	int		answer;
25357c478bd9Sstevel@tonic-gate 	sigset_t	oldmask, newmask, zeromask;
25367c478bd9Sstevel@tonic-gate 
25377c478bd9Sstevel@tonic-gate 	(void) sigemptyset(&zeromask);
25387c478bd9Sstevel@tonic-gate 	(void) sigemptyset(&newmask);
25397c478bd9Sstevel@tonic-gate 
25407c478bd9Sstevel@tonic-gate 	(void) sigaddset(&newmask, SIGCLD);
25417c478bd9Sstevel@tonic-gate 
25427c478bd9Sstevel@tonic-gate 	/* Block SIGCLD and save the current signal mask */
25437c478bd9Sstevel@tonic-gate 	if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
25447c478bd9Sstevel@tonic-gate 		perror("SIG_BLOCK error");
25457c478bd9Sstevel@tonic-gate 
25467c478bd9Sstevel@tonic-gate 	/*
25477c478bd9Sstevel@tonic-gate 	 * Wait around until the process dies.
25487c478bd9Sstevel@tonic-gate 	 */
25497c478bd9Sstevel@tonic-gate 	if (process->p_flags & LIVING)
25507c478bd9Sstevel@tonic-gate 		(void) sigsuspend(&zeromask);
25517c478bd9Sstevel@tonic-gate 
25527c478bd9Sstevel@tonic-gate 	/* Reset signal mask to unblock SIGCLD */
25537c478bd9Sstevel@tonic-gate 	if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
25547c478bd9Sstevel@tonic-gate 		perror("SIG_SETMASK error");
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate 	if (process->p_flags & LIVING)
25577c478bd9Sstevel@tonic-gate 		return (FAILURE);
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 	/*
25607c478bd9Sstevel@tonic-gate 	 * Make sure to only return 16 bits so that answer will always
25617c478bd9Sstevel@tonic-gate 	 * be positive whenever the process of interest really died.
25627c478bd9Sstevel@tonic-gate 	 */
25637c478bd9Sstevel@tonic-gate 	answer = (process->p_exit & 0xffff);
25647c478bd9Sstevel@tonic-gate 
25657c478bd9Sstevel@tonic-gate 	/*
25667c478bd9Sstevel@tonic-gate 	 * Free the slot in the proc_table.
25677c478bd9Sstevel@tonic-gate 	 */
25687c478bd9Sstevel@tonic-gate 	process->p_flags = 0;
25697c478bd9Sstevel@tonic-gate 	return (answer);
25707c478bd9Sstevel@tonic-gate }
25717c478bd9Sstevel@tonic-gate 
25727c478bd9Sstevel@tonic-gate /*
25737c478bd9Sstevel@tonic-gate  * notify_pam_dead(): calls into the PAM framework to close the given session.
25747c478bd9Sstevel@tonic-gate  */
25757c478bd9Sstevel@tonic-gate static void
25767c478bd9Sstevel@tonic-gate notify_pam_dead(struct utmpx *up)
25777c478bd9Sstevel@tonic-gate {
25787c478bd9Sstevel@tonic-gate 	pam_handle_t *pamh;
25797c478bd9Sstevel@tonic-gate 	char user[sizeof (up->ut_user) + 1];
25807c478bd9Sstevel@tonic-gate 	char ttyn[sizeof (up->ut_line) + 1];
25817c478bd9Sstevel@tonic-gate 	char host[sizeof (up->ut_host) + 1];
25827c478bd9Sstevel@tonic-gate 
25837c478bd9Sstevel@tonic-gate 	/*
25847c478bd9Sstevel@tonic-gate 	 * PAM does not take care of updating utmpx/wtmpx.
25857c478bd9Sstevel@tonic-gate 	 */
25867c478bd9Sstevel@tonic-gate 	(void) snprintf(user, sizeof (user), "%s", up->ut_user);
25877c478bd9Sstevel@tonic-gate 	(void) snprintf(ttyn, sizeof (ttyn), "%s", up->ut_line);
25887c478bd9Sstevel@tonic-gate 	(void) snprintf(host, sizeof (host), "%s", up->ut_host);
25897c478bd9Sstevel@tonic-gate 
25907c478bd9Sstevel@tonic-gate 	if (pam_start("init", user, NULL, &pamh) == PAM_SUCCESS)  {
25917c478bd9Sstevel@tonic-gate 		(void) pam_set_item(pamh, PAM_TTY, ttyn);
25927c478bd9Sstevel@tonic-gate 		(void) pam_set_item(pamh, PAM_RHOST, host);
25937c478bd9Sstevel@tonic-gate 		(void) pam_close_session(pamh, 0);
25947c478bd9Sstevel@tonic-gate 		(void) pam_end(pamh, PAM_SUCCESS);
25957c478bd9Sstevel@tonic-gate 	}
25967c478bd9Sstevel@tonic-gate }
25977c478bd9Sstevel@tonic-gate 
25987c478bd9Sstevel@tonic-gate /*
25997c478bd9Sstevel@tonic-gate  * Check you can access utmpx (As / may be read-only and
26007c478bd9Sstevel@tonic-gate  * /var may not be mounted yet).
26017c478bd9Sstevel@tonic-gate  */
26027c478bd9Sstevel@tonic-gate static int
26037c478bd9Sstevel@tonic-gate access_utmpx(void)
26047c478bd9Sstevel@tonic-gate {
26057c478bd9Sstevel@tonic-gate 	do {
26067c478bd9Sstevel@tonic-gate 		utmpx_ok = (access(UTMPX, R_OK|W_OK) == 0);
26077c478bd9Sstevel@tonic-gate 	} while (!utmpx_ok && errno == EINTR);
26087c478bd9Sstevel@tonic-gate 
26097c478bd9Sstevel@tonic-gate 	return (utmpx_ok);
26107c478bd9Sstevel@tonic-gate }
26117c478bd9Sstevel@tonic-gate 
26127c478bd9Sstevel@tonic-gate /*
26137c478bd9Sstevel@tonic-gate  * account() updates entries in utmpx and appends new entries to the end of
26147c478bd9Sstevel@tonic-gate  * wtmpx (assuming they exist).  The program argument indicates the name of
26157c478bd9Sstevel@tonic-gate  * program if INIT_PROCESS, otherwise should be NULL.
26167c478bd9Sstevel@tonic-gate  *
26177c478bd9Sstevel@tonic-gate  * account() only blocks for INIT_PROCESS requests.
26187c478bd9Sstevel@tonic-gate  *
26197c478bd9Sstevel@tonic-gate  * Returns non-zero if write failed.
26207c478bd9Sstevel@tonic-gate  */
26217c478bd9Sstevel@tonic-gate static int
26227c478bd9Sstevel@tonic-gate account(short state, struct PROC_TABLE *process, char *program)
26237c478bd9Sstevel@tonic-gate {
26247c478bd9Sstevel@tonic-gate 	struct utmpx utmpbuf, *u, *oldu;
26257c478bd9Sstevel@tonic-gate 	int tmplen;
26267c478bd9Sstevel@tonic-gate 	char fail_buf[UT_LINE_SZ];
26277c478bd9Sstevel@tonic-gate 	sigset_t block, unblock;
26287c478bd9Sstevel@tonic-gate 
26297c478bd9Sstevel@tonic-gate 	if (!utmpx_ok && !access_utmpx()) {
26307c478bd9Sstevel@tonic-gate 		return (-1);
26317c478bd9Sstevel@tonic-gate 	}
26327c478bd9Sstevel@tonic-gate 
26337c478bd9Sstevel@tonic-gate 	/*
26347c478bd9Sstevel@tonic-gate 	 * Set up the prototype for the utmp structure we want to write.
26357c478bd9Sstevel@tonic-gate 	 */
26367c478bd9Sstevel@tonic-gate 	u = &utmpbuf;
26377c478bd9Sstevel@tonic-gate 	(void) memset(u, 0, sizeof (struct utmpx));
26387c478bd9Sstevel@tonic-gate 
26397c478bd9Sstevel@tonic-gate 	/*
26407c478bd9Sstevel@tonic-gate 	 * Fill in the various fields of the utmp structure.
26417c478bd9Sstevel@tonic-gate 	 */
26427c478bd9Sstevel@tonic-gate 	u->ut_id[0] = process->p_id[0];
26437c478bd9Sstevel@tonic-gate 	u->ut_id[1] = process->p_id[1];
26447c478bd9Sstevel@tonic-gate 	u->ut_id[2] = process->p_id[2];
26457c478bd9Sstevel@tonic-gate 	u->ut_id[3] = process->p_id[3];
26467c478bd9Sstevel@tonic-gate 	u->ut_pid = process->p_pid;
26477c478bd9Sstevel@tonic-gate 
26487c478bd9Sstevel@tonic-gate 	/*
26497c478bd9Sstevel@tonic-gate 	 * Fill the "ut_exit" structure.
26507c478bd9Sstevel@tonic-gate 	 */
26517c478bd9Sstevel@tonic-gate 	u->ut_exit.e_termination = WTERMSIG(process->p_exit);
26527c478bd9Sstevel@tonic-gate 	u->ut_exit.e_exit = WEXITSTATUS(process->p_exit);
26537c478bd9Sstevel@tonic-gate 	u->ut_type = state;
26547c478bd9Sstevel@tonic-gate 
26557c478bd9Sstevel@tonic-gate 	(void) time(&u->ut_tv.tv_sec);
26567c478bd9Sstevel@tonic-gate 
26577c478bd9Sstevel@tonic-gate 	/*
26587c478bd9Sstevel@tonic-gate 	 * Block signals for utmp update.
26597c478bd9Sstevel@tonic-gate 	 */
26607c478bd9Sstevel@tonic-gate 	(void) sigfillset(&block);
26617c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_BLOCK, &block, &unblock);
26627c478bd9Sstevel@tonic-gate 
26637c478bd9Sstevel@tonic-gate 	/*
26647c478bd9Sstevel@tonic-gate 	 * See if there already is such an entry in the "utmpx" file.
26657c478bd9Sstevel@tonic-gate 	 */
26667c478bd9Sstevel@tonic-gate 	setutxent();	/* Start at beginning of utmpx file. */
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 	if ((oldu = getutxid(u)) != NULL) {
26697c478bd9Sstevel@tonic-gate 		/*
26707c478bd9Sstevel@tonic-gate 		 * Copy in the old "user", "line" and "host" fields
26717c478bd9Sstevel@tonic-gate 		 * to our new structure.
26727c478bd9Sstevel@tonic-gate 		 */
26737c478bd9Sstevel@tonic-gate 		bcopy(oldu->ut_user, u->ut_user, sizeof (u->ut_user));
26747c478bd9Sstevel@tonic-gate 		bcopy(oldu->ut_line, u->ut_line, sizeof (u->ut_line));
26757c478bd9Sstevel@tonic-gate 		bcopy(oldu->ut_host, u->ut_host, sizeof (u->ut_host));
26767c478bd9Sstevel@tonic-gate 		u->ut_syslen = (tmplen = strlen(u->ut_host)) ?
267748847494SEnrico Perla - Sun Microsystems 		    min(tmplen + 1, sizeof (u->ut_host)) : 0;
26787c478bd9Sstevel@tonic-gate 
26797c478bd9Sstevel@tonic-gate 		if (oldu->ut_type == USER_PROCESS && state == DEAD_PROCESS) {
26807c478bd9Sstevel@tonic-gate 			notify_pam_dead(oldu);
26817c478bd9Sstevel@tonic-gate 		}
26827c478bd9Sstevel@tonic-gate 	}
26837c478bd9Sstevel@tonic-gate 
26847c478bd9Sstevel@tonic-gate 	/*
26857c478bd9Sstevel@tonic-gate 	 * Perform special accounting. Insert the special string into the
26867c478bd9Sstevel@tonic-gate 	 * ut_line array. For INIT_PROCESSes put in the name of the
26877c478bd9Sstevel@tonic-gate 	 * program in the "ut_user" field.
26887c478bd9Sstevel@tonic-gate 	 */
26897c478bd9Sstevel@tonic-gate 	switch (state) {
26907c478bd9Sstevel@tonic-gate 	case INIT_PROCESS:
26917c478bd9Sstevel@tonic-gate 		(void) strncpy(u->ut_user, program, sizeof (u->ut_user));
26927c478bd9Sstevel@tonic-gate 		(void) strcpy(fail_buf, "INIT_PROCESS");
26937c478bd9Sstevel@tonic-gate 		break;
26947c478bd9Sstevel@tonic-gate 
26957c478bd9Sstevel@tonic-gate 	default:
26967c478bd9Sstevel@tonic-gate 		(void) strlcpy(fail_buf, u->ut_id, sizeof (u->ut_id) + 1);
26977c478bd9Sstevel@tonic-gate 		break;
26987c478bd9Sstevel@tonic-gate 	}
26997c478bd9Sstevel@tonic-gate 
27007c478bd9Sstevel@tonic-gate 	/*
27017c478bd9Sstevel@tonic-gate 	 * Write out the updated entry to utmpx file.
27027c478bd9Sstevel@tonic-gate 	 */
27037c478bd9Sstevel@tonic-gate 	if (pututxline(u) == NULL) {
27047c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Failed write of utmpx entry: \"%s\": %s\n",
27057c478bd9Sstevel@tonic-gate 		    fail_buf, strerror(errno));
27067c478bd9Sstevel@tonic-gate 		endutxent();
27077c478bd9Sstevel@tonic-gate 		(void) sigprocmask(SIG_SETMASK, &unblock, NULL);
27087c478bd9Sstevel@tonic-gate 		return (-1);
27097c478bd9Sstevel@tonic-gate 	}
27107c478bd9Sstevel@tonic-gate 
27117c478bd9Sstevel@tonic-gate 	/*
27127c478bd9Sstevel@tonic-gate 	 * If we're able to write to utmpx, then attempt to add to the
27137c478bd9Sstevel@tonic-gate 	 * end of the wtmpx file.
27147c478bd9Sstevel@tonic-gate 	 */
27157c478bd9Sstevel@tonic-gate 	updwtmpx(WTMPX, u);
27167c478bd9Sstevel@tonic-gate 
27177c478bd9Sstevel@tonic-gate 	endutxent();
27187c478bd9Sstevel@tonic-gate 
27197c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_SETMASK, &unblock, NULL);
27207c478bd9Sstevel@tonic-gate 
27217c478bd9Sstevel@tonic-gate 	return (0);
27227c478bd9Sstevel@tonic-gate }
27237c478bd9Sstevel@tonic-gate 
27247c478bd9Sstevel@tonic-gate static void
27257c478bd9Sstevel@tonic-gate clearent(pid_t pid, short status)
27267c478bd9Sstevel@tonic-gate {
27277c478bd9Sstevel@tonic-gate 	struct utmpx *up;
27287c478bd9Sstevel@tonic-gate 	sigset_t block, unblock;
27297c478bd9Sstevel@tonic-gate 
27307c478bd9Sstevel@tonic-gate 	/*
27317c478bd9Sstevel@tonic-gate 	 * Block signals for utmp update.
27327c478bd9Sstevel@tonic-gate 	 */
27337c478bd9Sstevel@tonic-gate 	(void) sigfillset(&block);
27347c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_BLOCK, &block, &unblock);
27357c478bd9Sstevel@tonic-gate 
27367c478bd9Sstevel@tonic-gate 	/*
27377c478bd9Sstevel@tonic-gate 	 * No error checking for now.
27387c478bd9Sstevel@tonic-gate 	 */
27397c478bd9Sstevel@tonic-gate 
27407c478bd9Sstevel@tonic-gate 	setutxent();
27417c478bd9Sstevel@tonic-gate 	while (up = getutxent()) {
27427c478bd9Sstevel@tonic-gate 		if (up->ut_pid == pid) {
27437c478bd9Sstevel@tonic-gate 			if (up->ut_type == DEAD_PROCESS) {
27447c478bd9Sstevel@tonic-gate 				/*
27457c478bd9Sstevel@tonic-gate 				 * Cleaned up elsewhere.
27467c478bd9Sstevel@tonic-gate 				 */
27477c478bd9Sstevel@tonic-gate 				continue;
27487c478bd9Sstevel@tonic-gate 			}
27497c478bd9Sstevel@tonic-gate 
27507c478bd9Sstevel@tonic-gate 			notify_pam_dead(up);
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate 			up->ut_type = DEAD_PROCESS;
27537c478bd9Sstevel@tonic-gate 			up->ut_exit.e_termination = WTERMSIG(status);
27547c478bd9Sstevel@tonic-gate 			up->ut_exit.e_exit = WEXITSTATUS(status);
27557c478bd9Sstevel@tonic-gate 			(void) time(&up->ut_tv.tv_sec);
27567c478bd9Sstevel@tonic-gate 
27577c478bd9Sstevel@tonic-gate 			(void) pututxline(up);
27587c478bd9Sstevel@tonic-gate 			/*
27597c478bd9Sstevel@tonic-gate 			 * Now attempt to add to the end of the
27607c478bd9Sstevel@tonic-gate 			 * wtmp and wtmpx files.  Do not create
27617c478bd9Sstevel@tonic-gate 			 * if they don't already exist.
27627c478bd9Sstevel@tonic-gate 			 */
27637c478bd9Sstevel@tonic-gate 			updwtmpx(WTMPX, up);
27647c478bd9Sstevel@tonic-gate 
27657c478bd9Sstevel@tonic-gate 			break;
27667c478bd9Sstevel@tonic-gate 		}
27677c478bd9Sstevel@tonic-gate 	}
27687c478bd9Sstevel@tonic-gate 
27697c478bd9Sstevel@tonic-gate 	endutxent();
27707c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_SETMASK, &unblock, NULL);
27717c478bd9Sstevel@tonic-gate }
27727c478bd9Sstevel@tonic-gate 
27737c478bd9Sstevel@tonic-gate /*
27747c478bd9Sstevel@tonic-gate  * prog_name() searches for the word or unix path name and
27757c478bd9Sstevel@tonic-gate  * returns a pointer to the last element of the pathname.
27767c478bd9Sstevel@tonic-gate  */
27777c478bd9Sstevel@tonic-gate static char *
27787c478bd9Sstevel@tonic-gate prog_name(char *string)
27797c478bd9Sstevel@tonic-gate {
27807c478bd9Sstevel@tonic-gate 	char	*ptr, *ptr2;
27810a1278f2SGary Mills 	static char word[UT_USER_SZ + 1];
27827c478bd9Sstevel@tonic-gate 
27837c478bd9Sstevel@tonic-gate 	/*
27847c478bd9Sstevel@tonic-gate 	 * Search for the first word skipping leading spaces and tabs.
27857c478bd9Sstevel@tonic-gate 	 */
27867c478bd9Sstevel@tonic-gate 	while (*string == ' ' || *string == '\t')
27877c478bd9Sstevel@tonic-gate 		string++;
27887c478bd9Sstevel@tonic-gate 
27897c478bd9Sstevel@tonic-gate 	/*
27907c478bd9Sstevel@tonic-gate 	 * If the first non-space non-tab character is not one allowed in
27917c478bd9Sstevel@tonic-gate 	 * a word, return a pointer to a null string, otherwise parse the
27927c478bd9Sstevel@tonic-gate 	 * pathname.
27937c478bd9Sstevel@tonic-gate 	 */
27947c478bd9Sstevel@tonic-gate 	if (*string != '.' && *string != '/' && *string != '_' &&
27957c478bd9Sstevel@tonic-gate 	    (*string < 'a' || *string > 'z') &&
27967c478bd9Sstevel@tonic-gate 	    (*string < 'A' || * string > 'Z') &&
27977c478bd9Sstevel@tonic-gate 	    (*string < '0' || *string > '9'))
27987c478bd9Sstevel@tonic-gate 		return ("");
27997c478bd9Sstevel@tonic-gate 
28007c478bd9Sstevel@tonic-gate 	/*
28017c478bd9Sstevel@tonic-gate 	 * Parse the pathname looking forward for '/', ' ', '\t', '\n' or
28027c478bd9Sstevel@tonic-gate 	 * '\0'.  Each time a '/' is found, move "ptr" to one past the
28037c478bd9Sstevel@tonic-gate 	 * '/', thus when a ' ', '\t', '\n', or '\0' is found, "ptr" will
28047c478bd9Sstevel@tonic-gate 	 * point to the last element of the pathname.
28057c478bd9Sstevel@tonic-gate 	 */
2806c39ec064SRoger A. Faulkner 	for (ptr = string; *string != ' ' && *string != '\t' &&
280748847494SEnrico Perla - Sun Microsystems 	    *string != '\n' && *string != '\0'; string++) {
28087c478bd9Sstevel@tonic-gate 		if (*string == '/')
28097c478bd9Sstevel@tonic-gate 			ptr = string+1;
28107c478bd9Sstevel@tonic-gate 	}
28117c478bd9Sstevel@tonic-gate 
28127c478bd9Sstevel@tonic-gate 	/*
28137c478bd9Sstevel@tonic-gate 	 * Copy out up to the size of the "ut_user" array into "word",
28147c478bd9Sstevel@tonic-gate 	 * null terminate it and return a pointer to it.
28157c478bd9Sstevel@tonic-gate 	 */
28160a1278f2SGary Mills 	for (ptr2 = &word[0]; ptr2 < &word[UT_USER_SZ] &&
28177c478bd9Sstevel@tonic-gate 	    ptr < string; /* CSTYLED */)
28187c478bd9Sstevel@tonic-gate 		*ptr2++ = *ptr++;
28197c478bd9Sstevel@tonic-gate 
28207c478bd9Sstevel@tonic-gate 	*ptr2 = '\0';
28217c478bd9Sstevel@tonic-gate 	return (&word[0]);
28227c478bd9Sstevel@tonic-gate }
28237c478bd9Sstevel@tonic-gate 
28247c478bd9Sstevel@tonic-gate 
28257c478bd9Sstevel@tonic-gate /*
28267c478bd9Sstevel@tonic-gate  * realcon() returns a nonzero value if there is a character device
28277c478bd9Sstevel@tonic-gate  * associated with SYSCON that has the same device number as CONSOLE.
28287c478bd9Sstevel@tonic-gate  */
28297c478bd9Sstevel@tonic-gate static int
28307c478bd9Sstevel@tonic-gate realcon()
28317c478bd9Sstevel@tonic-gate {
28327c478bd9Sstevel@tonic-gate 	struct stat sconbuf, conbuf;
28337c478bd9Sstevel@tonic-gate 
28347c478bd9Sstevel@tonic-gate 	if (stat(SYSCON, &sconbuf) != -1 &&
28357c478bd9Sstevel@tonic-gate 	    stat(CONSOLE, &conbuf) != -1 &&
28364bc0a2efScasper 	    S_ISCHR(sconbuf.st_mode) &&
28374bc0a2efScasper 	    S_ISCHR(conbuf.st_mode) &&
28387c478bd9Sstevel@tonic-gate 	    sconbuf.st_rdev == conbuf.st_rdev) {
28397c478bd9Sstevel@tonic-gate 		return (1);
28407c478bd9Sstevel@tonic-gate 	} else {
28417c478bd9Sstevel@tonic-gate 		return (0);
28427c478bd9Sstevel@tonic-gate 	}
28437c478bd9Sstevel@tonic-gate }
28447c478bd9Sstevel@tonic-gate 
28457c478bd9Sstevel@tonic-gate 
28467c478bd9Sstevel@tonic-gate /*
28477c478bd9Sstevel@tonic-gate  * get_ioctl_syscon() retrieves the SYSCON settings from the IOCTLSYSCON file.
28487c478bd9Sstevel@tonic-gate  * Returns true if the IOCTLSYSCON file needs to be written (with
28497c478bd9Sstevel@tonic-gate  * write_ioctl_syscon() below)
28507c478bd9Sstevel@tonic-gate  */
28517c478bd9Sstevel@tonic-gate static int
28527c478bd9Sstevel@tonic-gate get_ioctl_syscon()
28537c478bd9Sstevel@tonic-gate {
28547c478bd9Sstevel@tonic-gate 	FILE	*fp;
28557c478bd9Sstevel@tonic-gate 	unsigned int	iflags, oflags, cflags, lflags, ldisc, cc[18];
28567c478bd9Sstevel@tonic-gate 	int		i, valid_format = 0;
28577c478bd9Sstevel@tonic-gate 
28587c478bd9Sstevel@tonic-gate 	/*
28597c478bd9Sstevel@tonic-gate 	 * Read in the previous modes for SYSCON from IOCTLSYSCON.
28607c478bd9Sstevel@tonic-gate 	 */
28617c478bd9Sstevel@tonic-gate 	if ((fp = fopen(IOCTLSYSCON, "r")) == NULL) {
28627c478bd9Sstevel@tonic-gate 		stored_syscon_termios = dflt_termios;
28637c478bd9Sstevel@tonic-gate 		console(B_TRUE,
28647c478bd9Sstevel@tonic-gate 		    "warning:%s does not exist, default settings assumed\n",
28657c478bd9Sstevel@tonic-gate 		    IOCTLSYSCON);
28667c478bd9Sstevel@tonic-gate 	} else {
28677c478bd9Sstevel@tonic-gate 
28680a1278f2SGary Mills 		i = fscanf(fp,
28697c478bd9Sstevel@tonic-gate 	    "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x",
28700a1278f2SGary Mills 		    &iflags, &oflags, &cflags, &lflags,
28710a1278f2SGary Mills 		    &cc[0], &cc[1], &cc[2], &cc[3], &cc[4], &cc[5], &cc[6],
28720a1278f2SGary Mills 		    &cc[7], &cc[8], &cc[9], &cc[10], &cc[11], &cc[12], &cc[13],
28730a1278f2SGary Mills 		    &cc[14], &cc[15], &cc[16], &cc[17]);
28740a1278f2SGary Mills 
28750a1278f2SGary Mills 		if (i == 22) {
28760a1278f2SGary Mills 			stored_syscon_termios.c_iflag = iflags;
28770a1278f2SGary Mills 			stored_syscon_termios.c_oflag = oflags;
28780a1278f2SGary Mills 			stored_syscon_termios.c_cflag = cflags;
28790a1278f2SGary Mills 			stored_syscon_termios.c_lflag = lflags;
28800a1278f2SGary Mills 			for (i = 0; i < 18; i++)
28810a1278f2SGary Mills 				stored_syscon_termios.c_cc[i] = (char)cc[i];
28820a1278f2SGary Mills 			valid_format = 1;
28830a1278f2SGary Mills 		} else if (i == 13) {
28847c478bd9Sstevel@tonic-gate 		rewind(fp);
28857c478bd9Sstevel@tonic-gate 		i = fscanf(fp, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x",
28867c478bd9Sstevel@tonic-gate 		    &iflags, &oflags, &cflags, &lflags, &ldisc, &cc[0], &cc[1],
28877c478bd9Sstevel@tonic-gate 		    &cc[2], &cc[3], &cc[4], &cc[5], &cc[6], &cc[7]);
28887c478bd9Sstevel@tonic-gate 
28897c478bd9Sstevel@tonic-gate 		/*
28907c478bd9Sstevel@tonic-gate 		 * If the file is formatted properly, use the values to
28917c478bd9Sstevel@tonic-gate 		 * initialize the console terminal condition.
28927c478bd9Sstevel@tonic-gate 		 */
28937c478bd9Sstevel@tonic-gate 		stored_syscon_termios.c_iflag = (ushort_t)iflags;
28947c478bd9Sstevel@tonic-gate 		stored_syscon_termios.c_oflag = (ushort_t)oflags;
28957c478bd9Sstevel@tonic-gate 		stored_syscon_termios.c_cflag = (ushort_t)cflags;
28967c478bd9Sstevel@tonic-gate 		stored_syscon_termios.c_lflag = (ushort_t)lflags;
28977c478bd9Sstevel@tonic-gate 		for (i = 0; i < 8; i++)
28987c478bd9Sstevel@tonic-gate 			stored_syscon_termios.c_cc[i] = (char)cc[i];
28997c478bd9Sstevel@tonic-gate 		valid_format = 1;
29000a1278f2SGary Mills 		}
29010a1278f2SGary Mills 		(void) fclose(fp);
29027c478bd9Sstevel@tonic-gate 
29030a1278f2SGary Mills 		/* If the file is badly formatted, use the default settings. */
29040a1278f2SGary Mills 		if (!valid_format)
29050a1278f2SGary Mills 			stored_syscon_termios = dflt_termios;
29067c478bd9Sstevel@tonic-gate 	}
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	/* If the file had a bad format, rewrite it later. */
29097c478bd9Sstevel@tonic-gate 	return (!valid_format);
29107c478bd9Sstevel@tonic-gate }
29117c478bd9Sstevel@tonic-gate 
29127c478bd9Sstevel@tonic-gate 
29137c478bd9Sstevel@tonic-gate static void
29147c478bd9Sstevel@tonic-gate write_ioctl_syscon()
29157c478bd9Sstevel@tonic-gate {
29167c478bd9Sstevel@tonic-gate 	FILE *fp;
29177c478bd9Sstevel@tonic-gate 	int i;
29187c478bd9Sstevel@tonic-gate 
29197c478bd9Sstevel@tonic-gate 	(void) unlink(SYSCON);
29207c478bd9Sstevel@tonic-gate 	(void) link(SYSTTY, SYSCON);
29217c478bd9Sstevel@tonic-gate 	(void) umask(022);
29227c478bd9Sstevel@tonic-gate 	fp = fopen(IOCTLSYSCON, "w");
29237c478bd9Sstevel@tonic-gate 
29247c478bd9Sstevel@tonic-gate 	(void) fprintf(fp, "%x:%x:%x:%x:0", stored_syscon_termios.c_iflag,
29257c478bd9Sstevel@tonic-gate 	    stored_syscon_termios.c_oflag, stored_syscon_termios.c_cflag,
29267c478bd9Sstevel@tonic-gate 	    stored_syscon_termios.c_lflag);
29277c478bd9Sstevel@tonic-gate 	for (i = 0; i < 8; ++i)
29287c478bd9Sstevel@tonic-gate 		(void) fprintf(fp, ":%x", stored_syscon_termios.c_cc[i]);
29297c478bd9Sstevel@tonic-gate 	(void) putc('\n', fp);
29307c478bd9Sstevel@tonic-gate 
29317c478bd9Sstevel@tonic-gate 	(void) fflush(fp);
29327c478bd9Sstevel@tonic-gate 	(void) fsync(fileno(fp));
29337c478bd9Sstevel@tonic-gate 	(void) fclose(fp);
29347c478bd9Sstevel@tonic-gate 	(void) umask(cmask);
29357c478bd9Sstevel@tonic-gate }
29367c478bd9Sstevel@tonic-gate 
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate /*
29397c478bd9Sstevel@tonic-gate  * void console(boolean_t, char *, ...)
29407c478bd9Sstevel@tonic-gate  *   Outputs the requested message to the system console.  Note that the number
29417c478bd9Sstevel@tonic-gate  *   of arguments passed to console() should be determined by the print format.
29427c478bd9Sstevel@tonic-gate  *
29437c478bd9Sstevel@tonic-gate  *   The "prefix" parameter indicates whether or not "INIT: " should precede the
29447c478bd9Sstevel@tonic-gate  *   message.
29457c478bd9Sstevel@tonic-gate  *
29467c478bd9Sstevel@tonic-gate  *   To make sure we write to the console in a sane fashion, we use the modes
29477c478bd9Sstevel@tonic-gate  *   we keep in stored_syscon_termios (which we read out of /etc/ioctl.syscon).
29487c478bd9Sstevel@tonic-gate  *   Afterwards we restore whatever modes were already there.
29497c478bd9Sstevel@tonic-gate  */
29507c478bd9Sstevel@tonic-gate /* PRINTFLIKE2 */
29517c478bd9Sstevel@tonic-gate static void
29527c478bd9Sstevel@tonic-gate console(boolean_t prefix, char *format, ...)
29537c478bd9Sstevel@tonic-gate {
29547c478bd9Sstevel@tonic-gate 	char	outbuf[BUFSIZ];
29557c478bd9Sstevel@tonic-gate 	va_list	args;
29567c478bd9Sstevel@tonic-gate 	int fd, getret;
29577c478bd9Sstevel@tonic-gate 	struct termios old_syscon_termios;
29587c478bd9Sstevel@tonic-gate 	FILE *f;
29597c478bd9Sstevel@tonic-gate 
29607c478bd9Sstevel@tonic-gate 	/*
29617c478bd9Sstevel@tonic-gate 	 * We open SYSCON anew each time in case it has changed (see
29627c478bd9Sstevel@tonic-gate 	 * userinit()).
29637c478bd9Sstevel@tonic-gate 	 */
29647c478bd9Sstevel@tonic-gate 	if ((fd = open(SYSCON, O_RDWR | O_NOCTTY)) < 0 ||
29657c478bd9Sstevel@tonic-gate 	    (f = fdopen(fd, "r+")) == NULL) {
29667c478bd9Sstevel@tonic-gate 		if (prefix)
29677c478bd9Sstevel@tonic-gate 			syslog(LOG_WARNING, "INIT: ");
29687c478bd9Sstevel@tonic-gate 		va_start(args, format);
29697c478bd9Sstevel@tonic-gate 		vsyslog(LOG_WARNING, format, args);
29707c478bd9Sstevel@tonic-gate 		va_end(args);
29717c478bd9Sstevel@tonic-gate 		if (fd >= 0)
29727c478bd9Sstevel@tonic-gate 			(void) close(fd);
29737c478bd9Sstevel@tonic-gate 		return;
29747c478bd9Sstevel@tonic-gate 	}
29757c478bd9Sstevel@tonic-gate 	setbuf(f, &outbuf[0]);
29767c478bd9Sstevel@tonic-gate 
29777c478bd9Sstevel@tonic-gate 	getret = tcgetattr(fd, &old_syscon_termios);
29787c478bd9Sstevel@tonic-gate 	old_syscon_termios.c_cflag &= ~HUPCL;
29797c478bd9Sstevel@tonic-gate 	if (realcon())
29807c478bd9Sstevel@tonic-gate 		/* Don't overwrite cflag of real console. */
29817c478bd9Sstevel@tonic-gate 		stored_syscon_termios.c_cflag = old_syscon_termios.c_cflag;
29827c478bd9Sstevel@tonic-gate 
29837c478bd9Sstevel@tonic-gate 	stored_syscon_termios.c_cflag &= ~HUPCL;
29847c478bd9Sstevel@tonic-gate 
29857c478bd9Sstevel@tonic-gate 	(void) tcsetattr(fd, TCSANOW, &stored_syscon_termios);
29867c478bd9Sstevel@tonic-gate 
29877c478bd9Sstevel@tonic-gate 	if (prefix)
29887c478bd9Sstevel@tonic-gate 		(void) fprintf(f, "\nINIT: ");
29897c478bd9Sstevel@tonic-gate 	va_start(args, format);
29907c478bd9Sstevel@tonic-gate 	(void) vfprintf(f, format, args);
29917c478bd9Sstevel@tonic-gate 	va_end(args);
29927c478bd9Sstevel@tonic-gate 
29937c478bd9Sstevel@tonic-gate 	if (getret == 0)
29947c478bd9Sstevel@tonic-gate 		(void) tcsetattr(fd, TCSADRAIN, &old_syscon_termios);
29957c478bd9Sstevel@tonic-gate 
29967c478bd9Sstevel@tonic-gate 	(void) fclose(f);
29977c478bd9Sstevel@tonic-gate }
29987c478bd9Sstevel@tonic-gate 
29997c478bd9Sstevel@tonic-gate /*
30007c478bd9Sstevel@tonic-gate  * timer() is a substitute for sleep() which uses alarm() and pause().
30017c478bd9Sstevel@tonic-gate  */
30027c478bd9Sstevel@tonic-gate static void
30037c478bd9Sstevel@tonic-gate timer(int waitime)
30047c478bd9Sstevel@tonic-gate {
30057c478bd9Sstevel@tonic-gate 	setimer(waitime);
30067c478bd9Sstevel@tonic-gate 	while (time_up == FALSE)
30077c478bd9Sstevel@tonic-gate 		(void) pause();
30087c478bd9Sstevel@tonic-gate }
30097c478bd9Sstevel@tonic-gate 
30107c478bd9Sstevel@tonic-gate static void
30117c478bd9Sstevel@tonic-gate setimer(int timelimit)
30127c478bd9Sstevel@tonic-gate {
30137c478bd9Sstevel@tonic-gate 	alarmclk();
30147c478bd9Sstevel@tonic-gate 	(void) alarm(timelimit);
30157c478bd9Sstevel@tonic-gate 	time_up = (timelimit ? FALSE : TRUE);
30167c478bd9Sstevel@tonic-gate }
30177c478bd9Sstevel@tonic-gate 
30187c478bd9Sstevel@tonic-gate /*
30197c478bd9Sstevel@tonic-gate  * Fails with
30207c478bd9Sstevel@tonic-gate  *   ENOMEM - out of memory
30217c478bd9Sstevel@tonic-gate  *   ECONNABORTED - repository connection broken
30227c478bd9Sstevel@tonic-gate  *   EPERM - permission denied
30237c478bd9Sstevel@tonic-gate  *   EACCES - backend access denied
30247c478bd9Sstevel@tonic-gate  *   EROFS - backend readonly
30257c478bd9Sstevel@tonic-gate  */
30267c478bd9Sstevel@tonic-gate static int
30277c478bd9Sstevel@tonic-gate get_or_add_startd(scf_instance_t *inst)
30287c478bd9Sstevel@tonic-gate {
30297c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
30307c478bd9Sstevel@tonic-gate 	scf_scope_t *scope = NULL;
30317c478bd9Sstevel@tonic-gate 	scf_service_t *svc = NULL;
30327c478bd9Sstevel@tonic-gate 	int ret = 0;
30337c478bd9Sstevel@tonic-gate 
30347c478bd9Sstevel@tonic-gate 	h = scf_instance_handle(inst);
30357c478bd9Sstevel@tonic-gate 
30367c478bd9Sstevel@tonic-gate 	if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, inst,
30377c478bd9Sstevel@tonic-gate 	    NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0)
30387c478bd9Sstevel@tonic-gate 		return (0);
30397c478bd9Sstevel@tonic-gate 
30407c478bd9Sstevel@tonic-gate 	switch (scf_error()) {
30417c478bd9Sstevel@tonic-gate 	case SCF_ERROR_CONNECTION_BROKEN:
30427c478bd9Sstevel@tonic-gate 		return (ECONNABORTED);
30437c478bd9Sstevel@tonic-gate 
30447c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_FOUND:
30457c478bd9Sstevel@tonic-gate 		break;
30467c478bd9Sstevel@tonic-gate 
30477c478bd9Sstevel@tonic-gate 	case SCF_ERROR_HANDLE_MISMATCH:
30487c478bd9Sstevel@tonic-gate 	case SCF_ERROR_INVALID_ARGUMENT:
30497c478bd9Sstevel@tonic-gate 	case SCF_ERROR_CONSTRAINT_VIOLATED:
30507c478bd9Sstevel@tonic-gate 	default:
30517c478bd9Sstevel@tonic-gate 		bad_error("scf_handle_decode_fmri", scf_error());
30527c478bd9Sstevel@tonic-gate 	}
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 	/* Make sure we're right, since we're adding piece-by-piece. */
30557c478bd9Sstevel@tonic-gate 	assert(strcmp(SCF_SERVICE_STARTD,
30567c478bd9Sstevel@tonic-gate 	    "svc:/system/svc/restarter:default") == 0);
30577c478bd9Sstevel@tonic-gate 
30587c478bd9Sstevel@tonic-gate 	if ((scope = scf_scope_create(h)) == NULL ||
30597c478bd9Sstevel@tonic-gate 	    (svc = scf_service_create(h)) == NULL) {
30607c478bd9Sstevel@tonic-gate 		ret = ENOMEM;
30617c478bd9Sstevel@tonic-gate 		goto out;
30627c478bd9Sstevel@tonic-gate 	}
30637c478bd9Sstevel@tonic-gate 
30647c478bd9Sstevel@tonic-gate get_scope:
30657c478bd9Sstevel@tonic-gate 	if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, scope) != 0) {
30667c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
30677c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
30687c478bd9Sstevel@tonic-gate 			ret = ECONNABORTED;
30697c478bd9Sstevel@tonic-gate 			goto out;
30707c478bd9Sstevel@tonic-gate 
30717c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
30727c478bd9Sstevel@tonic-gate 			(void) fputs(gettext(
30737c478bd9Sstevel@tonic-gate 			    "smf(5) repository missing local scope.\n"),
30747c478bd9Sstevel@tonic-gate 			    stderr);
30757c478bd9Sstevel@tonic-gate 			exit(1);
30767c478bd9Sstevel@tonic-gate 			/* NOTREACHED */
30777c478bd9Sstevel@tonic-gate 
30787c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
30797c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
30807c478bd9Sstevel@tonic-gate 		default:
30817c478bd9Sstevel@tonic-gate 			bad_error("scf_handle_get_scope", scf_error());
30827c478bd9Sstevel@tonic-gate 		}
30837c478bd9Sstevel@tonic-gate 	}
30847c478bd9Sstevel@tonic-gate 
30857c478bd9Sstevel@tonic-gate get_svc:
30867c478bd9Sstevel@tonic-gate 	if (scf_scope_get_service(scope, "system/svc/restarter", svc) != 0) {
30877c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
30887c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
30897c478bd9Sstevel@tonic-gate 			ret = ECONNABORTED;
30907c478bd9Sstevel@tonic-gate 			goto out;
30917c478bd9Sstevel@tonic-gate 
30927c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
30937c478bd9Sstevel@tonic-gate 			goto get_scope;
30947c478bd9Sstevel@tonic-gate 
30957c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
30967c478bd9Sstevel@tonic-gate 			break;
30977c478bd9Sstevel@tonic-gate 
30987c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
30997c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
31007c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
31017c478bd9Sstevel@tonic-gate 		default:
31027c478bd9Sstevel@tonic-gate 			bad_error("scf_scope_get_service", scf_error());
31037c478bd9Sstevel@tonic-gate 		}
31047c478bd9Sstevel@tonic-gate 
31057c478bd9Sstevel@tonic-gate add_svc:
31067c478bd9Sstevel@tonic-gate 		if (scf_scope_add_service(scope, "system/svc/restarter", svc) !=
31077c478bd9Sstevel@tonic-gate 		    0) {
31087c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
31097c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
31107c478bd9Sstevel@tonic-gate 				ret = ECONNABORTED;
31117c478bd9Sstevel@tonic-gate 				goto out;
31127c478bd9Sstevel@tonic-gate 
31137c478bd9Sstevel@tonic-gate 			case SCF_ERROR_EXISTS:
31147c478bd9Sstevel@tonic-gate 				goto get_svc;
31157c478bd9Sstevel@tonic-gate 
31167c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
31177c478bd9Sstevel@tonic-gate 				ret = EPERM;
31187c478bd9Sstevel@tonic-gate 				goto out;
31197c478bd9Sstevel@tonic-gate 
31207c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
31217c478bd9Sstevel@tonic-gate 				ret = EACCES;
31227c478bd9Sstevel@tonic-gate 				goto out;
31237c478bd9Sstevel@tonic-gate 
31247c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
31257c478bd9Sstevel@tonic-gate 				ret = EROFS;
31267c478bd9Sstevel@tonic-gate 				goto out;
31277c478bd9Sstevel@tonic-gate 
31287c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
31297c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
31307c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
31317c478bd9Sstevel@tonic-gate 			default:
31327c478bd9Sstevel@tonic-gate 				bad_error("scf_scope_add_service", scf_error());
31337c478bd9Sstevel@tonic-gate 			}
31347c478bd9Sstevel@tonic-gate 		}
31357c478bd9Sstevel@tonic-gate 	}
31367c478bd9Sstevel@tonic-gate 
31377c478bd9Sstevel@tonic-gate get_inst:
31387c478bd9Sstevel@tonic-gate 	if (scf_service_get_instance(svc, "default", inst) != 0) {
31397c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
31407c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
31417c478bd9Sstevel@tonic-gate 			ret = ECONNABORTED;
31427c478bd9Sstevel@tonic-gate 			goto out;
31437c478bd9Sstevel@tonic-gate 
31447c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
31457c478bd9Sstevel@tonic-gate 			goto add_svc;
31467c478bd9Sstevel@tonic-gate 
31477c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
31487c478bd9Sstevel@tonic-gate 			break;
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
31517c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
31527c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
31537c478bd9Sstevel@tonic-gate 		default:
31547c478bd9Sstevel@tonic-gate 			bad_error("scf_service_get_instance", scf_error());
31557c478bd9Sstevel@tonic-gate 		}
31567c478bd9Sstevel@tonic-gate 
31577c478bd9Sstevel@tonic-gate 		if (scf_service_add_instance(svc, "default", inst) !=
31587c478bd9Sstevel@tonic-gate 		    0) {
31597c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
31607c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
31617c478bd9Sstevel@tonic-gate 				ret = ECONNABORTED;
31627c478bd9Sstevel@tonic-gate 				goto out;
31637c478bd9Sstevel@tonic-gate 
31647c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
31657c478bd9Sstevel@tonic-gate 				goto add_svc;
31667c478bd9Sstevel@tonic-gate 
31677c478bd9Sstevel@tonic-gate 			case SCF_ERROR_EXISTS:
31687c478bd9Sstevel@tonic-gate 				goto get_inst;
31697c478bd9Sstevel@tonic-gate 
31707c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
31717c478bd9Sstevel@tonic-gate 				ret = EPERM;
31727c478bd9Sstevel@tonic-gate 				goto out;
31737c478bd9Sstevel@tonic-gate 
31747c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
31757c478bd9Sstevel@tonic-gate 				ret = EACCES;
31767c478bd9Sstevel@tonic-gate 				goto out;
31777c478bd9Sstevel@tonic-gate 
31787c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
31797c478bd9Sstevel@tonic-gate 				ret = EROFS;
31807c478bd9Sstevel@tonic-gate 				goto out;
31817c478bd9Sstevel@tonic-gate 
31827c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
31837c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
31847c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
31857c478bd9Sstevel@tonic-gate 			default:
31867c478bd9Sstevel@tonic-gate 				bad_error("scf_service_add_instance",
31877c478bd9Sstevel@tonic-gate 				    scf_error());
31887c478bd9Sstevel@tonic-gate 			}
31897c478bd9Sstevel@tonic-gate 		}
31907c478bd9Sstevel@tonic-gate 	}
31917c478bd9Sstevel@tonic-gate 
31927c478bd9Sstevel@tonic-gate 	ret = 0;
31937c478bd9Sstevel@tonic-gate 
31947c478bd9Sstevel@tonic-gate out:
31957c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
31967c478bd9Sstevel@tonic-gate 	scf_scope_destroy(scope);
31977c478bd9Sstevel@tonic-gate 	return (ret);
31987c478bd9Sstevel@tonic-gate }
31997c478bd9Sstevel@tonic-gate 
32007c478bd9Sstevel@tonic-gate /*
32017c478bd9Sstevel@tonic-gate  * Fails with
32027c478bd9Sstevel@tonic-gate  *   ECONNABORTED - repository connection broken
32037c478bd9Sstevel@tonic-gate  *   ECANCELED - the transaction's property group was deleted
32047c478bd9Sstevel@tonic-gate  */
32057c478bd9Sstevel@tonic-gate static int
32067c478bd9Sstevel@tonic-gate transaction_add_set(scf_transaction_t *tx, scf_transaction_entry_t *ent,
32077c478bd9Sstevel@tonic-gate     const char *pname, scf_type_t type)
32087c478bd9Sstevel@tonic-gate {
32097c478bd9Sstevel@tonic-gate change_type:
32107c478bd9Sstevel@tonic-gate 	if (scf_transaction_property_change_type(tx, ent, pname, type) == 0)
32117c478bd9Sstevel@tonic-gate 		return (0);
32127c478bd9Sstevel@tonic-gate 
32137c478bd9Sstevel@tonic-gate 	switch (scf_error()) {
32147c478bd9Sstevel@tonic-gate 	case SCF_ERROR_CONNECTION_BROKEN:
32157c478bd9Sstevel@tonic-gate 		return (ECONNABORTED);
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 	case SCF_ERROR_DELETED:
32187c478bd9Sstevel@tonic-gate 		return (ECANCELED);
32197c478bd9Sstevel@tonic-gate 
32207c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_FOUND:
32217c478bd9Sstevel@tonic-gate 		goto new;
32227c478bd9Sstevel@tonic-gate 
32237c478bd9Sstevel@tonic-gate 	case SCF_ERROR_HANDLE_MISMATCH:
32247c478bd9Sstevel@tonic-gate 	case SCF_ERROR_INVALID_ARGUMENT:
32257c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_BOUND:
32267c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_SET:
32277c478bd9Sstevel@tonic-gate 	default:
32287c478bd9Sstevel@tonic-gate 		bad_error("scf_transaction_property_change_type", scf_error());
32297c478bd9Sstevel@tonic-gate 	}
32307c478bd9Sstevel@tonic-gate 
32317c478bd9Sstevel@tonic-gate new:
32327c478bd9Sstevel@tonic-gate 	if (scf_transaction_property_new(tx, ent, pname, type) == 0)
32337c478bd9Sstevel@tonic-gate 		return (0);
32347c478bd9Sstevel@tonic-gate 
32357c478bd9Sstevel@tonic-gate 	switch (scf_error()) {
32367c478bd9Sstevel@tonic-gate 	case SCF_ERROR_CONNECTION_BROKEN:
32377c478bd9Sstevel@tonic-gate 		return (ECONNABORTED);
32387c478bd9Sstevel@tonic-gate 
32397c478bd9Sstevel@tonic-gate 	case SCF_ERROR_DELETED:
32407c478bd9Sstevel@tonic-gate 		return (ECANCELED);
32417c478bd9Sstevel@tonic-gate 
32427c478bd9Sstevel@tonic-gate 	case SCF_ERROR_EXISTS:
32437c478bd9Sstevel@tonic-gate 		goto change_type;
32447c478bd9Sstevel@tonic-gate 
32457c478bd9Sstevel@tonic-gate 	case SCF_ERROR_HANDLE_MISMATCH:
32467c478bd9Sstevel@tonic-gate 	case SCF_ERROR_INVALID_ARGUMENT:
32477c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_BOUND:
32487c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_SET:
32497c478bd9Sstevel@tonic-gate 	default:
32507c478bd9Sstevel@tonic-gate 		bad_error("scf_transaction_property_new", scf_error());
32517c478bd9Sstevel@tonic-gate 		/* NOTREACHED */
32527c478bd9Sstevel@tonic-gate 	}
32537c478bd9Sstevel@tonic-gate }
32547c478bd9Sstevel@tonic-gate 
32557c478bd9Sstevel@tonic-gate static void
32567c478bd9Sstevel@tonic-gate scferr(void)
32577c478bd9Sstevel@tonic-gate {
32587c478bd9Sstevel@tonic-gate 	switch (scf_error()) {
32597c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NO_MEMORY:
32607c478bd9Sstevel@tonic-gate 		console(B_TRUE, gettext("Out of memory.\n"));
32617c478bd9Sstevel@tonic-gate 		break;
32627c478bd9Sstevel@tonic-gate 
32637c478bd9Sstevel@tonic-gate 	case SCF_ERROR_CONNECTION_BROKEN:
32647c478bd9Sstevel@tonic-gate 		console(B_TRUE, gettext(
32657c478bd9Sstevel@tonic-gate 		    "Connection to smf(5) repository server broken.\n"));
32667c478bd9Sstevel@tonic-gate 		break;
32677c478bd9Sstevel@tonic-gate 
32687c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NO_RESOURCES:
32697c478bd9Sstevel@tonic-gate 		console(B_TRUE, gettext(
32707c478bd9Sstevel@tonic-gate 		    "smf(5) repository server is out of memory.\n"));
32717c478bd9Sstevel@tonic-gate 		break;
32727c478bd9Sstevel@tonic-gate 
32737c478bd9Sstevel@tonic-gate 	case SCF_ERROR_PERMISSION_DENIED:
32747c478bd9Sstevel@tonic-gate 		console(B_TRUE, gettext("Insufficient privileges.\n"));
32757c478bd9Sstevel@tonic-gate 		break;
32767c478bd9Sstevel@tonic-gate 
32777c478bd9Sstevel@tonic-gate 	default:
32787c478bd9Sstevel@tonic-gate 		console(B_TRUE, gettext("libscf error: %s\n"),
32797c478bd9Sstevel@tonic-gate 		    scf_strerror(scf_error()));
32807c478bd9Sstevel@tonic-gate 	}
32817c478bd9Sstevel@tonic-gate }
32827c478bd9Sstevel@tonic-gate 
32837c478bd9Sstevel@tonic-gate static void
32847c478bd9Sstevel@tonic-gate lscf_set_runlevel(char rl)
32857c478bd9Sstevel@tonic-gate {
32867c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
32877c478bd9Sstevel@tonic-gate 	scf_instance_t *inst = NULL;
32887c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *pg = NULL;
32897c478bd9Sstevel@tonic-gate 	scf_transaction_t *tx = NULL;
32907c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *ent = NULL;
32917c478bd9Sstevel@tonic-gate 	scf_value_t *val = NULL;
32927c478bd9Sstevel@tonic-gate 	char buf[2];
32937c478bd9Sstevel@tonic-gate 	int r;
32947c478bd9Sstevel@tonic-gate 
32957c478bd9Sstevel@tonic-gate 	h = scf_handle_create(SCF_VERSION);
32967c478bd9Sstevel@tonic-gate 	if (h == NULL) {
32977c478bd9Sstevel@tonic-gate 		scferr();
32987c478bd9Sstevel@tonic-gate 		return;
32997c478bd9Sstevel@tonic-gate 	}
33007c478bd9Sstevel@tonic-gate 
33017c478bd9Sstevel@tonic-gate 	if (scf_handle_bind(h) != 0) {
33027c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
33037c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NO_SERVER:
33047c478bd9Sstevel@tonic-gate 			console(B_TRUE,
33057c478bd9Sstevel@tonic-gate 			    gettext("smf(5) repository server not running.\n"));
33067c478bd9Sstevel@tonic-gate 			goto bail;
33077c478bd9Sstevel@tonic-gate 
33087c478bd9Sstevel@tonic-gate 		default:
33097c478bd9Sstevel@tonic-gate 			scferr();
33107c478bd9Sstevel@tonic-gate 			goto bail;
33117c478bd9Sstevel@tonic-gate 		}
33127c478bd9Sstevel@tonic-gate 	}
33137c478bd9Sstevel@tonic-gate 
33147c478bd9Sstevel@tonic-gate 	if ((inst = scf_instance_create(h)) == NULL ||
33157c478bd9Sstevel@tonic-gate 	    (pg = scf_pg_create(h)) == NULL ||
33167c478bd9Sstevel@tonic-gate 	    (val = scf_value_create(h)) == NULL ||
33177c478bd9Sstevel@tonic-gate 	    (tx = scf_transaction_create(h)) == NULL ||
33187c478bd9Sstevel@tonic-gate 	    (ent = scf_entry_create(h)) == NULL) {
33197c478bd9Sstevel@tonic-gate 		scferr();
33207c478bd9Sstevel@tonic-gate 		goto bail;
33217c478bd9Sstevel@tonic-gate 	}
33227c478bd9Sstevel@tonic-gate 
33237c478bd9Sstevel@tonic-gate get_inst:
33247c478bd9Sstevel@tonic-gate 	r = get_or_add_startd(inst);
33257c478bd9Sstevel@tonic-gate 	switch (r) {
33267c478bd9Sstevel@tonic-gate 	case 0:
33277c478bd9Sstevel@tonic-gate 		break;
33287c478bd9Sstevel@tonic-gate 
33297c478bd9Sstevel@tonic-gate 	case ENOMEM:
33307c478bd9Sstevel@tonic-gate 	case ECONNABORTED:
33317c478bd9Sstevel@tonic-gate 	case EPERM:
33327c478bd9Sstevel@tonic-gate 	case EACCES:
33337c478bd9Sstevel@tonic-gate 	case EROFS:
33347c478bd9Sstevel@tonic-gate 		scferr();
33357c478bd9Sstevel@tonic-gate 		goto bail;
33367c478bd9Sstevel@tonic-gate 	default:
33377c478bd9Sstevel@tonic-gate 		bad_error("get_or_add_startd", r);
33387c478bd9Sstevel@tonic-gate 	}
33397c478bd9Sstevel@tonic-gate 
33407c478bd9Sstevel@tonic-gate get_pg:
33417c478bd9Sstevel@tonic-gate 	if (scf_instance_get_pg(inst, SCF_PG_OPTIONS_OVR, pg) != 0) {
33427c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
33437c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
33447c478bd9Sstevel@tonic-gate 			scferr();
33457c478bd9Sstevel@tonic-gate 			goto bail;
33467c478bd9Sstevel@tonic-gate 
33477c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
33487c478bd9Sstevel@tonic-gate 			goto get_inst;
33497c478bd9Sstevel@tonic-gate 
33507c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
33517c478bd9Sstevel@tonic-gate 			break;
33527c478bd9Sstevel@tonic-gate 
33537c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
33547c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
33557c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
33567c478bd9Sstevel@tonic-gate 		default:
33577c478bd9Sstevel@tonic-gate 			bad_error("scf_instance_get_pg", scf_error());
33587c478bd9Sstevel@tonic-gate 		}
33597c478bd9Sstevel@tonic-gate 
33607c478bd9Sstevel@tonic-gate add_pg:
33617c478bd9Sstevel@tonic-gate 		if (scf_instance_add_pg(inst, SCF_PG_OPTIONS_OVR,
33627c478bd9Sstevel@tonic-gate 		    SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS, pg) !=
33637c478bd9Sstevel@tonic-gate 		    0) {
33647c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
33657c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
33667c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
33677c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
33687c478bd9Sstevel@tonic-gate 				scferr();
33697c478bd9Sstevel@tonic-gate 				goto bail;
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
33727c478bd9Sstevel@tonic-gate 				goto get_inst;
33737c478bd9Sstevel@tonic-gate 
33747c478bd9Sstevel@tonic-gate 			case SCF_ERROR_EXISTS:
33757c478bd9Sstevel@tonic-gate 				goto get_pg;
33767c478bd9Sstevel@tonic-gate 
33777c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
33787c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
33797c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
33807c478bd9Sstevel@tonic-gate 			default:
33817c478bd9Sstevel@tonic-gate 				bad_error("scf_instance_add_pg", scf_error());
33827c478bd9Sstevel@tonic-gate 			}
33837c478bd9Sstevel@tonic-gate 		}
33847c478bd9Sstevel@tonic-gate 	}
33857c478bd9Sstevel@tonic-gate 
33867c478bd9Sstevel@tonic-gate 	buf[0] = rl;
33877c478bd9Sstevel@tonic-gate 	buf[1] = '\0';
33887c478bd9Sstevel@tonic-gate 	r = scf_value_set_astring(val, buf);
33897c478bd9Sstevel@tonic-gate 	assert(r == 0);
33907c478bd9Sstevel@tonic-gate 
33917c478bd9Sstevel@tonic-gate 	for (;;) {
33927c478bd9Sstevel@tonic-gate 		if (scf_transaction_start(tx, pg) != 0) {
33937c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
33947c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
33957c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
33967c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
33977c478bd9Sstevel@tonic-gate 				scferr();
33987c478bd9Sstevel@tonic-gate 				goto bail;
33997c478bd9Sstevel@tonic-gate 
34007c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
34017c478bd9Sstevel@tonic-gate 				goto add_pg;
34027c478bd9Sstevel@tonic-gate 
34037c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
34047c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
34057c478bd9Sstevel@tonic-gate 			case SCF_ERROR_IN_USE:
34067c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
34077c478bd9Sstevel@tonic-gate 			default:
34087c478bd9Sstevel@tonic-gate 				bad_error("scf_transaction_start", scf_error());
34097c478bd9Sstevel@tonic-gate 			}
34107c478bd9Sstevel@tonic-gate 		}
34117c478bd9Sstevel@tonic-gate 
34127c478bd9Sstevel@tonic-gate 		r = transaction_add_set(tx, ent, "runlevel", SCF_TYPE_ASTRING);
34137c478bd9Sstevel@tonic-gate 		switch (r) {
34147c478bd9Sstevel@tonic-gate 		case 0:
34157c478bd9Sstevel@tonic-gate 			break;
34167c478bd9Sstevel@tonic-gate 
34177c478bd9Sstevel@tonic-gate 		case ECONNABORTED:
34187c478bd9Sstevel@tonic-gate 			scferr();
34197c478bd9Sstevel@tonic-gate 			goto bail;
34207c478bd9Sstevel@tonic-gate 
34217c478bd9Sstevel@tonic-gate 		case ECANCELED:
34227c478bd9Sstevel@tonic-gate 			scf_transaction_reset(tx);
34237c478bd9Sstevel@tonic-gate 			goto add_pg;
34247c478bd9Sstevel@tonic-gate 
34257c478bd9Sstevel@tonic-gate 		default:
34267c478bd9Sstevel@tonic-gate 			bad_error("transaction_add_set", r);
34277c478bd9Sstevel@tonic-gate 		}
34287c478bd9Sstevel@tonic-gate 
34297c478bd9Sstevel@tonic-gate 		r = scf_entry_add_value(ent, val);
34307c478bd9Sstevel@tonic-gate 		assert(r == 0);
34317c478bd9Sstevel@tonic-gate 
34327c478bd9Sstevel@tonic-gate 		r = scf_transaction_commit(tx);
34337c478bd9Sstevel@tonic-gate 		if (r == 1)
34347c478bd9Sstevel@tonic-gate 			break;
34357c478bd9Sstevel@tonic-gate 
34367c478bd9Sstevel@tonic-gate 		if (r != 0) {
34377c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
34387c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
34397c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
34407c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
34417c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
34427c478bd9Sstevel@tonic-gate 				scferr();
34437c478bd9Sstevel@tonic-gate 				goto bail;
34447c478bd9Sstevel@tonic-gate 
34457c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
34467c478bd9Sstevel@tonic-gate 				scf_transaction_reset(tx);
34477c478bd9Sstevel@tonic-gate 				goto add_pg;
34487c478bd9Sstevel@tonic-gate 
34497c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
34507c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
34517c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
34527c478bd9Sstevel@tonic-gate 			default:
34537c478bd9Sstevel@tonic-gate 				bad_error("scf_transaction_commit",
34547c478bd9Sstevel@tonic-gate 				    scf_error());
34557c478bd9Sstevel@tonic-gate 			}
34567c478bd9Sstevel@tonic-gate 		}
34577c478bd9Sstevel@tonic-gate 
34587c478bd9Sstevel@tonic-gate 		scf_transaction_reset(tx);
34597c478bd9Sstevel@tonic-gate 		(void) scf_pg_update(pg);
34607c478bd9Sstevel@tonic-gate 	}
34617c478bd9Sstevel@tonic-gate 
34627c478bd9Sstevel@tonic-gate bail:
34637c478bd9Sstevel@tonic-gate 	scf_transaction_destroy(tx);
34647c478bd9Sstevel@tonic-gate 	scf_entry_destroy(ent);
34657c478bd9Sstevel@tonic-gate 	scf_value_destroy(val);
34667c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
34677c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
34687c478bd9Sstevel@tonic-gate 
34697c478bd9Sstevel@tonic-gate 	(void) scf_handle_unbind(h);
34707c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
34717c478bd9Sstevel@tonic-gate }
34727c478bd9Sstevel@tonic-gate 
34737c478bd9Sstevel@tonic-gate /*
34747c478bd9Sstevel@tonic-gate  * Function to handle requests from users to main init running as process 1.
34757c478bd9Sstevel@tonic-gate  */
34767c478bd9Sstevel@tonic-gate static void
34777c478bd9Sstevel@tonic-gate userinit(int argc, char **argv)
34787c478bd9Sstevel@tonic-gate {
34797c478bd9Sstevel@tonic-gate 	FILE	*fp;
34807c478bd9Sstevel@tonic-gate 	char	*ln;
34817c478bd9Sstevel@tonic-gate 	int	init_signal;
34827c478bd9Sstevel@tonic-gate 	struct stat	sconbuf, conbuf;
34837c478bd9Sstevel@tonic-gate 	const char *usage_msg = "Usage: init [0123456SsQqabc]\n";
34847c478bd9Sstevel@tonic-gate 
34857c478bd9Sstevel@tonic-gate 	/*
34867c478bd9Sstevel@tonic-gate 	 * We are a user invoked init.  Is there an argument and is it
34877c478bd9Sstevel@tonic-gate 	 * a single character?  If not, print usage message and quit.
34887c478bd9Sstevel@tonic-gate 	 */
34897c478bd9Sstevel@tonic-gate 	if (argc != 2 || argv[1][1] != '\0') {
34907c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, usage_msg);
34917c478bd9Sstevel@tonic-gate 		exit(0);
34927c478bd9Sstevel@tonic-gate 	}
34937c478bd9Sstevel@tonic-gate 
34947c478bd9Sstevel@tonic-gate 	if ((init_signal = lvlname_to_state((char)argv[1][0])) == -1) {
34957c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, usage_msg);
34967c478bd9Sstevel@tonic-gate 		(void) audit_put_record(ADT_FAILURE, ADT_FAIL_VALUE_BAD_CMD,
34977c478bd9Sstevel@tonic-gate 		    argv[1]);
34987c478bd9Sstevel@tonic-gate 		exit(1);
34997c478bd9Sstevel@tonic-gate 	}
35007c478bd9Sstevel@tonic-gate 
35017c478bd9Sstevel@tonic-gate 	if (init_signal == SINGLE_USER) {
35027c478bd9Sstevel@tonic-gate 		/*
35037c478bd9Sstevel@tonic-gate 		 * Make sure this process is talking to a legal tty line
35047c478bd9Sstevel@tonic-gate 		 * and that /dev/syscon is linked to this line.
35057c478bd9Sstevel@tonic-gate 		 */
35067c478bd9Sstevel@tonic-gate 		ln = ttyname(0);	/* Get the name of tty */
35077c478bd9Sstevel@tonic-gate 		if (ln == NULL) {
35087c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
35097c478bd9Sstevel@tonic-gate 			    "Standard input not a tty line\n");
35107c478bd9Sstevel@tonic-gate 			(void) audit_put_record(ADT_FAILURE,
35117c478bd9Sstevel@tonic-gate 			    ADT_FAIL_VALUE_BAD_TTY, argv[1]);
35127c478bd9Sstevel@tonic-gate 			exit(1);
35137c478bd9Sstevel@tonic-gate 		}
3514c2a7bee5Svikram 
3515c2a7bee5Svikram 		if ((stat(ln, &sconbuf) != -1) &&
3516c2a7bee5Svikram 		    (stat(SYSCON, &conbuf) == -1 ||
3517c2a7bee5Svikram 		    sconbuf.st_rdev != conbuf.st_rdev)) {
35187c478bd9Sstevel@tonic-gate 			/*
3519c2a7bee5Svikram 			 * /dev/syscon needs to change.
35207c478bd9Sstevel@tonic-gate 			 * Unlink /dev/syscon and relink it to the current line.
35217c478bd9Sstevel@tonic-gate 			 */
3522c2a7bee5Svikram 			if (lstat(SYSCON, &conbuf) != -1 &&
3523c2a7bee5Svikram 			    unlink(SYSCON) == FAILURE) {
35247c478bd9Sstevel@tonic-gate 				perror("Can't unlink /dev/syscon");
35257c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
35267c478bd9Sstevel@tonic-gate 				    "Run command on the system console.\n");
35277c478bd9Sstevel@tonic-gate 				(void) audit_put_record(ADT_FAILURE,
35287c478bd9Sstevel@tonic-gate 				    ADT_FAIL_VALUE_PROGRAM, argv[1]);
35297c478bd9Sstevel@tonic-gate 				exit(1);
35307c478bd9Sstevel@tonic-gate 			}
3531c2a7bee5Svikram 			if (symlink(ln, SYSCON) == FAILURE) {
35327c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
3533c2a7bee5Svikram 				    "Can't symlink /dev/syscon to %s: %s", ln,
35347c478bd9Sstevel@tonic-gate 				    strerror(errno));
35357c478bd9Sstevel@tonic-gate 
35367c478bd9Sstevel@tonic-gate 				/* Try to leave a syscon */
35377c478bd9Sstevel@tonic-gate 				(void) link(SYSTTY, SYSCON);
35387c478bd9Sstevel@tonic-gate 				(void) audit_put_record(ADT_FAILURE,
35397c478bd9Sstevel@tonic-gate 				    ADT_FAIL_VALUE_PROGRAM, argv[1]);
35407c478bd9Sstevel@tonic-gate 				exit(1);
35417c478bd9Sstevel@tonic-gate 			}
35427c478bd9Sstevel@tonic-gate 
35437c478bd9Sstevel@tonic-gate 			/*
35447c478bd9Sstevel@tonic-gate 			 * Try to leave a message on system console saying where
35457c478bd9Sstevel@tonic-gate 			 * /dev/syscon is currently connected.
35467c478bd9Sstevel@tonic-gate 			 */
35477c478bd9Sstevel@tonic-gate 			if ((fp = fopen(SYSTTY, "r+")) != NULL) {
35487c478bd9Sstevel@tonic-gate 				(void) fprintf(fp,
35497c478bd9Sstevel@tonic-gate 				    "\n****	SYSCON CHANGED TO %s	****\n",
35507c478bd9Sstevel@tonic-gate 				    ln);
35517c478bd9Sstevel@tonic-gate 				(void) fclose(fp);
35527c478bd9Sstevel@tonic-gate 			}
35537c478bd9Sstevel@tonic-gate 		}
35547c478bd9Sstevel@tonic-gate 	}
35557c478bd9Sstevel@tonic-gate 
35567c478bd9Sstevel@tonic-gate 	update_boot_archive(init_signal);
35577c478bd9Sstevel@tonic-gate 
35586d59ee37Spaulson 	(void) audit_put_record(ADT_SUCCESS, ADT_SUCCESS, argv[1]);
35597c478bd9Sstevel@tonic-gate 
35607c478bd9Sstevel@tonic-gate 	/*
35617c478bd9Sstevel@tonic-gate 	 * Signal init; init will take care of telling svc.startd.
35627c478bd9Sstevel@tonic-gate 	 */
35637c478bd9Sstevel@tonic-gate 	if (kill(init_pid, init_signal) == FAILURE) {
35647c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, "Must be super-user\n");
35657c478bd9Sstevel@tonic-gate 		(void) audit_put_record(ADT_FAILURE,
35667c478bd9Sstevel@tonic-gate 		    ADT_FAIL_VALUE_AUTH, argv[1]);
35677c478bd9Sstevel@tonic-gate 		exit(1);
35687c478bd9Sstevel@tonic-gate 	}
35697c478bd9Sstevel@tonic-gate 
35707c478bd9Sstevel@tonic-gate 	exit(0);
35717c478bd9Sstevel@tonic-gate }
35727c478bd9Sstevel@tonic-gate 
35737c478bd9Sstevel@tonic-gate 
35747c478bd9Sstevel@tonic-gate #define	DELTA	25	/* Number of pidlist elements to allocate at a time */
35757c478bd9Sstevel@tonic-gate 
35767c478bd9Sstevel@tonic-gate /* ARGSUSED */
35777c478bd9Sstevel@tonic-gate void
35787c478bd9Sstevel@tonic-gate sigpoll(int n)
35797c478bd9Sstevel@tonic-gate {
35807c478bd9Sstevel@tonic-gate 	struct pidrec prec;
35817c478bd9Sstevel@tonic-gate 	struct pidrec *p = &prec;
35827c478bd9Sstevel@tonic-gate 	struct pidlist *plp;
35837c478bd9Sstevel@tonic-gate 	struct pidlist *tp, *savetp;
35847c478bd9Sstevel@tonic-gate 	int i;
35857c478bd9Sstevel@tonic-gate 
35867c478bd9Sstevel@tonic-gate 	if (Pfd < 0) {
35877c478bd9Sstevel@tonic-gate 		return;
35887c478bd9Sstevel@tonic-gate 	}
3589dd965b2fSnakanon 
35907c478bd9Sstevel@tonic-gate 	for (;;) {
35917c478bd9Sstevel@tonic-gate 		/*
35927c478bd9Sstevel@tonic-gate 		 * Important Note: Either read will really fail (in which case
35937c478bd9Sstevel@tonic-gate 		 * return is all we can do) or will get EAGAIN (Pfd was opened
35947c478bd9Sstevel@tonic-gate 		 * O_NDELAY), in which case we also want to return.
35957c478bd9Sstevel@tonic-gate 		 * Always return from here!
35967c478bd9Sstevel@tonic-gate 		 */
35977c478bd9Sstevel@tonic-gate 		if (read(Pfd, p, sizeof (struct pidrec)) !=
35987c478bd9Sstevel@tonic-gate 						sizeof (struct pidrec)) {
35997c478bd9Sstevel@tonic-gate 			return;
36007c478bd9Sstevel@tonic-gate 		}
36017c478bd9Sstevel@tonic-gate 		switch (p->pd_type) {
36027c478bd9Sstevel@tonic-gate 
36037c478bd9Sstevel@tonic-gate 		case ADDPID:
36047c478bd9Sstevel@tonic-gate 			/*
36057c478bd9Sstevel@tonic-gate 			 * New "godchild", add to list.
36067c478bd9Sstevel@tonic-gate 			 */
36077c478bd9Sstevel@tonic-gate 			if (Plfree == NULL) {
36087c478bd9Sstevel@tonic-gate 				plp = (struct pidlist *)calloc(DELTA,
36097c478bd9Sstevel@tonic-gate 				    sizeof (struct pidlist));
36107c478bd9Sstevel@tonic-gate 				if (plp == NULL) {
36117c478bd9Sstevel@tonic-gate 					/* Can't save pid */
36127c478bd9Sstevel@tonic-gate 					break;
36137c478bd9Sstevel@tonic-gate 				}
36147c478bd9Sstevel@tonic-gate 				/*
36157c478bd9Sstevel@tonic-gate 				 * Point at 2nd record allocated, we'll use plp.
36167c478bd9Sstevel@tonic-gate 				 */
36177c478bd9Sstevel@tonic-gate 				tp = plp + 1;
36187c478bd9Sstevel@tonic-gate 				/*
36197c478bd9Sstevel@tonic-gate 				 * Link them into a chain.
36207c478bd9Sstevel@tonic-gate 				 */
36217c478bd9Sstevel@tonic-gate 				Plfree = tp;
36227c478bd9Sstevel@tonic-gate 				for (i = 0; i < DELTA - 2; i++) {
36237c478bd9Sstevel@tonic-gate 					tp->pl_next = tp + 1;
36247c478bd9Sstevel@tonic-gate 					tp++;
36257c478bd9Sstevel@tonic-gate 				}
36267c478bd9Sstevel@tonic-gate 			} else {
36277c478bd9Sstevel@tonic-gate 				plp = Plfree;
36287c478bd9Sstevel@tonic-gate 				Plfree = plp->pl_next;
36297c478bd9Sstevel@tonic-gate 			}
36307c478bd9Sstevel@tonic-gate 			plp->pl_pid = p->pd_pid;
36317c478bd9Sstevel@tonic-gate 			plp->pl_dflag = 0;
36327c478bd9Sstevel@tonic-gate 			plp->pl_next = NULL;
36337c478bd9Sstevel@tonic-gate 			/*
36347c478bd9Sstevel@tonic-gate 			 * Note - pid list is kept in increasing order of pids.
36357c478bd9Sstevel@tonic-gate 			 */
36367c478bd9Sstevel@tonic-gate 			if (Plhead == NULL) {
36377c478bd9Sstevel@tonic-gate 				Plhead = plp;
36387c478bd9Sstevel@tonic-gate 				/* Back up to read next record */
36397c478bd9Sstevel@tonic-gate 				break;
36407c478bd9Sstevel@tonic-gate 			} else {
36417c478bd9Sstevel@tonic-gate 				savetp = tp = Plhead;
36427c478bd9Sstevel@tonic-gate 				while (tp) {
36437c478bd9Sstevel@tonic-gate 					if (plp->pl_pid > tp->pl_pid) {
36447c478bd9Sstevel@tonic-gate 						savetp = tp;
36457c478bd9Sstevel@tonic-gate 						tp = tp->pl_next;
36467c478bd9Sstevel@tonic-gate 						continue;
36477c478bd9Sstevel@tonic-gate 					} else if (plp->pl_pid < tp->pl_pid) {
36487c478bd9Sstevel@tonic-gate 						if (tp == Plhead) {
36497c478bd9Sstevel@tonic-gate 							plp->pl_next = Plhead;
36507c478bd9Sstevel@tonic-gate 							Plhead = plp;
36517c478bd9Sstevel@tonic-gate 						} else {
36527c478bd9Sstevel@tonic-gate 							plp->pl_next =
36537c478bd9Sstevel@tonic-gate 							    savetp->pl_next;
36547c478bd9Sstevel@tonic-gate 							savetp->pl_next = plp;
36557c478bd9Sstevel@tonic-gate 						}
36567c478bd9Sstevel@tonic-gate 						break;
36577c478bd9Sstevel@tonic-gate 					} else {
36587c478bd9Sstevel@tonic-gate 						/* Already in list! */
36597c478bd9Sstevel@tonic-gate 						plp->pl_next = Plfree;
36607c478bd9Sstevel@tonic-gate 						Plfree = plp;
36617c478bd9Sstevel@tonic-gate 						break;
36627c478bd9Sstevel@tonic-gate 					}
36637c478bd9Sstevel@tonic-gate 				}
36647c478bd9Sstevel@tonic-gate 				if (tp == NULL) {
36657c478bd9Sstevel@tonic-gate 					/* Add to end of list */
36667c478bd9Sstevel@tonic-gate 					savetp->pl_next = plp;
36677c478bd9Sstevel@tonic-gate 				}
36687c478bd9Sstevel@tonic-gate 			}
36697c478bd9Sstevel@tonic-gate 			/* Back up to read next record. */
36707c478bd9Sstevel@tonic-gate 			break;
36717c478bd9Sstevel@tonic-gate 
36727c478bd9Sstevel@tonic-gate 		case REMPID:
36737c478bd9Sstevel@tonic-gate 			/*
36747c478bd9Sstevel@tonic-gate 			 * This one was handled by someone else,
36757c478bd9Sstevel@tonic-gate 			 * purge it from the list.
36767c478bd9Sstevel@tonic-gate 			 */
36777c478bd9Sstevel@tonic-gate 			if (Plhead == NULL) {
36787c478bd9Sstevel@tonic-gate 				/* Back up to read next record. */
36797c478bd9Sstevel@tonic-gate 				break;
36807c478bd9Sstevel@tonic-gate 			}
36817c478bd9Sstevel@tonic-gate 			savetp = tp = Plhead;
36827c478bd9Sstevel@tonic-gate 			while (tp) {
36837c478bd9Sstevel@tonic-gate 				if (p->pd_pid > tp->pl_pid) {
36847c478bd9Sstevel@tonic-gate 					/* Keep on looking. */
36857c478bd9Sstevel@tonic-gate 					savetp = tp;
36867c478bd9Sstevel@tonic-gate 					tp = tp->pl_next;
36877c478bd9Sstevel@tonic-gate 					continue;
36887c478bd9Sstevel@tonic-gate 				} else if (p->pd_pid < tp->pl_pid) {
36897c478bd9Sstevel@tonic-gate 					/* Not in list. */
36907c478bd9Sstevel@tonic-gate 					break;
36917c478bd9Sstevel@tonic-gate 				} else {
36927c478bd9Sstevel@tonic-gate 					/* Found it. */
36937c478bd9Sstevel@tonic-gate 					if (tp == Plhead)
36947c478bd9Sstevel@tonic-gate 						Plhead = tp->pl_next;
36957c478bd9Sstevel@tonic-gate 					else
36967c478bd9Sstevel@tonic-gate 						savetp->pl_next = tp->pl_next;
36977c478bd9Sstevel@tonic-gate 					tp->pl_next = Plfree;
36987c478bd9Sstevel@tonic-gate 					Plfree = tp;
36997c478bd9Sstevel@tonic-gate 					break;
37007c478bd9Sstevel@tonic-gate 				}
37017c478bd9Sstevel@tonic-gate 			}
37027c478bd9Sstevel@tonic-gate 			/* Back up to read next record. */
37037c478bd9Sstevel@tonic-gate 			break;
37047c478bd9Sstevel@tonic-gate 		default:
37057c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Bad message on initpipe\n");
37067c478bd9Sstevel@tonic-gate 			break;
37077c478bd9Sstevel@tonic-gate 		}
37087c478bd9Sstevel@tonic-gate 	}
37097c478bd9Sstevel@tonic-gate }
37107c478bd9Sstevel@tonic-gate 
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate static void
37137c478bd9Sstevel@tonic-gate cleanaux()
37147c478bd9Sstevel@tonic-gate {
37157c478bd9Sstevel@tonic-gate 	struct pidlist *savep, *p;
37167c478bd9Sstevel@tonic-gate 	pid_t	pid;
37177c478bd9Sstevel@tonic-gate 	short	status;
37187c478bd9Sstevel@tonic-gate 
3719c39ec064SRoger A. Faulkner 	(void) sighold(SIGCLD);
37207c478bd9Sstevel@tonic-gate 	Gchild = 0;	/* Note - Safe to do this here since no SIGCLDs */
37217c478bd9Sstevel@tonic-gate 	(void) sighold(SIGPOLL);
37227c478bd9Sstevel@tonic-gate 	savep = p = Plhead;
37237c478bd9Sstevel@tonic-gate 	while (p) {
37247c478bd9Sstevel@tonic-gate 		if (p->pl_dflag) {
37257c478bd9Sstevel@tonic-gate 			/*
37267c478bd9Sstevel@tonic-gate 			 * Found an entry to delete,
37277c478bd9Sstevel@tonic-gate 			 * remove it from list first.
37287c478bd9Sstevel@tonic-gate 			 */
37297c478bd9Sstevel@tonic-gate 			pid = p->pl_pid;
37307c478bd9Sstevel@tonic-gate 			status = p->pl_exit;
37317c478bd9Sstevel@tonic-gate 			if (p == Plhead) {
37327c478bd9Sstevel@tonic-gate 				Plhead = p->pl_next;
37337c478bd9Sstevel@tonic-gate 				p->pl_next = Plfree;
37347c478bd9Sstevel@tonic-gate 				Plfree = p;
37357c478bd9Sstevel@tonic-gate 				savep = p = Plhead;
37367c478bd9Sstevel@tonic-gate 			} else {
37377c478bd9Sstevel@tonic-gate 				savep->pl_next = p->pl_next;
37387c478bd9Sstevel@tonic-gate 				p->pl_next = Plfree;
37397c478bd9Sstevel@tonic-gate 				Plfree = p;
37407c478bd9Sstevel@tonic-gate 				p = savep->pl_next;
37417c478bd9Sstevel@tonic-gate 			}
37427c478bd9Sstevel@tonic-gate 			clearent(pid, status);
37437c478bd9Sstevel@tonic-gate 			continue;
37447c478bd9Sstevel@tonic-gate 		}
37457c478bd9Sstevel@tonic-gate 		savep = p;
37467c478bd9Sstevel@tonic-gate 		p = p->pl_next;
37477c478bd9Sstevel@tonic-gate 	}
37487c478bd9Sstevel@tonic-gate 	(void) sigrelse(SIGPOLL);
3749c39ec064SRoger A. Faulkner 	(void) sigrelse(SIGCLD);
37507c478bd9Sstevel@tonic-gate }
37517c478bd9Sstevel@tonic-gate 
37527c478bd9Sstevel@tonic-gate 
37537c478bd9Sstevel@tonic-gate /*
37547c478bd9Sstevel@tonic-gate  * /etc/inittab has more entries and we have run out of room in the proc_table
37557c478bd9Sstevel@tonic-gate  * array. Double the size of proc_table to accomodate the extra entries.
37567c478bd9Sstevel@tonic-gate  */
37577c478bd9Sstevel@tonic-gate static void
37587c478bd9Sstevel@tonic-gate increase_proc_table_size()
37597c478bd9Sstevel@tonic-gate {
37607c478bd9Sstevel@tonic-gate 	sigset_t block, unblock;
37617c478bd9Sstevel@tonic-gate 	void *ptr;
37627c478bd9Sstevel@tonic-gate 	size_t delta = num_proc * sizeof (struct PROC_TABLE);
37637c478bd9Sstevel@tonic-gate 
37647c478bd9Sstevel@tonic-gate 
37657c478bd9Sstevel@tonic-gate 	/*
37667c478bd9Sstevel@tonic-gate 	 * Block signals for realloc.
37677c478bd9Sstevel@tonic-gate 	 */
37687c478bd9Sstevel@tonic-gate 	(void) sigfillset(&block);
37697c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_BLOCK, &block, &unblock);
37707c478bd9Sstevel@tonic-gate 
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 	/*
37737c478bd9Sstevel@tonic-gate 	 * On failure we just return because callers of this function check
37747c478bd9Sstevel@tonic-gate 	 * for failure.
37757c478bd9Sstevel@tonic-gate 	 */
37767c478bd9Sstevel@tonic-gate 	do
37777c478bd9Sstevel@tonic-gate 		ptr = realloc(g_state, g_state_sz + delta);
37780a1278f2SGary Mills 	while (ptr == NULL && errno == EAGAIN)
37790a1278f2SGary Mills 		;
37807c478bd9Sstevel@tonic-gate 
37817c478bd9Sstevel@tonic-gate 	if (ptr != NULL) {
37827c478bd9Sstevel@tonic-gate 		/* ensure that the new part is initialized to zero */
37837c478bd9Sstevel@tonic-gate 		bzero((caddr_t)ptr + g_state_sz, delta);
37847c478bd9Sstevel@tonic-gate 
37857c478bd9Sstevel@tonic-gate 		g_state = ptr;
37867c478bd9Sstevel@tonic-gate 		g_state_sz += delta;
37877c478bd9Sstevel@tonic-gate 		num_proc <<= 1;
37887c478bd9Sstevel@tonic-gate 	}
37897c478bd9Sstevel@tonic-gate 
37907c478bd9Sstevel@tonic-gate 
37917c478bd9Sstevel@tonic-gate 	/* unblock our signals before returning */
37927c478bd9Sstevel@tonic-gate 	(void) sigprocmask(SIG_SETMASK, &unblock, NULL);
37937c478bd9Sstevel@tonic-gate }
37947c478bd9Sstevel@tonic-gate 
37957c478bd9Sstevel@tonic-gate 
37967c478bd9Sstevel@tonic-gate 
37977c478bd9Sstevel@tonic-gate /*
37987c478bd9Sstevel@tonic-gate  * Sanity check g_state.
37997c478bd9Sstevel@tonic-gate  */
38007c478bd9Sstevel@tonic-gate static int
38017c478bd9Sstevel@tonic-gate st_sane()
38027c478bd9Sstevel@tonic-gate {
38037c478bd9Sstevel@tonic-gate 	int i;
38047c478bd9Sstevel@tonic-gate 	struct PROC_TABLE *ptp;
38057c478bd9Sstevel@tonic-gate 
38067c478bd9Sstevel@tonic-gate 
38077c478bd9Sstevel@tonic-gate 	/* Note: cur_state is encoded as a signal number */
38087c478bd9Sstevel@tonic-gate 	if (cur_state < 1 || cur_state == 9 || cur_state > 13)
38097c478bd9Sstevel@tonic-gate 		return (0);
38107c478bd9Sstevel@tonic-gate 
38117c478bd9Sstevel@tonic-gate 	/* Check num_proc */
38127c478bd9Sstevel@tonic-gate 	if (g_state_sz != sizeof (struct init_state) + (num_proc - 1) *
38137c478bd9Sstevel@tonic-gate 	    sizeof (struct PROC_TABLE))
38147c478bd9Sstevel@tonic-gate 		return (0);
38157c478bd9Sstevel@tonic-gate 
38167c478bd9Sstevel@tonic-gate 	/* Check proc_table */
38177c478bd9Sstevel@tonic-gate 	for (i = 0, ptp = proc_table; i < num_proc; ++i, ++ptp) {
38187c478bd9Sstevel@tonic-gate 		/* skip unoccupied entries */
38197c478bd9Sstevel@tonic-gate 		if (!(ptp->p_flags & OCCUPIED))
38207c478bd9Sstevel@tonic-gate 			continue;
38217c478bd9Sstevel@tonic-gate 
38227c478bd9Sstevel@tonic-gate 		/* p_flags has no bits outside of PF_MASK */
38237c478bd9Sstevel@tonic-gate 		if (ptp->p_flags & ~(PF_MASK))
38247c478bd9Sstevel@tonic-gate 			return (0);
38257c478bd9Sstevel@tonic-gate 
38267c478bd9Sstevel@tonic-gate 		/* 5 <= pid <= MAXPID */
38277c478bd9Sstevel@tonic-gate 		if (ptp->p_pid < 5 || ptp->p_pid > MAXPID)
38287c478bd9Sstevel@tonic-gate 			return (0);
38297c478bd9Sstevel@tonic-gate 
38307c478bd9Sstevel@tonic-gate 		/* p_count >= 0 */
38317c478bd9Sstevel@tonic-gate 		if (ptp->p_count < 0)
38327c478bd9Sstevel@tonic-gate 			return (0);
38337c478bd9Sstevel@tonic-gate 
38347c478bd9Sstevel@tonic-gate 		/* p_time >= 0 */
38357c478bd9Sstevel@tonic-gate 		if (ptp->p_time < 0)
38367c478bd9Sstevel@tonic-gate 			return (0);
38377c478bd9Sstevel@tonic-gate 	}
38387c478bd9Sstevel@tonic-gate 
38397c478bd9Sstevel@tonic-gate 	return (1);
38407c478bd9Sstevel@tonic-gate }
38417c478bd9Sstevel@tonic-gate 
38427c478bd9Sstevel@tonic-gate /*
38437c478bd9Sstevel@tonic-gate  * Initialize our state.
38447c478bd9Sstevel@tonic-gate  *
38457c478bd9Sstevel@tonic-gate  * If the system just booted, then init_state_file, which is located on an
38467c478bd9Sstevel@tonic-gate  * everpresent tmpfs filesystem, should not exist.
38477c478bd9Sstevel@tonic-gate  *
38487c478bd9Sstevel@tonic-gate  * If we were restarted, then init_state_file should exist, in
38497c478bd9Sstevel@tonic-gate  * which case we'll read it in, sanity check it, and use it.
38507c478bd9Sstevel@tonic-gate  *
38517c478bd9Sstevel@tonic-gate  * Note: You can't call console() until proc_table is ready.
38527c478bd9Sstevel@tonic-gate  */
38537c478bd9Sstevel@tonic-gate void
38547c478bd9Sstevel@tonic-gate st_init()
38557c478bd9Sstevel@tonic-gate {
38567c478bd9Sstevel@tonic-gate 	struct stat stb;
38577c478bd9Sstevel@tonic-gate 	int ret, st_fd, insane = 0;
38587c478bd9Sstevel@tonic-gate 	size_t to_be_read;
38597c478bd9Sstevel@tonic-gate 	char *ptr;
38607c478bd9Sstevel@tonic-gate 
38617c478bd9Sstevel@tonic-gate 
38627c478bd9Sstevel@tonic-gate 	booting = 1;
38637c478bd9Sstevel@tonic-gate 
38647c478bd9Sstevel@tonic-gate 	do {
38657c478bd9Sstevel@tonic-gate 		/*
38667c478bd9Sstevel@tonic-gate 		 * If we can exclusively create the file, then we're the
38677c478bd9Sstevel@tonic-gate 		 * initial invocation of init(1M).
38687c478bd9Sstevel@tonic-gate 		 */
38697c478bd9Sstevel@tonic-gate 		st_fd = open(init_state_file, O_RDWR | O_CREAT | O_EXCL,
38707c478bd9Sstevel@tonic-gate 		    S_IRUSR | S_IWUSR);
38717c478bd9Sstevel@tonic-gate 	} while (st_fd == -1 && errno == EINTR);
38727c478bd9Sstevel@tonic-gate 	if (st_fd != -1)
38737c478bd9Sstevel@tonic-gate 		goto new_state;
38747c478bd9Sstevel@tonic-gate 
38757c478bd9Sstevel@tonic-gate 	booting = 0;
38767c478bd9Sstevel@tonic-gate 
38777c478bd9Sstevel@tonic-gate 	do {
38787c478bd9Sstevel@tonic-gate 		st_fd = open(init_state_file, O_RDWR, S_IRUSR | S_IWUSR);
38797c478bd9Sstevel@tonic-gate 	} while (st_fd == -1 && errno == EINTR);
38807c478bd9Sstevel@tonic-gate 	if (st_fd == -1)
38817c478bd9Sstevel@tonic-gate 		goto new_state;
38827c478bd9Sstevel@tonic-gate 
38837c478bd9Sstevel@tonic-gate 	/* Get the size of the file. */
38847c478bd9Sstevel@tonic-gate 	do
38857c478bd9Sstevel@tonic-gate 		ret = fstat(st_fd, &stb);
38860a1278f2SGary Mills 	while (ret == -1 && errno == EINTR)
38870a1278f2SGary Mills 		;
38887c478bd9Sstevel@tonic-gate 	if (ret == -1)
38897c478bd9Sstevel@tonic-gate 		goto new_state;
38907c478bd9Sstevel@tonic-gate 
38917c478bd9Sstevel@tonic-gate 	do
38927c478bd9Sstevel@tonic-gate 		g_state = malloc(stb.st_size);
38930a1278f2SGary Mills 	while (g_state == NULL && errno == EAGAIN)
38940a1278f2SGary Mills 		;
38957c478bd9Sstevel@tonic-gate 	if (g_state == NULL)
38967c478bd9Sstevel@tonic-gate 		goto new_state;
38977c478bd9Sstevel@tonic-gate 
38987c478bd9Sstevel@tonic-gate 	to_be_read = stb.st_size;
38997c478bd9Sstevel@tonic-gate 	ptr = (char *)g_state;
39007c478bd9Sstevel@tonic-gate 	while (to_be_read > 0) {
39017c478bd9Sstevel@tonic-gate 		ssize_t read_ret;
39027c478bd9Sstevel@tonic-gate 
39037c478bd9Sstevel@tonic-gate 		read_ret = read(st_fd, ptr, to_be_read);
39047c478bd9Sstevel@tonic-gate 		if (read_ret < 0) {
39057c478bd9Sstevel@tonic-gate 			if (errno == EINTR)
39067c478bd9Sstevel@tonic-gate 				continue;
39077c478bd9Sstevel@tonic-gate 
39087c478bd9Sstevel@tonic-gate 			goto new_state;
39097c478bd9Sstevel@tonic-gate 		}
39107c478bd9Sstevel@tonic-gate 
39117c478bd9Sstevel@tonic-gate 		to_be_read -= read_ret;
39127c478bd9Sstevel@tonic-gate 		ptr += read_ret;
39137c478bd9Sstevel@tonic-gate 	}
39147c478bd9Sstevel@tonic-gate 
39157c478bd9Sstevel@tonic-gate 	(void) close(st_fd);
39167c478bd9Sstevel@tonic-gate 
39177c478bd9Sstevel@tonic-gate 	g_state_sz = stb.st_size;
39187c478bd9Sstevel@tonic-gate 
39197c478bd9Sstevel@tonic-gate 	if (st_sane()) {
39207c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Restarting.\n");
39217c478bd9Sstevel@tonic-gate 		return;
39227c478bd9Sstevel@tonic-gate 	}
39237c478bd9Sstevel@tonic-gate 
39247c478bd9Sstevel@tonic-gate 	insane = 1;
39257c478bd9Sstevel@tonic-gate 
39267c478bd9Sstevel@tonic-gate new_state:
39277c478bd9Sstevel@tonic-gate 	if (st_fd >= 0)
39287c478bd9Sstevel@tonic-gate 		(void) close(st_fd);
39297c478bd9Sstevel@tonic-gate 	else
39307c478bd9Sstevel@tonic-gate 		(void) unlink(init_state_file);
39317c478bd9Sstevel@tonic-gate 
39327c478bd9Sstevel@tonic-gate 	if (g_state != NULL)
39337c478bd9Sstevel@tonic-gate 		free(g_state);
39347c478bd9Sstevel@tonic-gate 
39357c478bd9Sstevel@tonic-gate 	/* Something went wrong, so allocate new state. */
39367c478bd9Sstevel@tonic-gate 	g_state_sz = sizeof (struct init_state) +
39377c478bd9Sstevel@tonic-gate 	    ((init_num_proc - 1) * sizeof (struct PROC_TABLE));
39387c478bd9Sstevel@tonic-gate 	do
39397c478bd9Sstevel@tonic-gate 		g_state = calloc(1, g_state_sz);
39400a1278f2SGary Mills 	while (g_state == NULL && errno == EAGAIN)
39410a1278f2SGary Mills 		;
39427c478bd9Sstevel@tonic-gate 	if (g_state == NULL) {
39437c478bd9Sstevel@tonic-gate 		/* Fatal error! */
39447c478bd9Sstevel@tonic-gate 		exit(errno);
39457c478bd9Sstevel@tonic-gate 	}
39467c478bd9Sstevel@tonic-gate 
39477c478bd9Sstevel@tonic-gate 	g_state->ist_runlevel = -1;
39487c478bd9Sstevel@tonic-gate 	num_proc = init_num_proc;
39497c478bd9Sstevel@tonic-gate 
39507c478bd9Sstevel@tonic-gate 	if (!booting) {
39517c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Restarting.\n");
39527c478bd9Sstevel@tonic-gate 
39537c478bd9Sstevel@tonic-gate 		/* Overwrite the bad state file. */
39547c478bd9Sstevel@tonic-gate 		st_write();
39557c478bd9Sstevel@tonic-gate 
39567c478bd9Sstevel@tonic-gate 		if (!insane) {
39577c478bd9Sstevel@tonic-gate 			console(B_TRUE,
39587c478bd9Sstevel@tonic-gate 			    "Error accessing persistent state file `%s'.  "
39597c478bd9Sstevel@tonic-gate 			    "Ignored.\n", init_state_file);
39607c478bd9Sstevel@tonic-gate 		} else {
39617c478bd9Sstevel@tonic-gate 			console(B_TRUE,
39627c478bd9Sstevel@tonic-gate 			    "Persistent state file `%s' is invalid and was "
39637c478bd9Sstevel@tonic-gate 			    "ignored.\n", init_state_file);
39647c478bd9Sstevel@tonic-gate 		}
39657c478bd9Sstevel@tonic-gate 	}
39667c478bd9Sstevel@tonic-gate }
39677c478bd9Sstevel@tonic-gate 
39687c478bd9Sstevel@tonic-gate /*
39697c478bd9Sstevel@tonic-gate  * Write g_state out to the state file.
39707c478bd9Sstevel@tonic-gate  */
39717c478bd9Sstevel@tonic-gate void
39727c478bd9Sstevel@tonic-gate st_write()
39737c478bd9Sstevel@tonic-gate {
39747c478bd9Sstevel@tonic-gate 	static int complained = 0;
39757c478bd9Sstevel@tonic-gate 
39767c478bd9Sstevel@tonic-gate 	int st_fd;
39777c478bd9Sstevel@tonic-gate 	char *cp;
39787c478bd9Sstevel@tonic-gate 	size_t sz;
39797c478bd9Sstevel@tonic-gate 	ssize_t ret;
39807c478bd9Sstevel@tonic-gate 
39817c478bd9Sstevel@tonic-gate 
39827c478bd9Sstevel@tonic-gate 	do {
39837c478bd9Sstevel@tonic-gate 		st_fd = open(init_next_state_file,
39847c478bd9Sstevel@tonic-gate 		    O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
39857c478bd9Sstevel@tonic-gate 	} while (st_fd < 0 && errno == EINTR);
39867c478bd9Sstevel@tonic-gate 	if (st_fd < 0)
39877c478bd9Sstevel@tonic-gate 		goto err;
39887c478bd9Sstevel@tonic-gate 
39897c478bd9Sstevel@tonic-gate 	cp = (char *)g_state;
39907c478bd9Sstevel@tonic-gate 	sz = g_state_sz;
39917c478bd9Sstevel@tonic-gate 	while (sz > 0) {
39927c478bd9Sstevel@tonic-gate 		ret = write(st_fd, cp, sz);
39937c478bd9Sstevel@tonic-gate 		if (ret < 0) {
39947c478bd9Sstevel@tonic-gate 			if (errno == EINTR)
39957c478bd9Sstevel@tonic-gate 				continue;
39967c478bd9Sstevel@tonic-gate 
39977c478bd9Sstevel@tonic-gate 			goto err;
39987c478bd9Sstevel@tonic-gate 		}
39997c478bd9Sstevel@tonic-gate 
40007c478bd9Sstevel@tonic-gate 		sz -= ret;
40017c478bd9Sstevel@tonic-gate 		cp += ret;
40027c478bd9Sstevel@tonic-gate 	}
40037c478bd9Sstevel@tonic-gate 
40047c478bd9Sstevel@tonic-gate 	(void) close(st_fd);
40057c478bd9Sstevel@tonic-gate 	st_fd = -1;
40067c478bd9Sstevel@tonic-gate 	if (rename(init_next_state_file, init_state_file)) {
40077c478bd9Sstevel@tonic-gate 		(void) unlink(init_next_state_file);
40087c478bd9Sstevel@tonic-gate 		goto err;
40097c478bd9Sstevel@tonic-gate 	}
40107c478bd9Sstevel@tonic-gate 	complained = 0;
40117c478bd9Sstevel@tonic-gate 
40127c478bd9Sstevel@tonic-gate 	return;
40137c478bd9Sstevel@tonic-gate 
40147c478bd9Sstevel@tonic-gate err:
40157c478bd9Sstevel@tonic-gate 	if (st_fd >= 0)
40167c478bd9Sstevel@tonic-gate 		(void) close(st_fd);
40177c478bd9Sstevel@tonic-gate 
40187c478bd9Sstevel@tonic-gate 	if (!booting && !complained) {
40197c478bd9Sstevel@tonic-gate 		/*
40207c478bd9Sstevel@tonic-gate 		 * Only complain after the filesystem should have come up.
40217c478bd9Sstevel@tonic-gate 		 * And only do it once so we don't loop between console()
40227c478bd9Sstevel@tonic-gate 		 * & efork().
40237c478bd9Sstevel@tonic-gate 		 */
40247c478bd9Sstevel@tonic-gate 		complained = 1;
40257c478bd9Sstevel@tonic-gate 		if (st_fd)
40267c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Couldn't write persistent state "
40277c478bd9Sstevel@tonic-gate 			    "file `%s'.\n", init_state_file);
40287c478bd9Sstevel@tonic-gate 		else
40297c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Couldn't move persistent state "
40307c478bd9Sstevel@tonic-gate 			    "file `%s' to `%s'.\n", init_next_state_file,
40317c478bd9Sstevel@tonic-gate 			    init_state_file);
40327c478bd9Sstevel@tonic-gate 	}
40337c478bd9Sstevel@tonic-gate }
40347c478bd9Sstevel@tonic-gate 
40357c478bd9Sstevel@tonic-gate /*
40367c478bd9Sstevel@tonic-gate  * Create a contract with these parameters.
40377c478bd9Sstevel@tonic-gate  */
40387c478bd9Sstevel@tonic-gate static int
40397c478bd9Sstevel@tonic-gate contract_make_template(uint_t info, uint_t critical, uint_t fatal,
40407c478bd9Sstevel@tonic-gate     uint64_t cookie)
40417c478bd9Sstevel@tonic-gate {
40427c478bd9Sstevel@tonic-gate 	int fd, err;
40437c478bd9Sstevel@tonic-gate 
40447c478bd9Sstevel@tonic-gate 	char *ioctl_tset_emsg =
40457c478bd9Sstevel@tonic-gate 	    "Couldn't set \"%s\" contract template parameter: %s.\n";
40467c478bd9Sstevel@tonic-gate 
40477c478bd9Sstevel@tonic-gate 	do
40487c478bd9Sstevel@tonic-gate 		fd = open64(CTFS_ROOT "/process/template", O_RDWR);
40490a1278f2SGary Mills 	while (fd < 0 && errno == EINTR)
40500a1278f2SGary Mills 		;
40517c478bd9Sstevel@tonic-gate 	if (fd < 0) {
40527c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Couldn't create process template: %s.\n",
40537c478bd9Sstevel@tonic-gate 		    strerror(errno));
40547c478bd9Sstevel@tonic-gate 		return (-1);
40557c478bd9Sstevel@tonic-gate 	}
40567c478bd9Sstevel@tonic-gate 
40577c478bd9Sstevel@tonic-gate 	if (err = ct_pr_tmpl_set_param(fd, CT_PR_INHERIT | CT_PR_REGENT))
40587c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Contract set template inherit, regent "
40597b209c2cSacruz 		    "failed: %s.\n", strerror(err));
40607c478bd9Sstevel@tonic-gate 
40617c478bd9Sstevel@tonic-gate 	/*
40627c478bd9Sstevel@tonic-gate 	 * These errors result in a misconfigured template, which is better
40637c478bd9Sstevel@tonic-gate 	 * than no template at all, so warn but don't abort.
40647c478bd9Sstevel@tonic-gate 	 */
40657c478bd9Sstevel@tonic-gate 	if (err = ct_tmpl_set_informative(fd, info))
40667c478bd9Sstevel@tonic-gate 		console(B_TRUE, ioctl_tset_emsg, "informative", strerror(err));
40677c478bd9Sstevel@tonic-gate 
40687c478bd9Sstevel@tonic-gate 	if (err = ct_tmpl_set_critical(fd, critical))
40697c478bd9Sstevel@tonic-gate 		console(B_TRUE, ioctl_tset_emsg, "critical", strerror(err));
40707c478bd9Sstevel@tonic-gate 
40717c478bd9Sstevel@tonic-gate 	if (err = ct_pr_tmpl_set_fatal(fd, fatal))
40727c478bd9Sstevel@tonic-gate 		console(B_TRUE, ioctl_tset_emsg, "fatal", strerror(err));
40737c478bd9Sstevel@tonic-gate 
40747c478bd9Sstevel@tonic-gate 	if (err = ct_tmpl_set_cookie(fd, cookie))
40757c478bd9Sstevel@tonic-gate 		console(B_TRUE, ioctl_tset_emsg, "cookie", strerror(err));
40767c478bd9Sstevel@tonic-gate 
40777c478bd9Sstevel@tonic-gate 	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
40787c478bd9Sstevel@tonic-gate 
40797c478bd9Sstevel@tonic-gate 	return (fd);
40807c478bd9Sstevel@tonic-gate }
40817c478bd9Sstevel@tonic-gate 
40827c478bd9Sstevel@tonic-gate /*
40837c478bd9Sstevel@tonic-gate  * Create the templates and open an event file descriptor.  We use dup2(2) to
40847c478bd9Sstevel@tonic-gate  * get these descriptors away from the stdin/stdout/stderr group.
40857c478bd9Sstevel@tonic-gate  */
40867c478bd9Sstevel@tonic-gate static void
40877c478bd9Sstevel@tonic-gate contracts_init()
40887c478bd9Sstevel@tonic-gate {
40897c478bd9Sstevel@tonic-gate 	int err, fd;
40907c478bd9Sstevel@tonic-gate 
40917c478bd9Sstevel@tonic-gate 	/*
40927c478bd9Sstevel@tonic-gate 	 * Create & configure a legacy template.  We only want empty events so
40937c478bd9Sstevel@tonic-gate 	 * we know when to abandon them.
40947c478bd9Sstevel@tonic-gate 	 */
40957c478bd9Sstevel@tonic-gate 	legacy_tmpl = contract_make_template(0, CT_PR_EV_EMPTY, CT_PR_EV_HWERR,
40967c478bd9Sstevel@tonic-gate 	    ORDINARY_COOKIE);
40977c478bd9Sstevel@tonic-gate 	if (legacy_tmpl >= 0) {
40987c478bd9Sstevel@tonic-gate 		err = ct_tmpl_activate(legacy_tmpl);
40997c478bd9Sstevel@tonic-gate 		if (err != 0) {
41007c478bd9Sstevel@tonic-gate 			(void) close(legacy_tmpl);
41017c478bd9Sstevel@tonic-gate 			legacy_tmpl = -1;
41027c478bd9Sstevel@tonic-gate 			console(B_TRUE,
41037c478bd9Sstevel@tonic-gate 			    "Couldn't activate legacy template (%s); "
41047c478bd9Sstevel@tonic-gate 			    "legacy services will be in init's contract.\n",
41057c478bd9Sstevel@tonic-gate 			    strerror(err));
41067c478bd9Sstevel@tonic-gate 		}
41077c478bd9Sstevel@tonic-gate 	} else
41087c478bd9Sstevel@tonic-gate 		console(B_TRUE,
41097c478bd9Sstevel@tonic-gate 		    "Legacy services will be in init's contract.\n");
41107c478bd9Sstevel@tonic-gate 
41117c478bd9Sstevel@tonic-gate 	if (dup2(legacy_tmpl, 255) == -1) {
41127c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Could not duplicate legacy template: %s.\n",
41137c478bd9Sstevel@tonic-gate 		    strerror(errno));
41147c478bd9Sstevel@tonic-gate 	} else {
41157c478bd9Sstevel@tonic-gate 		(void) close(legacy_tmpl);
41167c478bd9Sstevel@tonic-gate 		legacy_tmpl = 255;
41177c478bd9Sstevel@tonic-gate 	}
41187c478bd9Sstevel@tonic-gate 
41197c478bd9Sstevel@tonic-gate 	(void) fcntl(legacy_tmpl, F_SETFD, FD_CLOEXEC);
41207c478bd9Sstevel@tonic-gate 
41217c478bd9Sstevel@tonic-gate 	startd_tmpl = contract_make_template(0, CT_PR_EV_EMPTY,
41227c478bd9Sstevel@tonic-gate 	    CT_PR_EV_HWERR | CT_PR_EV_SIGNAL | CT_PR_EV_CORE, STARTD_COOKIE);
41237c478bd9Sstevel@tonic-gate 
41247c478bd9Sstevel@tonic-gate 	if (dup2(startd_tmpl, 254) == -1) {
41257c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Could not duplicate startd template: %s.\n",
41267c478bd9Sstevel@tonic-gate 		    strerror(errno));
41277c478bd9Sstevel@tonic-gate 	} else {
41287c478bd9Sstevel@tonic-gate 		(void) close(startd_tmpl);
41297c478bd9Sstevel@tonic-gate 		startd_tmpl = 254;
41307c478bd9Sstevel@tonic-gate 	}
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 	(void) fcntl(startd_tmpl, F_SETFD, FD_CLOEXEC);
41337c478bd9Sstevel@tonic-gate 
41347c478bd9Sstevel@tonic-gate 	if (legacy_tmpl < 0 && startd_tmpl < 0) {
41357c478bd9Sstevel@tonic-gate 		/* The creation errors have already been reported. */
41367c478bd9Sstevel@tonic-gate 		console(B_TRUE,
41377c478bd9Sstevel@tonic-gate 		    "Ignoring contract events.  Core smf(5) services will not "
41387c478bd9Sstevel@tonic-gate 		    "be restarted.\n");
41397c478bd9Sstevel@tonic-gate 		return;
41407c478bd9Sstevel@tonic-gate 	}
41417c478bd9Sstevel@tonic-gate 
41427c478bd9Sstevel@tonic-gate 	/*
41437c478bd9Sstevel@tonic-gate 	 * Open an event endpoint.
41447c478bd9Sstevel@tonic-gate 	 */
41457c478bd9Sstevel@tonic-gate 	do
41467c478bd9Sstevel@tonic-gate 		fd = open64(CTFS_ROOT "/process/pbundle", O_RDONLY);
41470a1278f2SGary Mills 	while (fd < 0 && errno == EINTR)
41480a1278f2SGary Mills 		;
41497c478bd9Sstevel@tonic-gate 	if (fd < 0) {
41507c478bd9Sstevel@tonic-gate 		console(B_TRUE,
41517c478bd9Sstevel@tonic-gate 		    "Couldn't open process pbundle: %s.  Core smf(5) services "
41527c478bd9Sstevel@tonic-gate 		    "will not be restarted.\n", strerror(errno));
41537c478bd9Sstevel@tonic-gate 		return;
41547c478bd9Sstevel@tonic-gate 	}
41557c478bd9Sstevel@tonic-gate 
41567c478bd9Sstevel@tonic-gate 	if (dup2(fd, 253) == -1) {
41577c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Could not duplicate process bundle: %s.\n",
41587c478bd9Sstevel@tonic-gate 		    strerror(errno));
41597c478bd9Sstevel@tonic-gate 	} else {
41607c478bd9Sstevel@tonic-gate 		(void) close(fd);
41617c478bd9Sstevel@tonic-gate 		fd = 253;
41627c478bd9Sstevel@tonic-gate 	}
41637c478bd9Sstevel@tonic-gate 
41647c478bd9Sstevel@tonic-gate 	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
41657c478bd9Sstevel@tonic-gate 
41667c478bd9Sstevel@tonic-gate 	/* Reset in case we've been restarted. */
41677c478bd9Sstevel@tonic-gate 	(void) ct_event_reset(fd);
41687c478bd9Sstevel@tonic-gate 
41697c478bd9Sstevel@tonic-gate 	poll_fds[0].fd = fd;
41707c478bd9Sstevel@tonic-gate 	poll_fds[0].events = POLLIN;
41717c478bd9Sstevel@tonic-gate 	poll_nfds = 1;
41727c478bd9Sstevel@tonic-gate }
41737c478bd9Sstevel@tonic-gate 
41747c478bd9Sstevel@tonic-gate static int
41757c478bd9Sstevel@tonic-gate contract_getfile(ctid_t id, const char *name, int oflag)
41767c478bd9Sstevel@tonic-gate {
41777c478bd9Sstevel@tonic-gate 	int fd;
41787c478bd9Sstevel@tonic-gate 
41797c478bd9Sstevel@tonic-gate 	do
41807c478bd9Sstevel@tonic-gate 		fd = contract_open(id, "process", name, oflag);
41810a1278f2SGary Mills 	while (fd < 0 && errno == EINTR)
41820a1278f2SGary Mills 		;
41837c478bd9Sstevel@tonic-gate 
41847c478bd9Sstevel@tonic-gate 	if (fd < 0)
41857c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Couldn't open %s for contract %ld: %s.\n",
41867c478bd9Sstevel@tonic-gate 		    name, id, strerror(errno));
41877c478bd9Sstevel@tonic-gate 
41887c478bd9Sstevel@tonic-gate 	return (fd);
41897c478bd9Sstevel@tonic-gate }
41907c478bd9Sstevel@tonic-gate 
41917c478bd9Sstevel@tonic-gate static int
41927c478bd9Sstevel@tonic-gate contract_cookie(ctid_t id, uint64_t *cp)
41937c478bd9Sstevel@tonic-gate {
41947c478bd9Sstevel@tonic-gate 	int fd, err;
41957c478bd9Sstevel@tonic-gate 	ct_stathdl_t sh;
41967c478bd9Sstevel@tonic-gate 
41977c478bd9Sstevel@tonic-gate 	fd = contract_getfile(id, "status", O_RDONLY);
41987c478bd9Sstevel@tonic-gate 	if (fd < 0)
41997c478bd9Sstevel@tonic-gate 		return (-1);
42007c478bd9Sstevel@tonic-gate 
42017c478bd9Sstevel@tonic-gate 	err = ct_status_read(fd, CTD_COMMON, &sh);
42027c478bd9Sstevel@tonic-gate 	if (err != 0) {
42037c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Couldn't read status of contract %ld: %s.\n",
42047c478bd9Sstevel@tonic-gate 		    id, strerror(err));
42057c478bd9Sstevel@tonic-gate 		(void) close(fd);
42067c478bd9Sstevel@tonic-gate 		return (-1);
42077c478bd9Sstevel@tonic-gate 	}
42087c478bd9Sstevel@tonic-gate 
42097c478bd9Sstevel@tonic-gate 	(void) close(fd);
42107c478bd9Sstevel@tonic-gate 
42117c478bd9Sstevel@tonic-gate 	*cp = ct_status_get_cookie(sh);
42127c478bd9Sstevel@tonic-gate 
42137c478bd9Sstevel@tonic-gate 	ct_status_free(sh);
42147c478bd9Sstevel@tonic-gate 	return (0);
42157c478bd9Sstevel@tonic-gate }
42167c478bd9Sstevel@tonic-gate 
42177c478bd9Sstevel@tonic-gate static void
42187c478bd9Sstevel@tonic-gate contract_ack(ct_evthdl_t e)
42197c478bd9Sstevel@tonic-gate {
42207c478bd9Sstevel@tonic-gate 	int fd;
42217c478bd9Sstevel@tonic-gate 
42227c478bd9Sstevel@tonic-gate 	if (ct_event_get_flags(e) & CTE_INFO)
42237c478bd9Sstevel@tonic-gate 		return;
42247c478bd9Sstevel@tonic-gate 
42257c478bd9Sstevel@tonic-gate 	fd = contract_getfile(ct_event_get_ctid(e), "ctl", O_WRONLY);
42267c478bd9Sstevel@tonic-gate 	if (fd < 0)
42277c478bd9Sstevel@tonic-gate 		return;
42287c478bd9Sstevel@tonic-gate 
42297c478bd9Sstevel@tonic-gate 	(void) ct_ctl_ack(fd, ct_event_get_evid(e));
42307c478bd9Sstevel@tonic-gate 	(void) close(fd);
42317c478bd9Sstevel@tonic-gate }
42327c478bd9Sstevel@tonic-gate 
42337c478bd9Sstevel@tonic-gate /*
42347c478bd9Sstevel@tonic-gate  * Process a contract event.
42357c478bd9Sstevel@tonic-gate  */
42367c478bd9Sstevel@tonic-gate static void
42377c478bd9Sstevel@tonic-gate contract_event(struct pollfd *poll)
42387c478bd9Sstevel@tonic-gate {
42397c478bd9Sstevel@tonic-gate 	ct_evthdl_t e;
42407c478bd9Sstevel@tonic-gate 	int err;
42417c478bd9Sstevel@tonic-gate 	ctid_t ctid;
42427c478bd9Sstevel@tonic-gate 
42437c478bd9Sstevel@tonic-gate 	if (!(poll->revents & POLLIN)) {
42447c478bd9Sstevel@tonic-gate 		if (poll->revents & POLLERR)
42457c478bd9Sstevel@tonic-gate 			console(B_TRUE,
42467c478bd9Sstevel@tonic-gate 			    "Unknown poll error on my process contract "
42477c478bd9Sstevel@tonic-gate 			    "pbundle.\n");
42487c478bd9Sstevel@tonic-gate 		return;
42497c478bd9Sstevel@tonic-gate 	}
42507c478bd9Sstevel@tonic-gate 
42517c478bd9Sstevel@tonic-gate 	err = ct_event_read(poll->fd, &e);
42527c478bd9Sstevel@tonic-gate 	if (err != 0) {
42537c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Error retrieving contract event: %s.\n",
42547c478bd9Sstevel@tonic-gate 		    strerror(err));
42557c478bd9Sstevel@tonic-gate 		return;
42567c478bd9Sstevel@tonic-gate 	}
42577c478bd9Sstevel@tonic-gate 
42587c478bd9Sstevel@tonic-gate 	ctid = ct_event_get_ctid(e);
42597c478bd9Sstevel@tonic-gate 
42607c478bd9Sstevel@tonic-gate 	if (ct_event_get_type(e) == CT_PR_EV_EMPTY) {
42617c478bd9Sstevel@tonic-gate 		uint64_t cookie;
42627c478bd9Sstevel@tonic-gate 		int ret, abandon = 1;
42637c478bd9Sstevel@tonic-gate 
42647c478bd9Sstevel@tonic-gate 		/* If it's svc.startd, restart it.  Else, abandon. */
42657c478bd9Sstevel@tonic-gate 		ret = contract_cookie(ctid, &cookie);
42667c478bd9Sstevel@tonic-gate 
42677c478bd9Sstevel@tonic-gate 		if (ret == 0) {
42687c478bd9Sstevel@tonic-gate 			if (cookie == STARTD_COOKIE &&
42697c478bd9Sstevel@tonic-gate 			    do_restart_startd) {
42707c478bd9Sstevel@tonic-gate 				if (smf_debug)
42717c478bd9Sstevel@tonic-gate 					console(B_TRUE, "Restarting "
42727c478bd9Sstevel@tonic-gate 					    "svc.startd.\n");
42737c478bd9Sstevel@tonic-gate 
42747c478bd9Sstevel@tonic-gate 				/*
42757c478bd9Sstevel@tonic-gate 				 * Account for the failure.  If the failure rate
42767c478bd9Sstevel@tonic-gate 				 * exceeds a threshold, then drop to maintenance
42777c478bd9Sstevel@tonic-gate 				 * mode.
42787c478bd9Sstevel@tonic-gate 				 */
42797c478bd9Sstevel@tonic-gate 				startd_record_failure();
42807c478bd9Sstevel@tonic-gate 				if (startd_failure_rate_critical())
42817c478bd9Sstevel@tonic-gate 					enter_maintenance();
42827c478bd9Sstevel@tonic-gate 
42837c478bd9Sstevel@tonic-gate 				if (startd_tmpl < 0)
42847c478bd9Sstevel@tonic-gate 					console(B_TRUE,
42857c478bd9Sstevel@tonic-gate 					    "Restarting svc.startd in "
42867c478bd9Sstevel@tonic-gate 					    "improper contract (bad "
42877c478bd9Sstevel@tonic-gate 					    "template).\n");
42887c478bd9Sstevel@tonic-gate 
42897c478bd9Sstevel@tonic-gate 				(void) startd_run(startd_cline, startd_tmpl,
42907c478bd9Sstevel@tonic-gate 				    ctid);
42917c478bd9Sstevel@tonic-gate 
42927c478bd9Sstevel@tonic-gate 				abandon = 0;
42937c478bd9Sstevel@tonic-gate 			}
42947c478bd9Sstevel@tonic-gate 		}
42957c478bd9Sstevel@tonic-gate 
42967c478bd9Sstevel@tonic-gate 		if (abandon && (err = contract_abandon_id(ctid))) {
42977c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Couldn't abandon contract %ld: %s.\n",
42987c478bd9Sstevel@tonic-gate 			    ctid, strerror(err));
42997c478bd9Sstevel@tonic-gate 		}
43007c478bd9Sstevel@tonic-gate 
43017c478bd9Sstevel@tonic-gate 		/*
43027c478bd9Sstevel@tonic-gate 		 * No need to acknowledge the event since either way the
43037c478bd9Sstevel@tonic-gate 		 * originating contract should be abandoned.
43047c478bd9Sstevel@tonic-gate 		 */
43057c478bd9Sstevel@tonic-gate 	} else {
43067c478bd9Sstevel@tonic-gate 		console(B_TRUE,
43077c478bd9Sstevel@tonic-gate 		    "Received contract event of unexpected type %d from "
43087c478bd9Sstevel@tonic-gate 		    "contract %ld.\n", ct_event_get_type(e), ctid);
43097c478bd9Sstevel@tonic-gate 
43107c478bd9Sstevel@tonic-gate 		if ((ct_event_get_flags(e) & (CTE_INFO | CTE_ACK)) == 0)
43117c478bd9Sstevel@tonic-gate 			/* Allow unexpected critical events to be released. */
43127c478bd9Sstevel@tonic-gate 			contract_ack(e);
43137c478bd9Sstevel@tonic-gate 	}
43147c478bd9Sstevel@tonic-gate 
43157c478bd9Sstevel@tonic-gate 	ct_event_free(e);
43167c478bd9Sstevel@tonic-gate }
43177c478bd9Sstevel@tonic-gate 
43187c478bd9Sstevel@tonic-gate /*
43197c478bd9Sstevel@tonic-gate  * svc.startd(1M) Management
43207c478bd9Sstevel@tonic-gate  */
43217c478bd9Sstevel@tonic-gate 
43227c478bd9Sstevel@tonic-gate /*
43237c478bd9Sstevel@tonic-gate  * (Re)start svc.startd(1M).  old_ctid should be the contract ID of the old
43247c478bd9Sstevel@tonic-gate  * contract, or 0 if we're starting it for the first time.  If wait is true
43257c478bd9Sstevel@tonic-gate  * we'll wait for and return the exit value of the child.
43267c478bd9Sstevel@tonic-gate  */
43277c478bd9Sstevel@tonic-gate static int
43287c478bd9Sstevel@tonic-gate startd_run(const char *cline, int tmpl, ctid_t old_ctid)
43297c478bd9Sstevel@tonic-gate {
43307c478bd9Sstevel@tonic-gate 	int err, i, ret, did_activate;
43317c478bd9Sstevel@tonic-gate 	pid_t pid;
43327c478bd9Sstevel@tonic-gate 	struct stat sb;
43337c478bd9Sstevel@tonic-gate 
43347c478bd9Sstevel@tonic-gate 	if (cline[0] == '\0')
43357c478bd9Sstevel@tonic-gate 		return (-1);
43367c478bd9Sstevel@tonic-gate 
43377c478bd9Sstevel@tonic-gate 	/*
43387c478bd9Sstevel@tonic-gate 	 * Don't restart startd if the system is rebooting or shutting down.
43397c478bd9Sstevel@tonic-gate 	 */
43407c478bd9Sstevel@tonic-gate 	do {
43417c478bd9Sstevel@tonic-gate 		ret = stat("/etc/svc/volatile/resetting", &sb);
43427c478bd9Sstevel@tonic-gate 	} while (ret == -1 && errno == EINTR);
43437c478bd9Sstevel@tonic-gate 
43447c478bd9Sstevel@tonic-gate 	if (ret == 0) {
43457c478bd9Sstevel@tonic-gate 		if (smf_debug)
43467c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Quiescing for reboot.\n");
43477c478bd9Sstevel@tonic-gate 		(void) pause();
43487c478bd9Sstevel@tonic-gate 		return (-1);
43497c478bd9Sstevel@tonic-gate 	}
43507c478bd9Sstevel@tonic-gate 
43517c478bd9Sstevel@tonic-gate 	err = ct_pr_tmpl_set_transfer(tmpl, old_ctid);
43527c478bd9Sstevel@tonic-gate 	if (err == EINVAL) {
43537c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Remake startd_tmpl; reattempt transfer.\n");
43547c478bd9Sstevel@tonic-gate 		tmpl = startd_tmpl = contract_make_template(0, CT_PR_EV_EMPTY,
43557c478bd9Sstevel@tonic-gate 		    CT_PR_EV_HWERR, STARTD_COOKIE);
43567c478bd9Sstevel@tonic-gate 
43577c478bd9Sstevel@tonic-gate 		err = ct_pr_tmpl_set_transfer(tmpl, old_ctid);
43587c478bd9Sstevel@tonic-gate 	}
43597c478bd9Sstevel@tonic-gate 	if (err != 0) {
43607c478bd9Sstevel@tonic-gate 		console(B_TRUE,
43617c478bd9Sstevel@tonic-gate 		    "Couldn't set transfer parameter of contract template: "
43627c478bd9Sstevel@tonic-gate 		    "%s.\n", strerror(err));
43637c478bd9Sstevel@tonic-gate 	}
43647c478bd9Sstevel@tonic-gate 
43657b209c2cSacruz 	if ((err = ct_pr_tmpl_set_svc_fmri(startd_tmpl,
43667b209c2cSacruz 	    SCF_SERVICE_STARTD)) != 0)
43677b209c2cSacruz 		console(B_TRUE,
43687b209c2cSacruz 		    "Can not set svc_fmri in contract template: %s\n",
43697b209c2cSacruz 		    strerror(err));
43707b209c2cSacruz 	if ((err = ct_pr_tmpl_set_svc_aux(startd_tmpl,
43717b209c2cSacruz 	    startd_svc_aux)) != 0)
43727b209c2cSacruz 		console(B_TRUE,
43737b209c2cSacruz 		    "Can not set svc_aux in contract template: %s\n",
43747b209c2cSacruz 		    strerror(err));
43757c478bd9Sstevel@tonic-gate 	did_activate = !(ct_tmpl_activate(tmpl));
43767c478bd9Sstevel@tonic-gate 	if (!did_activate)
43777c478bd9Sstevel@tonic-gate 		console(B_TRUE,
43787c478bd9Sstevel@tonic-gate 		    "Template activation failed; not starting \"%s\" in "
43797c478bd9Sstevel@tonic-gate 		    "proper contract.\n", cline);
43807c478bd9Sstevel@tonic-gate 
4381c39ec064SRoger A. Faulkner 	/* Hold SIGCLD so we can wait if necessary. */
4382c39ec064SRoger A. Faulkner 	(void) sighold(SIGCLD);
43837c478bd9Sstevel@tonic-gate 
43847c478bd9Sstevel@tonic-gate 	while ((pid = fork()) < 0) {
43857c478bd9Sstevel@tonic-gate 		if (errno == EPERM) {
43867c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Insufficient permission to fork.\n");
43877c478bd9Sstevel@tonic-gate 
43887c478bd9Sstevel@tonic-gate 			/* Now that's a doozy. */
43897c478bd9Sstevel@tonic-gate 			exit(1);
43907c478bd9Sstevel@tonic-gate 		}
43917c478bd9Sstevel@tonic-gate 
43927c478bd9Sstevel@tonic-gate 		console(B_TRUE,
43937c478bd9Sstevel@tonic-gate 		    "fork() for svc.startd failed: %s.  Will retry in 1 "
43947c478bd9Sstevel@tonic-gate 		    "second...\n", strerror(errno));
43957c478bd9Sstevel@tonic-gate 
43967c478bd9Sstevel@tonic-gate 		(void) sleep(1);
43977c478bd9Sstevel@tonic-gate 
43987c478bd9Sstevel@tonic-gate 		/* Eventually give up? */
43997c478bd9Sstevel@tonic-gate 	}
44007c478bd9Sstevel@tonic-gate 
44017c478bd9Sstevel@tonic-gate 	if (pid == 0) {
44027c478bd9Sstevel@tonic-gate 		/* child */
44037c478bd9Sstevel@tonic-gate 
44047c478bd9Sstevel@tonic-gate 		/* See the comment in efork() */
44057c478bd9Sstevel@tonic-gate 		for (i = SIGHUP; i <= SIGRTMAX; ++i) {
44067c478bd9Sstevel@tonic-gate 			if (i == SIGTTOU || i == SIGTTIN || i == SIGTSTP)
44077c478bd9Sstevel@tonic-gate 				(void) sigset(i, SIG_IGN);
44087c478bd9Sstevel@tonic-gate 			else
44097c478bd9Sstevel@tonic-gate 				(void) sigset(i, SIG_DFL);
44107c478bd9Sstevel@tonic-gate 		}
44117c478bd9Sstevel@tonic-gate 
44127c478bd9Sstevel@tonic-gate 		if (smf_options != NULL) {
44137c478bd9Sstevel@tonic-gate 			/* Put smf_options in the environment. */
44147c478bd9Sstevel@tonic-gate 			glob_envp[glob_envn] =
44157c478bd9Sstevel@tonic-gate 			    malloc(sizeof ("SMF_OPTIONS=") - 1 +
441648847494SEnrico Perla - Sun Microsystems 			    strlen(smf_options) + 1);
44177c478bd9Sstevel@tonic-gate 
44187c478bd9Sstevel@tonic-gate 			if (glob_envp[glob_envn] != NULL) {
44197c478bd9Sstevel@tonic-gate 				/* LINTED */
44207c478bd9Sstevel@tonic-gate 				(void) sprintf(glob_envp[glob_envn],
44217c478bd9Sstevel@tonic-gate 				    "SMF_OPTIONS=%s", smf_options);
44227c478bd9Sstevel@tonic-gate 				glob_envp[glob_envn+1] = NULL;
44237c478bd9Sstevel@tonic-gate 			} else {
44247c478bd9Sstevel@tonic-gate 				console(B_TRUE,
44257c478bd9Sstevel@tonic-gate 				    "Could not set SMF_OPTIONS (%s).\n",
44267c478bd9Sstevel@tonic-gate 				    strerror(errno));
44277c478bd9Sstevel@tonic-gate 			}
44287c478bd9Sstevel@tonic-gate 		}
44297c478bd9Sstevel@tonic-gate 
44307c478bd9Sstevel@tonic-gate 		if (smf_debug)
44317c478bd9Sstevel@tonic-gate 			console(B_TRUE, "Executing svc.startd\n");
44327c478bd9Sstevel@tonic-gate 
44337c478bd9Sstevel@tonic-gate 		(void) execle(SH, "INITSH", "-c", cline, NULL, glob_envp);
44347c478bd9Sstevel@tonic-gate 
44357c478bd9Sstevel@tonic-gate 		console(B_TRUE, "Could not exec \"%s\" (%s).\n", SH,
44367c478bd9Sstevel@tonic-gate 		    strerror(errno));
44377c478bd9Sstevel@tonic-gate 
44387c478bd9Sstevel@tonic-gate 		exit(1);
44397c478bd9Sstevel@tonic-gate 	}
44407c478bd9Sstevel@tonic-gate 
44417c478bd9Sstevel@tonic-gate 	/* parent */
44427c478bd9Sstevel@tonic-gate 
44437c478bd9Sstevel@tonic-gate 	if (did_activate) {
44447c478bd9Sstevel@tonic-gate 		if (legacy_tmpl < 0 || ct_tmpl_activate(legacy_tmpl) != 0)
44457c478bd9Sstevel@tonic-gate 			(void) ct_tmpl_clear(tmpl);
44467c478bd9Sstevel@tonic-gate 	}
44477c478bd9Sstevel@tonic-gate 
44487c478bd9Sstevel@tonic-gate 	/* Clear the old_ctid reference so the kernel can reclaim it. */
44497c478bd9Sstevel@tonic-gate 	if (old_ctid != 0)
44507c478bd9Sstevel@tonic-gate 		(void) ct_pr_tmpl_set_transfer(tmpl, 0);
44517c478bd9Sstevel@tonic-gate 
4452c39ec064SRoger A. Faulkner 	(void) sigrelse(SIGCLD);
44537c478bd9Sstevel@tonic-gate 
44547c478bd9Sstevel@tonic-gate 	return (0);
44557c478bd9Sstevel@tonic-gate }
44567c478bd9Sstevel@tonic-gate 
44577c478bd9Sstevel@tonic-gate /*
44587c478bd9Sstevel@tonic-gate  * void startd_record_failure(void)
44597c478bd9Sstevel@tonic-gate  *   Place the current time in our circular array of svc.startd failures.
44607c478bd9Sstevel@tonic-gate  */
44617c478bd9Sstevel@tonic-gate void
44627c478bd9Sstevel@tonic-gate startd_record_failure()
44637c478bd9Sstevel@tonic-gate {
44647c478bd9Sstevel@tonic-gate 	int index = startd_failure_index++ % NSTARTD_FAILURE_TIMES;
44657c478bd9Sstevel@tonic-gate 
44667c478bd9Sstevel@tonic-gate 	startd_failure_time[index] = gethrtime();
44677c478bd9Sstevel@tonic-gate }
44687c478bd9Sstevel@tonic-gate 
44697c478bd9Sstevel@tonic-gate /*
44707c478bd9Sstevel@tonic-gate  * int startd_failure_rate_critical(void)
44717c478bd9Sstevel@tonic-gate  *   Return true if the average failure interval is less than the permitted
44727c478bd9Sstevel@tonic-gate  *   interval.  Implicit success if insufficient measurements for an average
44737c478bd9Sstevel@tonic-gate  *   exist.
44747c478bd9Sstevel@tonic-gate  */
44757c478bd9Sstevel@tonic-gate int
44767c478bd9Sstevel@tonic-gate startd_failure_rate_critical()
44777c478bd9Sstevel@tonic-gate {
44787c478bd9Sstevel@tonic-gate 	int n = startd_failure_index;
44797c478bd9Sstevel@tonic-gate 	hrtime_t avg_ns = 0;
44807c478bd9Sstevel@tonic-gate 
44817c478bd9Sstevel@tonic-gate 	if (startd_failure_index < NSTARTD_FAILURE_TIMES)
44827c478bd9Sstevel@tonic-gate 		return (0);
44837c478bd9Sstevel@tonic-gate 
44847c478bd9Sstevel@tonic-gate 	avg_ns =
44857c478bd9Sstevel@tonic-gate 	    (startd_failure_time[(n - 1) % NSTARTD_FAILURE_TIMES] -
44867c478bd9Sstevel@tonic-gate 	    startd_failure_time[n % NSTARTD_FAILURE_TIMES]) /
44877c478bd9Sstevel@tonic-gate 	    NSTARTD_FAILURE_TIMES;
44887c478bd9Sstevel@tonic-gate 
44897c478bd9Sstevel@tonic-gate 	return (avg_ns < STARTD_FAILURE_RATE_NS);
44907c478bd9Sstevel@tonic-gate }
44917c478bd9Sstevel@tonic-gate 
44927c478bd9Sstevel@tonic-gate /*
44937c478bd9Sstevel@tonic-gate  * returns string that must be free'd
44947c478bd9Sstevel@tonic-gate  */
44957c478bd9Sstevel@tonic-gate 
44967c478bd9Sstevel@tonic-gate static char
44977c478bd9Sstevel@tonic-gate *audit_boot_msg()
44987c478bd9Sstevel@tonic-gate {
44997c478bd9Sstevel@tonic-gate 	char		*b, *p;
45007c478bd9Sstevel@tonic-gate 	char		desc[] = "booted";
45017c478bd9Sstevel@tonic-gate 	zoneid_t	zid = getzoneid();
45027c478bd9Sstevel@tonic-gate 
45037c478bd9Sstevel@tonic-gate 	b = malloc(sizeof (desc) + MAXNAMELEN + 3);
45047c478bd9Sstevel@tonic-gate 	if (b == NULL)
45057c478bd9Sstevel@tonic-gate 		return (b);
45067c478bd9Sstevel@tonic-gate 
45077c478bd9Sstevel@tonic-gate 	p = b;
45087c478bd9Sstevel@tonic-gate 	p += strlcpy(p, desc, sizeof (desc));
45097c478bd9Sstevel@tonic-gate 	if (zid != GLOBAL_ZONEID) {
45107c478bd9Sstevel@tonic-gate 		p += strlcpy(p, ": ", 3);
45117c478bd9Sstevel@tonic-gate 		(void) getzonenamebyid(zid, p, MAXNAMELEN);
45127c478bd9Sstevel@tonic-gate 	}
45137c478bd9Sstevel@tonic-gate 	return (b);
45147c478bd9Sstevel@tonic-gate }
45157c478bd9Sstevel@tonic-gate 
45167c478bd9Sstevel@tonic-gate /*
45177c478bd9Sstevel@tonic-gate  * Generate AUE_init_solaris audit record.  Return 1 if
45187c478bd9Sstevel@tonic-gate  * auditing is enabled in case the caller cares.
45197c478bd9Sstevel@tonic-gate  *
45207c478bd9Sstevel@tonic-gate  * In the case of userint() or a local zone invocation of
45217c478bd9Sstevel@tonic-gate  * one_true_init, the process initially contains the audit
45227c478bd9Sstevel@tonic-gate  * characteristics of the process that invoked init.  The first pass
45237c478bd9Sstevel@tonic-gate  * through here uses those characteristics then for the case of
45247c478bd9Sstevel@tonic-gate  * one_true_init in a local zone, clears them so subsequent system
45257c478bd9Sstevel@tonic-gate  * state changes won't be attributed to the person who booted the
45267c478bd9Sstevel@tonic-gate  * zone.
45277c478bd9Sstevel@tonic-gate  */
45287c478bd9Sstevel@tonic-gate static int
45297c478bd9Sstevel@tonic-gate audit_put_record(int pass_fail, int status, char *msg)
45307c478bd9Sstevel@tonic-gate {
45317c478bd9Sstevel@tonic-gate 	adt_session_data_t	*ah;
45327c478bd9Sstevel@tonic-gate 	adt_event_data_t	*event;
45337c478bd9Sstevel@tonic-gate 
45347c478bd9Sstevel@tonic-gate 	if (!adt_audit_enabled())
45357c478bd9Sstevel@tonic-gate 		return (0);
45367c478bd9Sstevel@tonic-gate 
45377c478bd9Sstevel@tonic-gate 	/*
45387c478bd9Sstevel@tonic-gate 	 * the PROC_DATA picks up the context to tell whether this is
45397c478bd9Sstevel@tonic-gate 	 * an attributed record (auid = -2 is unattributed)
45407c478bd9Sstevel@tonic-gate 	 */
45417c478bd9Sstevel@tonic-gate 	if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA)) {
45427c478bd9Sstevel@tonic-gate 		console(B_TRUE, "audit failure:  %s\n", strerror(errno));
45437c478bd9Sstevel@tonic-gate 		return (1);
45447c478bd9Sstevel@tonic-gate 	}
45457c478bd9Sstevel@tonic-gate 	event = adt_alloc_event(ah, ADT_init_solaris);
45467c478bd9Sstevel@tonic-gate 	if (event == NULL) {
45477c478bd9Sstevel@tonic-gate 		console(B_TRUE, "audit failure:  %s\n", strerror(errno));
45487c478bd9Sstevel@tonic-gate 		(void) adt_end_session(ah);
45497c478bd9Sstevel@tonic-gate 		return (1);
45507c478bd9Sstevel@tonic-gate 	}
45517c478bd9Sstevel@tonic-gate 	event->adt_init_solaris.info = msg;	/* NULL is ok here */
45527c478bd9Sstevel@tonic-gate 
45537c478bd9Sstevel@tonic-gate 	if (adt_put_event(event, pass_fail, status)) {
45547c478bd9Sstevel@tonic-gate 		console(B_TRUE, "audit failure:  %s\n", strerror(errno));
45557c478bd9Sstevel@tonic-gate 		(void) adt_end_session(ah);
45567c478bd9Sstevel@tonic-gate 		return (1);
45577c478bd9Sstevel@tonic-gate 	}
45587c478bd9Sstevel@tonic-gate 	adt_free_event(event);
45597c478bd9Sstevel@tonic-gate 
45607c478bd9Sstevel@tonic-gate 	(void) adt_end_session(ah);
45617c478bd9Sstevel@tonic-gate 
45627c478bd9Sstevel@tonic-gate 	return (1);
45637c478bd9Sstevel@tonic-gate }
4564