1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2013 Gary Mills
24 *
25 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
26 */
27
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
30
31 /*
32 * University Copyright- Copyright (c) 1982, 1986, 1988
33 * The Regents of the University of California
34 * All Rights Reserved
35 *
36 * University Acknowledgment- Portions of this document are derived from
37 * software developed by the University of California, Berkeley, and its
38 * contributors.
39 */
40
41 /*
42 * init(1M) is the general process spawning program. Its primary job is to
43 * start and restart svc.startd for smf(5). For backwards-compatibility it also
44 * spawns and respawns processes according to /etc/inittab and the current
45 * run-level. It reads /etc/default/inittab for general configuration.
46 *
47 * To change run-levels the system administrator runs init from the command
48 * line with a level name. init signals svc.startd via libscf and directs the
49 * zone's init (pid 1 in the global zone) what to do by sending it a signal;
50 * these signal numbers are commonly refered to in the code as 'states'. Valid
51 * run-levels are [sS0123456]. Additionally, init can be given directives
52 * [qQabc], which indicate actions to be taken pertaining to /etc/inittab.
53 *
54 * When init processes inittab entries, it finds processes that are to be
55 * spawned at various run-levels. inittab contains the set of the levels for
56 * which each inittab entry is valid.
57 *
58 * State File and Restartability
59 * Premature exit by init(1M) is handled as a special case by the kernel:
60 * init(1M) will be immediately re-executed, retaining its original PID. (PID
61 * 1 in the global zone.) To track the processes it has previously spawned,
62 * as well as other mutable state, init(1M) regularly updates a state file
63 * such that its subsequent invocations have knowledge of its various
64 * dependent processes and duties.
65 *
66 * Process Contracts
67 * We start svc.startd(1M) in a contract and transfer inherited contracts when
68 * restarting it. Everything else is started using the legacy contract
69 * template, and the created contracts are abandoned when they become empty.
70 *
71 * utmpx Entry Handling
72 * Because init(1M) no longer governs the startup process, its knowledge of
73 * when utmpx becomes writable is indirect. However, spawned processes
74 * expect to be constructed with valid utmpx entries. As a result, attempts
75 * to write normal entries will be retried until successful.
76 *
77 * Maintenance Mode
78 * In certain failure scenarios, init(1M) will enter a maintenance mode, in
79 * which it invokes sulogin(1M) to allow the operator an opportunity to
80 * repair the system. Normally, this operation is performed as a
81 * fork(2)-exec(2)-waitpid(3C) sequence with the parent waiting for repair or
82 * diagnosis to be completed. In the cases that fork(2) requests themselves
83 * fail, init(1M) will directly execute sulogin(1M), and allow the kernel to
84 * restart init(1M) on exit from the operator session.
85 *
86 * One scenario where init(1M) enters its maintenance mode is when
87 * svc.startd(1M) begins to fail rapidly, defined as when the average time
88 * between recent failures drops below a given threshold.
89 */
90
91 #include <sys/contract/process.h>
92 #include <sys/ctfs.h>
93 #include <sys/stat.h>
94 #include <sys/statvfs.h>
95 #include <sys/stropts.h>
96 #include <sys/systeminfo.h>
97 #include <sys/time.h>
98 #include <sys/termios.h>
99 #include <sys/tty.h>
100 #include <sys/types.h>
101 #include <sys/utsname.h>
102
103 #include <bsm/adt_event.h>
104 #include <bsm/libbsm.h>
105 #include <security/pam_appl.h>
106
107 #include <assert.h>
108 #include <ctype.h>
109 #include <dirent.h>
110 #include <errno.h>
111 #include <fcntl.h>
112 #include <libcontract.h>
113 #include <libcontract_priv.h>
114 #include <libintl.h>
115 #include <libscf.h>
116 #include <libscf_priv.h>
117 #include <poll.h>
118 #include <procfs.h>
119 #include <signal.h>
120 #include <stdarg.h>
121 #include <stdio.h>
122 #include <stdio_ext.h>
123 #include <stdlib.h>
124 #include <string.h>
125 #include <strings.h>
126 #include <syslog.h>
127 #include <time.h>
128 #include <ulimit.h>
129 #include <unistd.h>
130 #include <utmpx.h>
131 #include <wait.h>
132 #include <zone.h>
133 #include <ucontext.h>
134
135 #undef sleep
136
137 #define fioctl(p, sptr, cmd) ioctl(fileno(p), sptr, cmd)
138 #define min(a, b) (((a) < (b)) ? (a) : (b))
139
140 #define TRUE 1
141 #define FALSE 0
142 #define FAILURE -1
143
144 #define UT_USER_SZ 32 /* Size of a utmpx ut_user field */
145 #define UT_LINE_SZ 32 /* Size of a utmpx ut_line field */
146
147 /*
148 * SLEEPTIME The number of seconds "init" sleeps between wakeups if
149 * nothing else requires this "init" wakeup.
150 */
151 #define SLEEPTIME (5 * 60)
152
153 /*
154 * MAXCMDL The maximum length of a command string in inittab.
155 */
156 #define MAXCMDL 512
157
158 /*
159 * EXEC The length of the prefix string added to all comamnds
160 * found in inittab.
161 */
162 #define EXEC (sizeof ("exec ") - 1)
163
164 /*
165 * TWARN The amount of time between warning signal, SIGTERM,
166 * and the fatal kill signal, SIGKILL.
167 */
168 #define TWARN 5
169
170 #define id_eq(x, y) ((x[0] == y[0] && x[1] == y[1] && x[2] == y[2] &&\
171 x[3] == y[3]) ? TRUE : FALSE)
172
173 /*
174 * The kernel's default umask is 022 these days; since some processes inherit
175 * their umask from init, init will set it from CMASK in /etc/default/init.
176 * init gets the default umask from the kernel, it sets it to 022 whenever
177 * it wants to create a file and reverts to CMASK afterwards.
178 */
179
180 static int cmask;
181
182 /*
183 * The following definitions, concluding with the 'lvls' array, provide a
184 * common mapping between level-name (like 'S'), signal number (state),
185 * run-level mask, and specific properties associated with a run-level.
186 * This array should be accessed using the routines lvlname_to_state(),
187 * lvlname_to_mask(), state_to_mask(), and state_to_flags().
188 */
189
190 /*
191 * Correspondence of signals to init actions.
192 */
193 #define LVLQ SIGHUP
194 #define LVL0 SIGINT
195 #define LVL1 SIGQUIT
196 #define LVL2 SIGILL
197 #define LVL3 SIGTRAP
198 #define LVL4 SIGIOT
199 #define LVL5 SIGEMT
200 #define LVL6 SIGFPE
201 #define SINGLE_USER SIGBUS
202 #define LVLa SIGSEGV
203 #define LVLb SIGSYS
204 #define LVLc SIGPIPE
205
206 /*
207 * Bit Mask for each level. Used to determine legal levels.
208 */
209 #define MASK0 0x0001
210 #define MASK1 0x0002
211 #define MASK2 0x0004
212 #define MASK3 0x0008
213 #define MASK4 0x0010
214 #define MASK5 0x0020
215 #define MASK6 0x0040
216 #define MASKSU 0x0080
217 #define MASKa 0x0100
218 #define MASKb 0x0200
219 #define MASKc 0x0400
220
221 #define MASK_NUMERIC (MASK0 | MASK1 | MASK2 | MASK3 | MASK4 | MASK5 | MASK6)
222 #define MASK_abc (MASKa | MASKb | MASKc)
223
224 /*
225 * Flags to indicate properties of various states.
226 */
227 #define LSEL_RUNLEVEL 0x0001 /* runlevels you can transition to */
228
229 typedef struct lvl {
230 int lvl_state;
231 int lvl_mask;
232 char lvl_name;
233 int lvl_flags;
234 } lvl_t;
235
236 static lvl_t lvls[] = {
237 { LVLQ, 0, 'Q', 0 },
238 { LVLQ, 0, 'q', 0 },
239 { LVL0, MASK0, '0', LSEL_RUNLEVEL },
240 { LVL1, MASK1, '1', LSEL_RUNLEVEL },
241 { LVL2, MASK2, '2', LSEL_RUNLEVEL },
242 { LVL3, MASK3, '3', LSEL_RUNLEVEL },
243 { LVL4, MASK4, '4', LSEL_RUNLEVEL },
244 { LVL5, MASK5, '5', LSEL_RUNLEVEL },
245 { LVL6, MASK6, '6', LSEL_RUNLEVEL },
246 { SINGLE_USER, MASKSU, 'S', LSEL_RUNLEVEL },
247 { SINGLE_USER, MASKSU, 's', LSEL_RUNLEVEL },
248 { LVLa, MASKa, 'a', 0 },
249 { LVLb, MASKb, 'b', 0 },
250 { LVLc, MASKc, 'c', 0 }
251 };
252
253 #define LVL_NELEMS (sizeof (lvls) / sizeof (lvl_t))
254
255 /*
256 * Legal action field values.
257 */
258 #define OFF 0 /* Kill process if on, else ignore */
259 #define RESPAWN 1 /* Continuously restart process when it dies */
260 #define ONDEMAND RESPAWN /* Respawn for a, b, c type processes */
261 #define ONCE 2 /* Start process, do not respawn when dead */
262 #define WAIT 3 /* Perform once and wait to complete */
263 #define BOOT 4 /* Start at boot time only */
264 #define BOOTWAIT 5 /* Start at boot time and wait to complete */
265 #define POWERFAIL 6 /* Start on powerfail */
266 #define POWERWAIT 7 /* Start and wait for complete on powerfail */
267 #define INITDEFAULT 8 /* Default level "init" should start at */
268 #define SYSINIT 9 /* Actions performed before init speaks */
269
270 #define M_OFF 0001
271 #define M_RESPAWN 0002
272 #define M_ONDEMAND M_RESPAWN
273 #define M_ONCE 0004
274 #define M_WAIT 0010
275 #define M_BOOT 0020
276 #define M_BOOTWAIT 0040
277 #define M_PF 0100
278 #define M_PWAIT 0200
279 #define M_INITDEFAULT 0400
280 #define M_SYSINIT 01000
281
282 /* States for the inittab parser in getcmd(). */
283 #define ID 1
284 #define LEVELS 2
285 #define ACTION 3
286 #define COMMAND 4
287 #define COMMENT 5
288
289 /*
290 * inittab entry id constants
291 */
292 #define INITTAB_ENTRY_ID_SIZE 4
293 #define INITTAB_ENTRY_ID_STR_FORMAT "%.4s" /* if INITTAB_ENTRY_ID_SIZE */
294 /* changes, this should */
295 /* change accordingly */
296
297 /*
298 * Init can be in any of three main states, "normal" mode where it is
299 * processing entries for the lines file in a normal fashion, "boot" mode,
300 * where it is only interested in the boot actions, and "powerfail" mode,
301 * where it is only interested in powerfail related actions. The following
302 * masks declare the legal actions for each mode.
303 */
304 #define NORMAL_MODES (M_OFF | M_RESPAWN | M_ONCE | M_WAIT)
305 #define BOOT_MODES (M_BOOT | M_BOOTWAIT)
306 #define PF_MODES (M_PF | M_PWAIT)
307
308 struct PROC_TABLE {
309 char p_id[INITTAB_ENTRY_ID_SIZE]; /* Four letter unique id of */
310 /* process */
311 pid_t p_pid; /* Process id */
312 short p_count; /* How many respawns of this command in */
313 /* the current series */
314 long p_time; /* Start time for a series of respawns */
315 short p_flags;
316 short p_exit; /* Exit status of a process which died */
317 };
318
319 /*
320 * Flags for the "p_flags" word of a PROC_TABLE entry:
321 *
322 * OCCUPIED This slot in init's proc table is in use.
323 *
324 * LIVING Process is alive.
325 *
326 * NOCLEANUP efork() is not allowed to cleanup this entry even
327 * if process is dead.
328 *
329 * NAMED This process has a name, i.e. came from inittab.
330 *
331 * DEMANDREQUEST Process started by a "telinit [abc]" command. Processes
332 * formed this way are respawnable and immune to level
333 * changes as long as their entry exists in inittab.
334 *
335 * TOUCHED Flag used by remv() to determine whether it has looked
336 * at an entry while checking for processes to be killed.
337 *
338 * WARNED Flag used by remv() to mark processes that have been
339 * sent the SIGTERM signal. If they don't die in 5
340 * seconds, they are sent the SIGKILL signal.
341 *
342 * KILLED Flag used by remv() to mark procs that have been sent
343 * the SIGTERM and SIGKILL signals.
344 *
345 * PF_MASK Bitwise or of legal flags, for sanity checking.
346 */
347 #define OCCUPIED 01
348 #define LIVING 02
349 #define NOCLEANUP 04
350 #define NAMED 010
351 #define DEMANDREQUEST 020
352 #define TOUCHED 040
353 #define WARNED 0100
354 #define KILLED 0200
355 #define PF_MASK 0377
356
357 /*
358 * Respawn limits for processes that are to be respawned:
359 *
360 * SPAWN_INTERVAL The number of seconds over which "init" will try to
361 * respawn a process SPAWN_LIMIT times before it gets mad.
362 *
363 * SPAWN_LIMIT The number of respawns "init" will attempt in
364 * SPAWN_INTERVAL seconds before it generates an
365 * error message and inhibits further tries for
366 * INHIBIT seconds.
367 *
368 * INHIBIT The number of seconds "init" ignores an entry it had
369 * trouble spawning unless a "telinit Q" is received.
370 */
371
372 #define SPAWN_INTERVAL (2*60)
373 #define SPAWN_LIMIT 10
374 #define INHIBIT (5*60)
375
376 /*
377 * The maximum number of decimal digits for an id_t. (ceil(log10 (max_id)))
378 */
379 #define ID_MAX_STR_LEN 10
380
381 #define NULLPROC ((struct PROC_TABLE *)(0))
382 #define NO_ROOM ((struct PROC_TABLE *)(FAILURE))
383
384 struct CMD_LINE {
385 char c_id[INITTAB_ENTRY_ID_SIZE]; /* Four letter unique id of */
386 /* process to be affected by */
387 /* action */
388 short c_levels; /* Mask of legal levels for process */
389 short c_action; /* Mask for type of action required */
390 char *c_command; /* Pointer to init command */
391 };
392
393 struct pidrec {
394 int pd_type; /* Command type */
395 pid_t pd_pid; /* pid to add or remove */
396 };
397
398 /*
399 * pd_type's
400 */
401 #define ADDPID 1
402 #define REMPID 2
403
404 static struct pidlist {
405 pid_t pl_pid; /* pid to watch for */
406 int pl_dflag; /* Flag indicating SIGCLD from this pid */
407 short pl_exit; /* Exit status of proc */
408 struct pidlist *pl_next; /* Next in list */
409 } *Plhead, *Plfree;
410
411 /*
412 * The following structure contains a set of modes for /dev/syscon
413 * and should match the default contents of /etc/ioctl.syscon. It should also
414 * be kept in-sync with base_termios in uts/common/io/ttcompat.c.
415 */
416 static struct termios dflt_termios = {
417 BRKINT|ICRNL|IXON|IMAXBEL, /* iflag */
418 OPOST|ONLCR|TAB3, /* oflag */
419 CS8|CREAD|B9600, /* cflag */
420 ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN, /* lflag */
421 CINTR, CQUIT, CERASE, CKILL, CEOF, 0, 0, 0,
422 0, 0, 0, 0, 0, 0, 0, 0,
423 0, 0, 0
424 };
425
426 static struct termios stored_syscon_termios;
427 static int write_ioctl = 0; /* Rewrite /etc/ioctl.syscon */
428
429 static union WAKEUP {
430 struct WAKEFLAGS {
431 unsigned w_usersignal : 1; /* User sent signal to "init" */
432 unsigned w_childdeath : 1; /* An "init" child died */
433 unsigned w_powerhit : 1; /* OS experienced powerfail */
434 } w_flags;
435 int w_mask;
436 } wakeup;
437
438
439 struct init_state {
440 int ist_runlevel;
441 int ist_num_proc;
442 int ist_utmpx_ok;
443 struct PROC_TABLE ist_proc_table[1];
444 };
445
446 #define cur_state (g_state->ist_runlevel)
447 #define num_proc (g_state->ist_num_proc)
448 #define proc_table (g_state->ist_proc_table)
449 #define utmpx_ok (g_state->ist_utmpx_ok)
450
451 /* Contract cookies. */
452 #define ORDINARY_COOKIE 0
453 #define STARTD_COOKIE 1
454
455
456 #ifndef NDEBUG
457 #define bad_error(func, err) { \
458 (void) fprintf(stderr, "%s:%d: %s() failed with unexpected " \
459 "error %d. Aborting.\n", __FILE__, __LINE__, (func), (err)); \
460 abort(); \
461 }
462 #else
463 #define bad_error(func, err) abort()
464 #endif
465
466
467 /*
468 * Useful file and device names.
469 */
470 static char *CONSOLE = "/dev/console"; /* Real system console */
471 static char *INITPIPE_DIR = "/var/run";
472 static char *INITPIPE = "/var/run/initpipe";
473
474 #define INIT_STATE_DIR "/etc/svc/volatile"
475 static const char * const init_state_file = INIT_STATE_DIR "/init.state";
476 static const char * const init_next_state_file =
477 INIT_STATE_DIR "/init-next.state";
478
479 static const int init_num_proc = 20; /* Initial size of process table. */
480
481 static char *UTMPX = UTMPX_FILE; /* Snapshot record file */
482 static char *WTMPX = WTMPX_FILE; /* Long term record file */
483 static char *INITTAB = "/etc/inittab"; /* Script file for "init" */
484 static char *SYSTTY = "/dev/systty"; /* System Console */
485 static char *SYSCON = "/dev/syscon"; /* Virtual System console */
486 static char *IOCTLSYSCON = "/etc/ioctl.syscon"; /* Last syscon modes */
487 static char *ENVFILE = "/etc/default/init"; /* Default env. */
488 static char *SU = "/etc/sulogin"; /* Super-user program for single user */
489 static char *SH = "/sbin/sh"; /* Standard shell */
490
491 /*
492 * Default Path. /sbin is included in path only during sysinit phase
493 */
494 #define DEF_PATH "PATH=/usr/sbin:/usr/bin"
495 #define INIT_PATH "PATH=/sbin:/usr/sbin:/usr/bin"
496
497 static int prior_state;
498 static int prev_state; /* State "init" was in last time it woke */
499 static int new_state; /* State user wants "init" to go to. */
500 static int lvlq_received; /* Explicit request to examine state */
501 static int op_modes = BOOT_MODES; /* Current state of "init" */
502 static int Gchild = 0; /* Flag to indicate "godchild" died, set in */
503 /* childeath() and cleared in cleanaux() */
504 static int Pfd = -1; /* fd to receive pids thru */
505 static unsigned int spawncnt, pausecnt;
506 static int rsflag; /* Set if a respawn has taken place */
507 static volatile int time_up; /* Flag set to TRUE by the alarm interrupt */
508 /* routine each time an alarm interrupt */
509 /* takes place. */
510 static int sflg = 0; /* Set if we were booted -s to single user */
511 static int rflg = 0; /* Set if booted -r, reconfigure devices */
512 static int bflg = 0; /* Set if booted -b, don't run rc scripts */
513 static pid_t init_pid; /* PID of "one true" init for current zone */
514
515 static struct init_state *g_state = NULL;
516 static size_t g_state_sz;
517 static int booting = 1; /* Set while we're booting. */
518
519 /*
520 * Array for default global environment.
521 */
522 #define MAXENVENT 24 /* Max number of default env variables + 1 */
523 /* init can use three itself, so this leaves */
524 /* 20 for the administrator in ENVFILE. */
525 static char *glob_envp[MAXENVENT]; /* Array of environment strings */
526 static int glob_envn; /* Number of environment strings */
527
528
529 static struct pollfd poll_fds[1];
530 static int poll_nfds = 0; /* poll_fds is uninitialized */
531
532 /*
533 * Contracts constants
534 */
535 #define SVC_INIT_PREFIX "init:/"
536 #define SVC_AUX_SIZE (INITTAB_ENTRY_ID_SIZE + 1)
537 #define SVC_FMRI_SIZE (sizeof (SVC_INIT_PREFIX) + INITTAB_ENTRY_ID_SIZE)
538
539 static int legacy_tmpl = -1; /* fd for legacy contract template */
540 static int startd_tmpl = -1; /* fd for svc.startd's template */
541 static char startd_svc_aux[SVC_AUX_SIZE];
542
543 static char startd_cline[256] = ""; /* svc.startd's command line */
544 static int do_restart_startd = 1; /* Whether to restart svc.startd. */
545 static char *smf_options = NULL; /* Options to give to startd. */
546 static int smf_debug = 0; /* Messages for debugging smf(5) */
547 static time_t init_boot_time; /* Substitute for kernel boot time. */
548
549 #define NSTARTD_FAILURE_TIMES 3 /* trigger after 3 failures */
550 #define STARTD_FAILURE_RATE_NS 5000000000LL /* 1 failure/5 seconds */
551
552 static hrtime_t startd_failure_time[NSTARTD_FAILURE_TIMES];
553 static uint_t startd_failure_index;
554
555
556 static char *prog_name(char *);
557 static int state_to_mask(int);
558 static int lvlname_to_mask(char, int *);
559 static void lscf_set_runlevel(char);
560 static int state_to_flags(int);
561 static char state_to_name(int);
562 static int lvlname_to_state(char);
563 static int getcmd(struct CMD_LINE *, char *);
564 static int realcon();
565 static int spawn_processes();
566 static int get_ioctl_syscon();
567 static int account(short, struct PROC_TABLE *, char *);
568 static void alarmclk();
569 static void childeath(int);
570 static void cleanaux();
571 static void clearent(pid_t, short);
572 static void console(boolean_t, char *, ...);
573 static void init_signals(void);
574 static void setup_pipe();
575 static void killproc(pid_t);
576 static void init_env();
577 static void boot_init();
578 static void powerfail();
579 static void remv();
580 static void write_ioctl_syscon();
581 static void spawn(struct PROC_TABLE *, struct CMD_LINE *);
582 static void setimer(int);
583 static void siglvl(int, siginfo_t *, ucontext_t *);
584 static void sigpoll(int);
585 static void enter_maintenance(void);
586 static void timer(int);
587 static void userinit(int, char **);
588 static void notify_pam_dead(struct utmpx *);
589 static long waitproc(struct PROC_TABLE *);
590 static struct PROC_TABLE *efork(int, struct PROC_TABLE *, int);
591 static struct PROC_TABLE *findpslot(struct CMD_LINE *);
592 static void increase_proc_table_size();
593 static void st_init();
594 static void st_write();
595 static void contracts_init();
596 static void contract_event(struct pollfd *);
597 static int startd_run(const char *, int, ctid_t);
598 static void startd_record_failure();
599 static int startd_failure_rate_critical();
600 static char *audit_boot_msg();
601 static int audit_put_record(int, int, char *);
602 static void update_boot_archive(int new_state);
603
604 int
605 main(int argc, char *argv[])
606 {
607 int chg_lvl_flag = FALSE, print_banner = FALSE;
608 int may_need_audit = 1;
609 int c;
610 char *msg;
611
612 /* Get a timestamp for use as boot time, if needed. */
613 (void) time(&init_boot_time);
614
615 /* Get the default umask */
616 cmask = umask(022);
617 (void) umask(cmask);
618
619 /* Parse the arguments to init. Check for single user */
620 opterr = 0;
621 while ((c = getopt(argc, argv, "brsm:")) != EOF) {
622 switch (c) {
623 case 'b':
624 rflg = 0;
625 bflg = 1;
626 if (!sflg)
627 sflg++;
628 break;
629 case 'r':
630 bflg = 0;
631 rflg++;
632 break;
633 case 's':
634 if (!bflg)
635 sflg++;
636 break;
637 case 'm':
638 smf_options = optarg;
639 smf_debug = (strstr(smf_options, "debug") != NULL);
640 break;
641 }
642 }
643
644 /*
645 * Determine if we are the main init, or a user invoked init, whose job
646 * it is to inform init to change levels or perform some other action.
647 */
648 if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
649 sizeof (init_pid)) != sizeof (init_pid)) {
650 (void) fprintf(stderr, "could not get pid for init\n");
651 return (1);
652 }
653
654 /*
655 * If this PID is not the same as the "true" init for the zone, then we
656 * must be in 'user' mode.
657 */
658 if (getpid() != init_pid) {
659 userinit(argc, argv);
660 }
661
662 if (getzoneid() != GLOBAL_ZONEID) {
663 print_banner = TRUE;
664 }
665
666 /*
667 * Initialize state (and set "booting").
668 */
669 st_init();
670
671 if (booting && print_banner) {
672 struct utsname un;
673 char buf[BUFSIZ], *isa;
674 long ret;
675 int bits = 32;
676
677 /*
678 * We want to print the boot banner as soon as
679 * possible. In the global zone, the kernel does it,
680 * but we do not have that luxury in non-global zones,
681 * so we will print it here.
682 */
683 (void) uname(&un);
684 ret = sysinfo(SI_ISALIST, buf, sizeof (buf));
685 if (ret != -1L && ret <= sizeof (buf)) {
686 for (isa = strtok(buf, " "); isa;
687 isa = strtok(NULL, " ")) {
688 if (strcmp(isa, "sparcv9") == 0 ||
689 strcmp(isa, "amd64") == 0) {
690 bits = 64;
691 break;
692 }
693 }
694 }
695
696 console(B_FALSE,
697 "\n\n%s Release %s Version %s %d-bit\r\n",
698 un.sysname, un.release, un.version, bits);
699 console(B_FALSE,
700 "Copyright (c) 1983, 2010, Oracle and/or its affiliates."
701 " All rights reserved.\r\n");
702 }
703
704 /*
705 * Get the ioctl settings for /dev/syscon from /etc/ioctl.syscon
706 * so that it can be brought up in the state it was in when the
707 * system went down; or set to defaults if ioctl.syscon isn't
708 * valid.
709 *
710 * This needs to be done even if we're restarting so reset_modes()
711 * will work in case we need to go down to single user mode.
712 */
713 write_ioctl = get_ioctl_syscon();
714
715 /*
716 * Set up all signals to be caught or ignored as appropriate.
717 */
718 init_signals();
719
720 /* Load glob_envp from ENVFILE. */
721 init_env();
722
723 contracts_init();
724
725 if (!booting) {
726 /* cur_state should have been read in. */
727
728 op_modes = NORMAL_MODES;
729
730 /* Rewrite the ioctl file if it was bad. */
731 if (write_ioctl)
732 write_ioctl_syscon();
733 } else {
734 /*
735 * It's fine to boot up with state as zero, because
736 * startd will later tell us the real state.
737 */
738 cur_state = 0;
739 op_modes = BOOT_MODES;
740
741 boot_init();
742 }
743
744 prev_state = prior_state = cur_state;
745
746 setup_pipe();
747
748 /*
749 * Here is the beginning of the main process loop.
750 */
751 for (;;) {
752 if (lvlq_received) {
753 setup_pipe();
754 lvlq_received = B_FALSE;
755 }
756
757 /*
758 * Clean up any accounting records for dead "godchildren".
759 */
760 if (Gchild)
761 cleanaux();
762
763 /*
764 * If in "normal" mode, check all living processes and initiate
765 * kill sequence on those that should not be there anymore.
766 */
767 if (op_modes == NORMAL_MODES && cur_state != LVLa &&
768 cur_state != LVLb && cur_state != LVLc)
769 remv();
770
771 /*
772 * If a change in run levels is the reason we awoke, now do
773 * the accounting to report the change in the utmp file.
774 * Also report the change on the system console.
775 */
776 if (chg_lvl_flag) {
777 chg_lvl_flag = FALSE;
778
779 if (state_to_flags(cur_state) & LSEL_RUNLEVEL) {
780 char rl = state_to_name(cur_state);
781
782 if (rl != -1)
783 lscf_set_runlevel(rl);
784 }
785
786 may_need_audit = 1;
787 }
788
789 /*
790 * Scan the inittab file and spawn and respawn processes that
791 * should be alive in the current state. If inittab does not
792 * exist default to single user mode.
793 */
794 if (spawn_processes() == FAILURE) {
795 prior_state = prev_state;
796 cur_state = SINGLE_USER;
797 }
798
799 /* If any respawns occurred, take note. */
800 if (rsflag) {
801 rsflag = 0;
802 spawncnt++;
803 }
804
805 /*
806 * If a powerfail signal was received during the last
807 * sequence, set mode to powerfail. When spawn_processes() is
808 * entered the first thing it does is to check "powerhit". If
809 * it is in PF_MODES then it clears "powerhit" and does
810 * a powerfail sequence. If it is not in PF_MODES, then it
811 * puts itself in PF_MODES and then clears "powerhit". Should
812 * "powerhit" get set again while spawn_processes() is working
813 * on a powerfail sequence, the following code will see that
814 * spawn_processes() tries to execute the powerfail sequence
815 * again. This guarantees that the powerfail sequence will be
816 * successfully completed before further processing takes
817 * place.
818 */
819 if (wakeup.w_flags.w_powerhit) {
820 op_modes = PF_MODES;
821 /*
822 * Make sure that cur_state != prev_state so that
823 * ONCE and WAIT types work.
824 */
825 prev_state = 0;
826 } else if (op_modes != NORMAL_MODES) {
827 /*
828 * If spawn_processes() was not just called while in
829 * normal mode, we set the mode to normal and it will
830 * be called again to check normal modes. If we have
831 * just finished a powerfail sequence with prev_state
832 * equal to zero, we set prev_state equal to cur_state
833 * before the next pass through.
834 */
835 if (op_modes == PF_MODES)
836 prev_state = cur_state;
837 op_modes = NORMAL_MODES;
838 } else if (cur_state == LVLa || cur_state == LVLb ||
839 cur_state == LVLc) {
840 /*
841 * If it was a change of levels that awakened us and the
842 * new level is one of the demand levels then reset
843 * cur_state to the previous state and do another scan
844 * to take care of the usual respawn actions.
845 */
846 cur_state = prior_state;
847 prior_state = prev_state;
848 prev_state = cur_state;
849 } else {
850 prev_state = cur_state;
851
852 if (wakeup.w_mask == 0) {
853 int ret;
854
855 if (may_need_audit && (cur_state == LVL3)) {
856 msg = audit_boot_msg();
857
858 may_need_audit = 0;
859 (void) audit_put_record(ADT_SUCCESS,
860 ADT_SUCCESS, msg);
861 free(msg);
862 }
863
864 /*
865 * "init" is finished with all actions for
866 * the current wakeup.
867 */
868 ret = poll(poll_fds, poll_nfds,
869 SLEEPTIME * MILLISEC);
870 pausecnt++;
871 if (ret > 0)
872 contract_event(&poll_fds[0]);
873 else if (ret < 0 && errno != EINTR)
874 console(B_TRUE, "poll() error: %s\n",
875 strerror(errno));
876 }
877
878 if (wakeup.w_flags.w_usersignal) {
879 /*
880 * Install the new level. This could be a real
881 * change in levels or a telinit [Q|a|b|c] or
882 * just a telinit to the same level at which
883 * we are running.
884 */
885 if (new_state != cur_state) {
886 if (new_state == LVLa ||
887 new_state == LVLb ||
888 new_state == LVLc) {
889 prev_state = prior_state;
890 prior_state = cur_state;
891 cur_state = new_state;
892 } else {
893 prev_state = cur_state;
894 if (cur_state >= 0)
895 prior_state = cur_state;
896 cur_state = new_state;
897 chg_lvl_flag = TRUE;
898 }
899 }
900
901 new_state = 0;
902 }
903
904 if (wakeup.w_flags.w_powerhit)
905 op_modes = PF_MODES;
906
907 /*
908 * Clear all wakeup reasons.
909 */
910 wakeup.w_mask = 0;
911 }
912 }
913
914 /*NOTREACHED*/
915 }
916
917 static void
918 update_boot_archive(int new_state)
919 {
920 if (new_state != LVL0 && new_state != LVL5 && new_state != LVL6)
921 return;
922
923 if (getzoneid() != GLOBAL_ZONEID)
924 return;
925
926 (void) system("/sbin/bootadm -ea update_all");
927 }
928
929 /*
930 * void enter_maintenance()
931 * A simple invocation of sulogin(1M), with no baggage, in the case that we
932 * are unable to activate svc.startd(1M). We fork; the child runs sulogin;
933 * we wait for it to exit.
934 */
935 static void
936 enter_maintenance()
937 {
938 struct PROC_TABLE *su_process;
939
940 console(B_FALSE, "Requesting maintenance mode\n"
941 "(See /lib/svc/share/README for additional information.)\n");
942 (void) sighold(SIGCLD);
943 while ((su_process = efork(M_OFF, NULLPROC, NOCLEANUP)) == NO_ROOM)
944 (void) pause();
945 (void) sigrelse(SIGCLD);
946 if (su_process == NULLPROC) {
947 int fd;
948
949 (void) fclose(stdin);
950 (void) fclose(stdout);
951 (void) fclose(stderr);
952 closefrom(0);
953
954 fd = open(SYSCON, O_RDWR | O_NOCTTY);
955 if (fd >= 0) {
956 (void) dup2(fd, 1);
957 (void) dup2(fd, 2);
958 } else {
959 /*
960 * Need to issue an error message somewhere.
961 */
962 syslog(LOG_CRIT, "init[%d]: cannot open %s; %s\n",
963 getpid(), SYSCON, strerror(errno));
964 }
965
966 /*
967 * Execute the "su" program.
968 */
969 (void) execle(SU, SU, "-", (char *)0, glob_envp);
970 console(B_TRUE, "execle of %s failed: %s\n", SU,
971 strerror(errno));
972 timer(5);
973 exit(1);
974 }
975
976 /*
977 * If we are the parent, wait around for the child to die
978 * or for "init" to be signaled to change levels.
979 */
980 while (waitproc(su_process) == FAILURE) {
981 /*
982 * All other reasons for waking are ignored when in
983 * single-user mode. The only child we are interested
984 * in is being waited for explicitly by waitproc().
985 */
986 wakeup.w_mask = 0;
987 }
988 }
989
990 /*
991 * remv() scans through "proc_table" and performs cleanup. If
992 * there is a process in the table, which shouldn't be here at
993 * the current run level, then remv() kills the process.
994 */
995 static void
996 remv()
997 {
998 struct PROC_TABLE *process;
999 struct CMD_LINE cmd;
1000 char cmd_string[MAXCMDL];
1001 int change_level;
1002
1003 change_level = (cur_state != prev_state ? TRUE : FALSE);
1004
1005 /*
1006 * Clear the TOUCHED flag on all entries so that when we have
1007 * finished scanning inittab, we will be able to tell if we
1008 * have any processes for which there is no entry in inittab.
1009 */
1010 for (process = proc_table;
1011 (process < proc_table + num_proc); process++) {
1012 process->p_flags &= ~TOUCHED;
1013 }
1014
1015 /*
1016 * Scan all inittab entries.
1017 */
1018 while (getcmd(&cmd, &cmd_string[0]) == TRUE) {
1019 /* Scan for process which goes with this entry in inittab. */
1020 for (process = proc_table;
1021 (process < proc_table + num_proc); process++) {
1022 if ((process->p_flags & OCCUPIED) == 0 ||
1023 !id_eq(process->p_id, cmd.c_id))
1024 continue;
1025
1026 /*
1027 * This slot contains the process we are looking for.
1028 */
1029
1030 /*
1031 * Is the cur_state SINGLE_USER or is this process
1032 * marked as "off" or was this proc started by some
1033 * mechanism other than LVL{a|b|c} and the current level
1034 * does not support this process?
1035 */
1036 if (cur_state == SINGLE_USER ||
1037 cmd.c_action == M_OFF ||
1038 ((cmd.c_levels & state_to_mask(cur_state)) == 0 &&
1039 (process->p_flags & DEMANDREQUEST) == 0)) {
1040 if (process->p_flags & LIVING) {
1041 /*
1042 * Touch this entry so we know we have
1043 * treated it. Note that procs which
1044 * are already dead at this point and
1045 * should not be restarted are left
1046 * untouched. This causes their slot to
1047 * be freed later after dead accounting
1048 * is done.
1049 */
1050 process->p_flags |= TOUCHED;
1051
1052 if ((process->p_flags & KILLED) == 0) {
1053 if (change_level) {
1054 process->p_flags
1055 |= WARNED;
1056 (void) kill(
1057 process->p_pid,
1058 SIGTERM);
1059 } else {
1060 /*
1061 * Fork a killing proc
1062 * so "init" can
1063 * continue without
1064 * having to pause for
1065 * TWARN seconds.
1066 */
1067 killproc(
1068 process->p_pid);
1069 }
1070 process->p_flags |= KILLED;
1071 }
1072 }
1073 } else {
1074 /*
1075 * Process can exist at current level. If it is
1076 * still alive or a DEMANDREQUEST we touch it so
1077 * it will be left alone. Otherwise we leave it
1078 * untouched so it will be accounted for and
1079 * cleaned up later in remv(). Dead
1080 * DEMANDREQUESTs will be accounted but not
1081 * freed.
1082 */
1083 if (process->p_flags &
1084 (LIVING|NOCLEANUP|DEMANDREQUEST))
1085 process->p_flags |= TOUCHED;
1086 }
1087
1088 break;
1089 }
1090 }
1091
1092 st_write();
1093
1094 /*
1095 * If this was a change of levels call, scan through the
1096 * process table for processes that were warned to die. If any
1097 * are found that haven't left yet, sleep for TWARN seconds and
1098 * then send final terminations to any that haven't died yet.
1099 */
1100 if (change_level) {
1101
1102 /*
1103 * Set the alarm for TWARN seconds on the assumption
1104 * that there will be some that need to be waited for.
1105 * This won't harm anything except we are guaranteed to
1106 * wakeup in TWARN seconds whether we need to or not.
1107 */
1108 setimer(TWARN);
1109
1110 /*
1111 * Scan for processes which should be dying. We hope they
1112 * will die without having to be sent a SIGKILL signal.
1113 */
1114 for (process = proc_table;
1115 (process < proc_table + num_proc); process++) {
1116 /*
1117 * If this process should die, hasn't yet, and the
1118 * TWARN time hasn't expired yet, wait for process
1119 * to die or for timer to expire.
1120 */
1121 while (time_up == FALSE &&
1122 (process->p_flags & (WARNED|LIVING|OCCUPIED)) ==
1123 (WARNED|LIVING|OCCUPIED))
1124 (void) pause();
1125
1126 if (time_up == TRUE)
1127 break;
1128 }
1129
1130 /*
1131 * If we reached the end of the table without the timer
1132 * expiring, then there are no procs which will have to be
1133 * sent the SIGKILL signal. If the timer has expired, then
1134 * it is necessary to scan the table again and send signals
1135 * to all processes which aren't going away nicely.
1136 */
1137 if (time_up == TRUE) {
1138 for (process = proc_table;
1139 (process < proc_table + num_proc); process++) {
1140 if ((process->p_flags &
1141 (WARNED|LIVING|OCCUPIED)) ==
1142 (WARNED|LIVING|OCCUPIED))
1143 (void) kill(process->p_pid, SIGKILL);
1144 }
1145 }
1146 setimer(0);
1147 }
1148
1149 /*
1150 * Rescan the proc_table for two kinds of entry, those marked LIVING,
1151 * NAMED, which don't have an entry in inittab (haven't been TOUCHED
1152 * by the above scanning), and haven't been sent kill signals, and
1153 * those entries marked not LIVING, NAMED. The former procs are killed.
1154 * The latter have DEAD_PROCESS accounting done and the slot cleared.
1155 */
1156 for (process = proc_table;
1157 (process < proc_table + num_proc); process++) {
1158 if ((process->p_flags & (LIVING|NAMED|TOUCHED|KILLED|OCCUPIED))
1159 == (LIVING|NAMED|OCCUPIED)) {
1160 killproc(process->p_pid);
1161 process->p_flags |= KILLED;
1162 } else if ((process->p_flags & (LIVING|NAMED|OCCUPIED)) ==
1163 (NAMED|OCCUPIED)) {
1164 (void) account(DEAD_PROCESS, process, NULL);
1165 /*
1166 * If this named proc hasn't been TOUCHED, then free the
1167 * space. It has either died of it's own accord, but
1168 * isn't respawnable or it was killed because it
1169 * shouldn't exist at this level.
1170 */
1171 if ((process->p_flags & TOUCHED) == 0)
1172 process->p_flags = 0;
1173 }
1174 }
1175
1176 st_write();
1177 }
1178
1179 /*
1180 * Extract the svc.startd command line and whether to restart it from its
1181 * inittab entry.
1182 */
1183 /*ARGSUSED*/
1184 static void
1185 process_startd_line(struct CMD_LINE *cmd, char *cmd_string)
1186 {
1187 size_t sz;
1188
1189 /* Save the command line. */
1190 if (sflg || rflg) {
1191 /* Also append -r or -s. */
1192 (void) strlcpy(startd_cline, cmd_string, sizeof (startd_cline));
1193 (void) strlcat(startd_cline, " -", sizeof (startd_cline));
1194 if (sflg)
1195 sz = strlcat(startd_cline, "s", sizeof (startd_cline));
1196 if (rflg)
1197 sz = strlcat(startd_cline, "r", sizeof (startd_cline));
1198 } else {
1199 sz = strlcpy(startd_cline, cmd_string, sizeof (startd_cline));
1200 }
1201
1202 if (sz >= sizeof (startd_cline)) {
1203 console(B_TRUE,
1204 "svc.startd command line too long. Ignoring.\n");
1205 startd_cline[0] = '\0';
1206 return;
1207 }
1208 }
1209
1210 /*
1211 * spawn_processes() scans inittab for entries which should be run at this
1212 * mode. Processes which should be running but are not, are started.
1213 */
1214 static int
1215 spawn_processes()
1216 {
1217 struct PROC_TABLE *pp;
1218 struct CMD_LINE cmd;
1219 char cmd_string[MAXCMDL];
1220 short lvl_mask;
1221 int status;
1222
1223 /*
1224 * First check the "powerhit" flag. If it is set, make sure the modes
1225 * are PF_MODES and clear the "powerhit" flag. Avoid the possible race
1226 * on the "powerhit" flag by disallowing a new powerfail interrupt
1227 * between the test of the powerhit flag and the clearing of it.
1228 */
1229 if (wakeup.w_flags.w_powerhit) {
1230 wakeup.w_flags.w_powerhit = 0;
1231 op_modes = PF_MODES;
1232 }
1233 lvl_mask = state_to_mask(cur_state);
1234
1235 /*
1236 * Scan through all the entries in inittab.
1237 */
1238 while ((status = getcmd(&cmd, &cmd_string[0])) == TRUE) {
1239 if (id_eq(cmd.c_id, "smf")) {
1240 process_startd_line(&cmd, cmd_string);
1241 continue;
1242 }
1243
1244 retry_for_proc_slot:
1245
1246 /*
1247 * Find out if there is a process slot for this entry already.
1248 */
1249 if ((pp = findpslot(&cmd)) == NULLPROC) {
1250 /*
1251 * we've run out of proc table entries
1252 * increase proc_table.
1253 */
1254 increase_proc_table_size();
1255
1256 /*
1257 * Retry now as we have an empty proc slot.
1258 * In case increase_proc_table_size() fails,
1259 * we will keep retrying.
1260 */
1261 goto retry_for_proc_slot;
1262 }
1263
1264 /*
1265 * If there is an entry, and it is marked as DEMANDREQUEST,
1266 * one of the levels a, b, or c is in its levels mask, and
1267 * the action field is ONDEMAND and ONDEMAND is a permissable
1268 * mode, and the process is dead, then respawn it.
1269 */
1270 if (((pp->p_flags & (LIVING|DEMANDREQUEST)) == DEMANDREQUEST) &&
1271 (cmd.c_levels & MASK_abc) &&
1272 (cmd.c_action & op_modes) == M_ONDEMAND) {
1273 spawn(pp, &cmd);
1274 continue;
1275 }
1276
1277 /*
1278 * If the action is not an action we are interested in,
1279 * skip the entry.
1280 */
1281 if ((cmd.c_action & op_modes) == 0 || pp->p_flags & LIVING ||
1282 (cmd.c_levels & lvl_mask) == 0)
1283 continue;
1284
1285 /*
1286 * If the modes are the normal modes (ONCE, WAIT, RESPAWN, OFF,
1287 * ONDEMAND) and the action field is either OFF or the action
1288 * field is ONCE or WAIT and the current level is the same as
1289 * the last level, then skip this entry. ONCE and WAIT only
1290 * get run when the level changes.
1291 */
1292 if (op_modes == NORMAL_MODES &&
1293 (cmd.c_action == M_OFF ||
1294 (cmd.c_action & (M_ONCE|M_WAIT)) &&
1295 cur_state == prev_state))
1296 continue;
1297
1298 /*
1299 * At this point we are interested in performing the action for
1300 * this entry. Actions fall into two categories, spinning off
1301 * a process and not waiting, and spinning off a process and
1302 * waiting for it to die. If the action is ONCE, RESPAWN,
1303 * ONDEMAND, POWERFAIL, or BOOT we don't wait for the process
1304 * to die, for all other actions we do wait.
1305 */
1306 if (cmd.c_action & (M_ONCE | M_RESPAWN | M_PF | M_BOOT)) {
1307 spawn(pp, &cmd);
1308
1309 } else {
1310 spawn(pp, &cmd);
1311 while (waitproc(pp) == FAILURE)
1312 ;
1313 (void) account(DEAD_PROCESS, pp, NULL);
1314 pp->p_flags = 0;
1315 }
1316 }
1317 return (status);
1318 }
1319
1320 /*
1321 * spawn() spawns a shell, inserts the information about the process
1322 * process into the proc_table, and does the startup accounting.
1323 */
1324 static void
1325 spawn(struct PROC_TABLE *process, struct CMD_LINE *cmd)
1326 {
1327 int i;
1328 int modes, maxfiles;
1329 time_t now;
1330 struct PROC_TABLE tmproc, *oprocess;
1331
1332 /*
1333 * The modes to be sent to efork() are 0 unless we are
1334 * spawning a LVLa, LVLb, or LVLc entry or we will be
1335 * waiting for the death of the child before continuing.
1336 */
1337 modes = NAMED;
1338 if (process->p_flags & DEMANDREQUEST || cur_state == LVLa ||
1339 cur_state == LVLb || cur_state == LVLc)
1340 modes |= DEMANDREQUEST;
1341 if ((cmd->c_action & (M_SYSINIT | M_WAIT | M_BOOTWAIT | M_PWAIT)) != 0)
1342 modes |= NOCLEANUP;
1343
1344 /*
1345 * If this is a respawnable process, check the threshold
1346 * information to avoid excessive respawns.
1347 */
1348 if (cmd->c_action & M_RESPAWN) {
1349 /*
1350 * Add NOCLEANUP to all respawnable commands so that the
1351 * information about the frequency of respawns isn't lost.
1352 */
1353 modes |= NOCLEANUP;
1354 (void) time(&now);
1355
1356 /*
1357 * If no time is assigned, then this is the first time
1358 * this command is being processed in this series. Assign
1359 * the current time.
1360 */
1361 if (process->p_time == 0L)
1362 process->p_time = now;
1363
1364 if (process->p_count++ == SPAWN_LIMIT) {
1365
1366 if ((now - process->p_time) < SPAWN_INTERVAL) {
1367 /*
1368 * Process is respawning too rapidly. Print
1369 * message and refuse to respawn it for now.
1370 */
1371 console(B_TRUE, "Command is respawning too "
1372 "rapidly. Check for possible errors.\n"
1373 "id:%4s \"%s\"\n",
1374 &cmd->c_id[0], &cmd->c_command[EXEC]);
1375 return;
1376 }
1377 process->p_time = now;
1378 process->p_count = 0;
1379
1380 } else if (process->p_count > SPAWN_LIMIT) {
1381 /*
1382 * If process has been respawning too rapidly and
1383 * the inhibit time limit hasn't expired yet, we
1384 * refuse to respawn.
1385 */
1386 if (now - process->p_time < SPAWN_INTERVAL + INHIBIT)
1387 return;
1388 process->p_time = now;
1389 process->p_count = 0;
1390 }
1391 rsflag = TRUE;
1392 }
1393
1394 /*
1395 * Spawn a child process to execute this command.
1396 */
1397 (void) sighold(SIGCLD);
1398 oprocess = process;
1399 while ((process = efork(cmd->c_action, oprocess, modes)) == NO_ROOM)
1400 (void) pause();
1401
1402 if (process == NULLPROC) {
1403
1404 /*
1405 * We are the child. We must make sure we get a different
1406 * file pointer for our references to utmpx. Otherwise our
1407 * seeks and reads will compete with those of the parent.
1408 */
1409 endutxent();
1410
1411 /*
1412 * Perform the accounting for the beginning of a process.
1413 * Note that all processes are initially "INIT_PROCESS"es.
1414 */
1415 tmproc.p_id[0] = cmd->c_id[0];
1416 tmproc.p_id[1] = cmd->c_id[1];
1417 tmproc.p_id[2] = cmd->c_id[2];
1418 tmproc.p_id[3] = cmd->c_id[3];
1419 tmproc.p_pid = getpid();
1420 tmproc.p_exit = 0;
1421 (void) account(INIT_PROCESS, &tmproc,
1422 prog_name(&cmd->c_command[EXEC]));
1423 maxfiles = ulimit(UL_GDESLIM, 0);
1424 for (i = 0; i < maxfiles; i++)
1425 (void) fcntl(i, F_SETFD, FD_CLOEXEC);
1426
1427 /*
1428 * Now exec a shell with the -c option and the command
1429 * from inittab.
1430 */
1431 (void) execle(SH, "INITSH", "-c", cmd->c_command, (char *)0,
1432 glob_envp);
1433 console(B_TRUE, "Command\n\"%s\"\n failed to execute. errno "
1434 "= %d (exec of shell failed)\n", cmd->c_command, errno);
1435
1436 /*
1437 * Don't come back so quickly that "init" doesn't have a
1438 * chance to finish putting this child in "proc_table".
1439 */
1440 timer(20);
1441 exit(1);
1442
1443 }
1444
1445 /*
1446 * We are the parent. Insert the necessary
1447 * information in the proc_table.
1448 */
1449 process->p_id[0] = cmd->c_id[0];
1450 process->p_id[1] = cmd->c_id[1];
1451 process->p_id[2] = cmd->c_id[2];
1452 process->p_id[3] = cmd->c_id[3];
1453
1454 st_write();
1455
1456 (void) sigrelse(SIGCLD);
1457 }
1458
1459 /*
1460 * findpslot() finds the old slot in the process table for the
1461 * command with the same id, or it finds an empty slot.
1462 */
1463 static struct PROC_TABLE *
1464 findpslot(struct CMD_LINE *cmd)
1465 {
1466 struct PROC_TABLE *process;
1467 struct PROC_TABLE *empty = NULLPROC;
1468
1469 for (process = proc_table;
1470 (process < proc_table + num_proc); process++) {
1471 if (process->p_flags & OCCUPIED &&
1472 id_eq(process->p_id, cmd->c_id))
1473 break;
1474
1475 /*
1476 * If the entry is totally empty and "empty" is still 0,
1477 * remember where this hole is and make sure the slot is
1478 * zeroed out.
1479 */
1480 if (empty == NULLPROC && (process->p_flags & OCCUPIED) == 0) {
1481 empty = process;
1482 process->p_id[0] = '\0';
1483 process->p_id[1] = '\0';
1484 process->p_id[2] = '\0';
1485 process->p_id[3] = '\0';
1486 process->p_pid = 0;
1487 process->p_time = 0L;
1488 process->p_count = 0;
1489 process->p_flags = 0;
1490 process->p_exit = 0;
1491 }
1492 }
1493
1494 /*
1495 * If there is no entry for this slot, then there should be an
1496 * empty slot. If there is no empty slot, then we've run out
1497 * of proc_table space. If the latter is true, empty will be
1498 * NULL and the caller will have to complain.
1499 */
1500 if (process == (proc_table + num_proc))
1501 process = empty;
1502
1503 return (process);
1504 }
1505
1506 /*
1507 * getcmd() parses lines from inittab. Each time it finds a command line
1508 * it will return TRUE as well as fill the passed CMD_LINE structure and
1509 * the shell command string. When the end of inittab is reached, FALSE
1510 * is returned inittab is automatically opened if it is not currently open
1511 * and is closed when the end of the file is reached.
1512 */
1513 static FILE *fp_inittab = NULL;
1514
1515 static int
1516 getcmd(struct CMD_LINE *cmd, char *shcmd)
1517 {
1518 char *ptr;
1519 int c, lastc, state;
1520 char *ptr1;
1521 int answer, i, proceed;
1522 struct stat sbuf;
1523 static char *actions[] = {
1524 "off", "respawn", "ondemand", "once", "wait", "boot",
1525 "bootwait", "powerfail", "powerwait", "initdefault",
1526 "sysinit",
1527 };
1528 static short act_masks[] = {
1529 M_OFF, M_RESPAWN, M_ONDEMAND, M_ONCE, M_WAIT, M_BOOT,
1530 M_BOOTWAIT, M_PF, M_PWAIT, M_INITDEFAULT, M_SYSINIT,
1531 };
1532 /*
1533 * Only these actions will be allowed for entries which
1534 * are specified for single-user mode.
1535 */
1536 short su_acts = M_INITDEFAULT | M_PF | M_PWAIT | M_WAIT;
1537
1538 if (fp_inittab == NULL) {
1539 /*
1540 * Before attempting to open inittab we stat it to make
1541 * sure it currently exists and is not empty. We try
1542 * several times because someone may have temporarily
1543 * unlinked or truncated the file.
1544 */
1545 for (i = 0; i < 3; i++) {
1546 if (stat(INITTAB, &sbuf) == -1) {
1547 if (i == 2) {
1548 console(B_TRUE,
1549 "Cannot stat %s, errno: %d\n",
1550 INITTAB, errno);
1551 return (FAILURE);
1552 } else {
1553 timer(3);
1554 }
1555 } else if (sbuf.st_size < 10) {
1556 if (i == 2) {
1557 console(B_TRUE,
1558 "%s truncated or corrupted\n",
1559 INITTAB);
1560 return (FAILURE);
1561 } else {
1562 timer(3);
1563 }
1564 } else {
1565 break;
1566 }
1567 }
1568
1569 /*
1570 * If unable to open inittab, print error message and
1571 * return FAILURE to caller.
1572 */
1573 if ((fp_inittab = fopen(INITTAB, "r")) == NULL) {
1574 console(B_TRUE, "Cannot open %s errno: %d\n", INITTAB,
1575 errno);
1576 return (FAILURE);
1577 }
1578 }
1579
1580 /*
1581 * Keep getting commands from inittab until you find a
1582 * good one or run out of file.
1583 */
1584 for (answer = FALSE; answer == FALSE; ) {
1585 /*
1586 * Zero out the cmd itself before trying next line.
1587 */
1588 bzero(cmd, sizeof (struct CMD_LINE));
1589
1590 /*
1591 * Read in lines of inittab, parsing at colons, until a line is
1592 * read in which doesn't end with a backslash. Do not start if
1593 * the first character read is an EOF. Note that this means
1594 * that lines which don't end in a newline are still processed,
1595 * since the "for" will terminate normally once started,
1596 * regardless of whether line terminates with a newline or EOF.
1597 */
1598 state = FAILURE;
1599 if ((c = fgetc(fp_inittab)) == EOF) {
1600 answer = FALSE;
1601 (void) fclose(fp_inittab);
1602 fp_inittab = NULL;
1603 break;
1604 }
1605
1606 for (proceed = TRUE, ptr = shcmd, state = ID, lastc = '\0';
1607 proceed && c != EOF;
1608 lastc = c, c = fgetc(fp_inittab)) {
1609 /* If we're not in the FAILURE state and haven't */
1610 /* yet reached the shell command field, process */
1611 /* the line, otherwise just look for a real end */
1612 /* of line. */
1613 if (state != FAILURE && state != COMMAND) {
1614 /*
1615 * Squeeze out spaces and tabs.
1616 */
1617 if (c == ' ' || c == '\t')
1618 continue;
1619
1620 /*
1621 * Ignore characters in a comment, except for the \n.
1622 */
1623 if (state == COMMENT) {
1624 if (c == '\n') {
1625 lastc = ' ';
1626 break;
1627 } else {
1628 continue;
1629 }
1630 }
1631
1632 /*
1633 * Detect comments (lines whose first non-whitespace
1634 * character is '#') by checking that we're at the
1635 * beginning of a line, have seen a '#', and haven't
1636 * yet accumulated any characters.
1637 */
1638 if (state == ID && c == '#' && ptr == shcmd) {
1639 state = COMMENT;
1640 continue;
1641 }
1642
1643 /*
1644 * If the character is a ':', then check the
1645 * previous field for correctness and advance
1646 * to the next field.
1647 */
1648 if (c == ':') {
1649 switch (state) {
1650
1651 case ID :
1652 /*
1653 * Check to see that there are only
1654 * 1 to 4 characters for the id.
1655 */
1656 if ((i = ptr - shcmd) < 1 || i > 4) {
1657 state = FAILURE;
1658 } else {
1659 bcopy(shcmd, &cmd->c_id[0], i);
1660 ptr = shcmd;
1661 state = LEVELS;
1662 }
1663 break;
1664
1665 case LEVELS :
1666 /*
1667 * Build a mask for all the levels for
1668 * which this command will be legal.
1669 */
1670 for (cmd->c_levels = 0, ptr1 = shcmd;
1671 ptr1 < ptr; ptr1++) {
1672 int mask;
1673 if (lvlname_to_mask(*ptr1,
1674 &mask) == -1) {
1675 state = FAILURE;
1676 break;
1677 }
1678 cmd->c_levels |= mask;
1679 }
1680 if (state != FAILURE) {
1681 state = ACTION;
1682 ptr = shcmd; /* Reset the buffer */
1683 }
1684 break;
1685
1686 case ACTION :
1687 /*
1688 * Null terminate the string in shcmd buffer and
1689 * then try to match against legal actions. If
1690 * the field is of length 0, then the default of
1691 * "RESPAWN" is used if the id is numeric,
1692 * otherwise the default is "OFF".
1693 */
1694 if (ptr == shcmd) {
1695 if (isdigit(cmd->c_id[0]) &&
1696 (cmd->c_id[1] == '\0' ||
1697 isdigit(cmd->c_id[1])) &&
1698 (cmd->c_id[2] == '\0' ||
1699 isdigit(cmd->c_id[2])) &&
1700 (cmd->c_id[3] == '\0' ||
1701 isdigit(cmd->c_id[3])))
1702 cmd->c_action = M_RESPAWN;
1703 else
1704 cmd->c_action = M_OFF;
1705 } else {
1706 for (cmd->c_action = 0, i = 0,
1707 *ptr = '\0';
1708 i <
1709 sizeof (actions)/sizeof (char *);
1710 i++) {
1711 if (strcmp(shcmd, actions[i]) == 0) {
1712 if ((cmd->c_levels & MASKSU) &&
1713 !(act_masks[i] & su_acts))
1714 cmd->c_action = 0;
1715 else
1716 cmd->c_action =
1717 act_masks[i];
1718 break;
1719 }
1720 }
1721 }
1722
1723 /*
1724 * If the action didn't match any legal action,
1725 * set state to FAILURE.
1726 */
1727 if (cmd->c_action == 0) {
1728 state = FAILURE;
1729 } else {
1730 state = COMMAND;
1731 (void) strcpy(shcmd, "exec ");
1732 }
1733 ptr = shcmd + EXEC;
1734 break;
1735 }
1736 continue;
1737 }
1738 }
1739
1740 /* If the character is a '\n', then this is the end of a */
1741 /* line. If the '\n' wasn't preceded by a backslash, */
1742 /* it is also the end of an inittab command. If it was */
1743 /* preceded by a backslash then the next line is a */
1744 /* continuation. Note that the continuation '\n' falls */
1745 /* through and is treated like other characters and is */
1746 /* stored in the shell command line. */
1747 if (c == '\n' && lastc != '\\') {
1748 proceed = FALSE;
1749 *ptr = '\0';
1750 break;
1751 }
1752
1753 /* For all other characters just stuff them into the */
1754 /* command as long as there aren't too many of them. */
1755 /* Make sure there is room for a terminating '\0' also. */
1756 if (ptr >= shcmd + MAXCMDL - 1)
1757 state = FAILURE;
1758 else
1759 *ptr++ = (char)c;
1760
1761 /* If the character we just stored was a quoted */
1762 /* backslash, then change "c" to '\0', so that this */
1763 /* backslash will not cause a subsequent '\n' to appear */
1764 /* quoted. In otherwords '\' '\' '\n' is the real end */
1765 /* of a command, while '\' '\n' is a continuation. */
1766 if (c == '\\' && lastc == '\\')
1767 c = '\0';
1768 }
1769
1770 /*
1771 * Make sure all the fields are properly specified
1772 * for a good command line.
1773 */
1774 if (state == COMMAND) {
1775 answer = TRUE;
1776 cmd->c_command = shcmd;
1777
1778 /*
1779 * If no default level was supplied, insert
1780 * all numerical levels.
1781 */
1782 if (cmd->c_levels == 0)
1783 cmd->c_levels = MASK_NUMERIC;
1784
1785 /*
1786 * If no action has been supplied, declare this
1787 * entry to be OFF.
1788 */
1789 if (cmd->c_action == 0)
1790 cmd->c_action = M_OFF;
1791
1792 /*
1793 * If no shell command has been supplied, make sure
1794 * there is a null string in the command field.
1795 */
1796 if (ptr == shcmd + EXEC)
1797 *shcmd = '\0';
1798 } else
1799 answer = FALSE;
1800
1801 /*
1802 * If we have reached the end of inittab, then close it
1803 * and quit trying to find a good command line.
1804 */
1805 if (c == EOF) {
1806 (void) fclose(fp_inittab);
1807 fp_inittab = NULL;
1808 break;
1809 }
1810 }
1811 return (answer);
1812 }
1813
1814 /*
1815 * lvlname_to_state(): convert the character name of a state to its level
1816 * (its corresponding signal number).
1817 */
1818 static int
1819 lvlname_to_state(char name)
1820 {
1821 int i;
1822 for (i = 0; i < LVL_NELEMS; i++) {
1823 if (lvls[i].lvl_name == name)
1824 return (lvls[i].lvl_state);
1825 }
1826 return (-1);
1827 }
1828
1829 /*
1830 * state_to_name(): convert the level to the character name.
1831 */
1832 static char
1833 state_to_name(int state)
1834 {
1835 int i;
1836 for (i = 0; i < LVL_NELEMS; i++) {
1837 if (lvls[i].lvl_state == state)
1838 return (lvls[i].lvl_name);
1839 }
1840 return (-1);
1841 }
1842
1843 /*
1844 * state_to_mask(): return the mask corresponding to a signal number
1845 */
1846 static int
1847 state_to_mask(int state)
1848 {
1849 int i;
1850 for (i = 0; i < LVL_NELEMS; i++) {
1851 if (lvls[i].lvl_state == state)
1852 return (lvls[i].lvl_mask);
1853 }
1854 return (0); /* return 0, since that represents an empty mask */
1855 }
1856
1857 /*
1858 * lvlname_to_mask(): return the mask corresponding to a levels character name
1859 */
1860 static int
1861 lvlname_to_mask(char name, int *mask)
1862 {
1863 int i;
1864 for (i = 0; i < LVL_NELEMS; i++) {
1865 if (lvls[i].lvl_name == name) {
1866 *mask = lvls[i].lvl_mask;
1867 return (0);
1868 }
1869 }
1870 return (-1);
1871 }
1872
1873 /*
1874 * state_to_flags(): return the flags corresponding to a runlevel. These
1875 * indicate properties of that runlevel.
1876 */
1877 static int
1878 state_to_flags(int state)
1879 {
1880 int i;
1881 for (i = 0; i < LVL_NELEMS; i++) {
1882 if (lvls[i].lvl_state == state)
1883 return (lvls[i].lvl_flags);
1884 }
1885 return (0);
1886 }
1887
1888 /*
1889 * killproc() creates a child which kills the process specified by pid.
1890 */
1891 void
1892 killproc(pid_t pid)
1893 {
1894 struct PROC_TABLE *process;
1895
1896 (void) sighold(SIGCLD);
1897 while ((process = efork(M_OFF, NULLPROC, 0)) == NO_ROOM)
1898 (void) pause();
1899 (void) sigrelse(SIGCLD);
1900
1901 if (process == NULLPROC) {
1902 /*
1903 * efork() sets all signal handlers to the default, so reset
1904 * the ALRM handler to make timer() work as expected.
1905 */
1906 (void) sigset(SIGALRM, alarmclk);
1907
1908 /*
1909 * We are the child. Try to terminate the process nicely
1910 * first using SIGTERM and if it refuses to die in TWARN
1911 * seconds kill it with SIGKILL.
1912 */
1913 (void) kill(pid, SIGTERM);
1914 (void) timer(TWARN);
1915 (void) kill(pid, SIGKILL);
1916 (void) exit(0);
1917 }
1918 }
1919
1920 /*
1921 * Set up the default environment for all procs to be forked from init.
1922 * Read the values from the /etc/default/init file, except for PATH. If
1923 * there's not enough room in the environment array, the environment
1924 * lines that don't fit are silently discarded.
1925 */
1926 void
1927 init_env()
1928 {
1929 char line[MAXCMDL];
1930 FILE *fp;
1931 int inquotes, length, wslength;
1932 char *tokp, *cp1, *cp2;
1933
1934 glob_envp[0] = malloc((unsigned)(strlen(DEF_PATH)+2));
1935 (void) strcpy(glob_envp[0], DEF_PATH);
1936 glob_envn = 1;
1937
1938 if (rflg) {
1939 glob_envp[1] =
1940 malloc((unsigned)(strlen("_DVFS_RECONFIG=YES")+2));
1941 (void) strcpy(glob_envp[1], "_DVFS_RECONFIG=YES");
1942 ++glob_envn;
1943 } else if (bflg == 1) {
1944 glob_envp[1] =
1945 malloc((unsigned)(strlen("RB_NOBOOTRC=YES")+2));
1946 (void) strcpy(glob_envp[1], "RB_NOBOOTRC=YES");
1947 ++glob_envn;
1948 }
1949
1950 if ((fp = fopen(ENVFILE, "r")) == NULL) {
1951 console(B_TRUE,
1952 "Cannot open %s. Environment not initialized.\n",
1953 ENVFILE);
1954 } else {
1955 while (fgets(line, MAXCMDL - 1, fp) != NULL &&
1956 glob_envn < MAXENVENT - 2) {
1957 /*
1958 * Toss newline
1959 */
1960 length = strlen(line);
1961 if (line[length - 1] == '\n')
1962 line[length - 1] = '\0';
1963
1964 /*
1965 * Ignore blank or comment lines.
1966 */
1967 if (line[0] == '#' || line[0] == '\0' ||
1968 (wslength = strspn(line, " \t\n")) ==
1969 strlen(line) ||
1970 strchr(line, '#') == line + wslength)
1971 continue;
1972
1973 /*
1974 * First make a pass through the line and change
1975 * any non-quoted semi-colons to blanks so they
1976 * will be treated as token separators below.
1977 */
1978 inquotes = 0;
1979 for (cp1 = line; *cp1 != '\0'; cp1++) {
1980 if (*cp1 == '"') {
1981 if (inquotes == 0)
1982 inquotes = 1;
1983 else
1984 inquotes = 0;
1985 } else if (*cp1 == ';') {
1986 if (inquotes == 0)
1987 *cp1 = ' ';
1988 }
1989 }
1990
1991 /*
1992 * Tokens within the line are separated by blanks
1993 * and tabs. For each token in the line which
1994 * contains a '=' we strip out any quotes and then
1995 * stick the token in the environment array.
1996 */
1997 if ((tokp = strtok(line, " \t")) == NULL)
1998 continue;
1999 do {
2000 if (strchr(tokp, '=') == NULL)
2001 continue;
2002 length = strlen(tokp);
2003 while ((cp1 = strpbrk(tokp, "\"\'")) != NULL) {
2004 for (cp2 = cp1;
2005 cp2 < &tokp[length]; cp2++)
2006 *cp2 = *(cp2 + 1);
2007 length--;
2008 }
2009
2010 if (strncmp(tokp, "CMASK=",
2011 sizeof ("CMASK=") - 1) == 0) {
2012 long t;
2013
2014 /* We know there's an = */
2015 t = strtol(strchr(tokp, '=') + 1, NULL,
2016 8);
2017
2018 /* Sanity */
2019 if (t <= 077 && t >= 0)
2020 cmask = (int)t;
2021 (void) umask(cmask);
2022 continue;
2023 }
2024 glob_envp[glob_envn] =
2025 malloc((unsigned)(length + 1));
2026 (void) strcpy(glob_envp[glob_envn], tokp);
2027 if (++glob_envn >= MAXENVENT - 1)
2028 break;
2029 } while ((tokp = strtok(NULL, " \t")) != NULL);
2030 }
2031
2032 /*
2033 * Append a null pointer to the environment array
2034 * to mark its end.
2035 */
2036 glob_envp[glob_envn] = NULL;
2037 (void) fclose(fp);
2038 }
2039 }
2040
2041 /*
2042 * boot_init(): Do initialization things that should be done at boot.
2043 */
2044 void
2045 boot_init()
2046 {
2047 int i;
2048 struct PROC_TABLE *process, *oprocess;
2049 struct CMD_LINE cmd;
2050 char line[MAXCMDL];
2051 char svc_aux[SVC_AUX_SIZE];
2052 char init_svc_fmri[SVC_FMRI_SIZE];
2053 char *old_path;
2054 int maxfiles;
2055
2056 /* Use INIT_PATH for sysinit cmds */
2057 old_path = glob_envp[0];
2058 glob_envp[0] = malloc((unsigned)(strlen(INIT_PATH)+2));
2059 (void) strcpy(glob_envp[0], INIT_PATH);
2060
2061 /*
2062 * Scan inittab(4) and process the special svc.startd entry, initdefault
2063 * and sysinit entries.
2064 */
2065 while (getcmd(&cmd, &line[0]) == TRUE) {
2066 if (startd_tmpl >= 0 && id_eq(cmd.c_id, "smf")) {
2067 process_startd_line(&cmd, line);
2068 (void) snprintf(startd_svc_aux, SVC_AUX_SIZE,
2069 INITTAB_ENTRY_ID_STR_FORMAT, cmd.c_id);
2070 } else if (cmd.c_action == M_INITDEFAULT) {
2071 /*
2072 * initdefault is no longer meaningful, as the SMF
2073 * milestone controls what (legacy) run level we
2074 * boot to.
2075 */
2076 console(B_TRUE,
2077 "Ignoring legacy \"initdefault\" entry.\n");
2078 } else if (cmd.c_action == M_SYSINIT) {
2079 /*
2080 * Execute the "sysinit" entry and wait for it to
2081 * complete. No bookkeeping is performed on these
2082 * entries because we avoid writing to the file system
2083 * until after there has been an chance to check it.
2084 */
2085 if (process = findpslot(&cmd)) {
2086 (void) sighold(SIGCLD);
2087 (void) snprintf(svc_aux, SVC_AUX_SIZE,
2088 INITTAB_ENTRY_ID_STR_FORMAT, cmd.c_id);
2089 (void) snprintf(init_svc_fmri, SVC_FMRI_SIZE,
2090 SVC_INIT_PREFIX INITTAB_ENTRY_ID_STR_FORMAT,
2091 cmd.c_id);
2092 if (legacy_tmpl >= 0) {
2093 (void) ct_pr_tmpl_set_svc_fmri(
2094 legacy_tmpl, init_svc_fmri);
2095 (void) ct_pr_tmpl_set_svc_aux(
2096 legacy_tmpl, svc_aux);
2097 }
2098
2099 for (oprocess = process;
2100 (process = efork(M_OFF, oprocess,
2101 (NAMED|NOCLEANUP))) == NO_ROOM;
2102 /* CSTYLED */)
2103 ;
2104 (void) sigrelse(SIGCLD);
2105
2106 if (process == NULLPROC) {
2107 maxfiles = ulimit(UL_GDESLIM, 0);
2108
2109 for (i = 0; i < maxfiles; i++)
2110 (void) fcntl(i, F_SETFD,
2111 FD_CLOEXEC);
2112 (void) execle(SH, "INITSH", "-c",
2113 cmd.c_command,
2114 (char *)0, glob_envp);
2115 console(B_TRUE,
2116 "Command\n\"%s\"\n failed to execute. errno = %d (exec of shell failed)\n",
2117 cmd.c_command, errno);
2118 exit(1);
2119 } else
2120 while (waitproc(process) == FAILURE)
2121 ;
2122 process->p_flags = 0;
2123 st_write();
2124 }
2125 }
2126 }
2127
2128 /* Restore the path. */
2129 free(glob_envp[0]);
2130 glob_envp[0] = old_path;
2131
2132 /*
2133 * This will enable st_write() to complain about init_state_file.
2134 */
2135 booting = 0;
2136
2137 /*
2138 * If the /etc/ioctl.syscon didn't exist or had invalid contents write
2139 * out a correct version.
2140 */
2141 if (write_ioctl)
2142 write_ioctl_syscon();
2143
2144 /*
2145 * Start svc.startd(1M), which does most of the work.
2146 */
2147 if (startd_cline[0] != '\0' && startd_tmpl >= 0) {
2148 /* Start svc.startd. */
2149 if (startd_run(startd_cline, startd_tmpl, 0) == -1)
2150 cur_state = SINGLE_USER;
2151 } else {
2152 console(B_TRUE, "Absent svc.startd entry or bad "
2153 "contract template. Not starting svc.startd.\n");
2154 enter_maintenance();
2155 }
2156 }
2157
2158 /*
2159 * init_signals(): Initialize all signals to either be caught or ignored.
2160 */
2161 void
2162 init_signals(void)
2163 {
2164 struct sigaction act;
2165 int i;
2166
2167 /*
2168 * Start by ignoring all signals, then selectively re-enable some.
2169 * The SIG_IGN disposition will only affect asynchronous signals:
2170 * any signal that we trigger synchronously that doesn't end up
2171 * being handled by siglvl() will be forcibly delivered by the kernel.
2172 */
2173 for (i = SIGHUP; i <= SIGRTMAX; i++)
2174 (void) sigset(i, SIG_IGN);
2175
2176 /*
2177 * Handle all level-changing signals using siglvl() and set sa_mask so
2178 * that all level-changing signals are blocked while in siglvl().
2179 */
2180 act.sa_handler = siglvl;
2181 act.sa_flags = SA_SIGINFO;
2182 (void) sigemptyset(&act.sa_mask);
2183
2184 (void) sigaddset(&act.sa_mask, LVLQ);
2185 (void) sigaddset(&act.sa_mask, LVL0);
2186 (void) sigaddset(&act.sa_mask, LVL1);
2187 (void) sigaddset(&act.sa_mask, LVL2);
2188 (void) sigaddset(&act.sa_mask, LVL3);
2189 (void) sigaddset(&act.sa_mask, LVL4);
2190 (void) sigaddset(&act.sa_mask, LVL5);
2191 (void) sigaddset(&act.sa_mask, LVL6);
2192 (void) sigaddset(&act.sa_mask, SINGLE_USER);
2193 (void) sigaddset(&act.sa_mask, LVLa);
2194 (void) sigaddset(&act.sa_mask, LVLb);
2195 (void) sigaddset(&act.sa_mask, LVLc);
2196
2197 (void) sigaction(LVLQ, &act, NULL);
2198 (void) sigaction(LVL0, &act, NULL);
2199 (void) sigaction(LVL1, &act, NULL);
2200 (void) sigaction(LVL2, &act, NULL);
2201 (void) sigaction(LVL3, &act, NULL);
2202 (void) sigaction(LVL4, &act, NULL);
2203 (void) sigaction(LVL5, &act, NULL);
2204 (void) sigaction(LVL6, &act, NULL);
2205 (void) sigaction(SINGLE_USER, &act, NULL);
2206 (void) sigaction(LVLa, &act, NULL);
2207 (void) sigaction(LVLb, &act, NULL);
2208 (void) sigaction(LVLc, &act, NULL);
2209
2210 (void) sigset(SIGALRM, alarmclk);
2211 alarmclk();
2212
2213 (void) sigset(SIGCLD, childeath);
2214 (void) sigset(SIGPWR, powerfail);
2215 }
2216
2217 /*
2218 * Set up pipe for "godchildren". If the file exists and is a pipe just open
2219 * it. Else, if the file system is r/w create it. Otherwise, defer its
2220 * creation and open until after /var/run has been mounted. This function is
2221 * only called on startup and when explicitly requested via LVLQ.
2222 */
2223 void
2224 setup_pipe()
2225 {
2226 struct stat stat_buf;
2227 struct statvfs statvfs_buf;
2228 struct sigaction act;
2229
2230 /*
2231 * Always close the previous pipe descriptor as the mounted filesystems
2232 * may have changed.
2233 */
2234 if (Pfd >= 0)
2235 (void) close(Pfd);
2236
2237 if ((stat(INITPIPE, &stat_buf) == 0) &&
2238 ((stat_buf.st_mode & (S_IFMT|S_IRUSR)) == (S_IFIFO|S_IRUSR)))
2239 Pfd = open(INITPIPE, O_RDWR | O_NDELAY);
2240 else
2241 if ((statvfs(INITPIPE_DIR, &statvfs_buf) == 0) &&
2242 ((statvfs_buf.f_flag & ST_RDONLY) == 0)) {
2243 (void) unlink(INITPIPE);
2244 (void) mknod(INITPIPE, S_IFIFO | 0600, 0);
2245 Pfd = open(INITPIPE, O_RDWR | O_NDELAY);
2246 }
2247
2248 if (Pfd >= 0) {
2249 (void) ioctl(Pfd, I_SETSIG, S_INPUT);
2250 /*
2251 * Read pipe in message discard mode.
2252 */
2253 (void) ioctl(Pfd, I_SRDOPT, RMSGD);
2254
2255 act.sa_handler = sigpoll;
2256 act.sa_flags = 0;
2257 (void) sigemptyset(&act.sa_mask);
2258 (void) sigaddset(&act.sa_mask, SIGCLD);
2259 (void) sigaction(SIGPOLL, &act, NULL);
2260 }
2261 }
2262
2263 /*
2264 * siglvl - handle an asynchronous signal from init(1M) telling us that we
2265 * should change the current run level. We set new_state accordingly.
2266 */
2267 void
2268 siglvl(int sig, siginfo_t *sip, ucontext_t *ucp)
2269 {
2270 struct PROC_TABLE *process;
2271 struct sigaction act;
2272
2273 /*
2274 * If the signal was from the kernel (rather than init(1M)) then init
2275 * itself tripped the signal. That is, we might have a bug and tripped
2276 * a real SIGSEGV instead of receiving it as an alias for SIGLVLa. In
2277 * such a case we reset the disposition to SIG_DFL, block all signals
2278 * in uc_mask but the current one, and return to the interrupted ucp
2279 * to effect an appropriate death. The kernel will then restart us.
2280 *
2281 * The one exception to SI_FROMKERNEL() is SIGFPE (a.k.a. LVL6), which
2282 * the kernel can send us when it wants to effect an orderly reboot.
2283 * For this case we must also verify si_code is zero, rather than a
2284 * code such as FPE_INTDIV which a bug might have triggered.
2285 */
2286 if (sip != NULL && SI_FROMKERNEL(sip) &&
2287 (sig != SIGFPE || sip->si_code == 0)) {
2288
2289 (void) sigemptyset(&act.sa_mask);
2290 act.sa_handler = SIG_DFL;
2291 act.sa_flags = 0;
2292 (void) sigaction(sig, &act, NULL);
2293
2294 (void) sigfillset(&ucp->uc_sigmask);
2295 (void) sigdelset(&ucp->uc_sigmask, sig);
2296 ucp->uc_flags |= UC_SIGMASK;
2297
2298 (void) setcontext(ucp);
2299 }
2300
2301 /*
2302 * If the signal received is a LVLQ signal, do not really
2303 * change levels, just restate the current level. If the
2304 * signal is not a LVLQ, set the new level to the signal
2305 * received.
2306 */
2307 if (sig == LVLQ) {
2308 new_state = cur_state;
2309 lvlq_received = B_TRUE;
2310 } else {
2311 new_state = sig;
2312 }
2313
2314 /*
2315 * Clear all times and repeat counts in the process table
2316 * since either the level is changing or the user has editted
2317 * the inittab file and wants us to look at it again.
2318 * If the user has fixed a typo, we don't want residual timing
2319 * data preventing the fixed command line from executing.
2320 */
2321 for (process = proc_table;
2322 (process < proc_table + num_proc); process++) {
2323 process->p_time = 0L;
2324 process->p_count = 0;
2325 }
2326
2327 /*
2328 * Set the flag to indicate that a "user signal" was received.
2329 */
2330 wakeup.w_flags.w_usersignal = 1;
2331 }
2332
2333
2334 /*
2335 * alarmclk
2336 */
2337 static void
2338 alarmclk()
2339 {
2340 time_up = TRUE;
2341 }
2342
2343 /*
2344 * childeath_single():
2345 *
2346 * This used to be the SIGCLD handler and it was set with signal()
2347 * (as opposed to sigset()). When a child exited we'd come to the
2348 * handler, wait for the child, and reenable the handler with
2349 * signal() just before returning. The implementation of signal()
2350 * checks with waitid() for waitable children and sends a SIGCLD
2351 * if there are some. If children are exiting faster than the
2352 * handler can run we keep sending signals and the handler never
2353 * gets to return and eventually the stack runs out and init dies.
2354 * To prevent that we set the handler with sigset() so the handler
2355 * doesn't need to be reset, and in childeath() (see below) we
2356 * call childeath_single() as long as there are children to be
2357 * waited for. If a child exits while init is in the handler a
2358 * SIGCLD will be pending and delivered on return from the handler.
2359 * If the child was already waited for the handler will have nothing
2360 * to do and return, otherwise the child will be waited for.
2361 */
2362 static void
2363 childeath_single(pid_t pid, int status)
2364 {
2365 struct PROC_TABLE *process;
2366 struct pidlist *pp;
2367
2368 /*
2369 * Scan the process table to see if we are interested in this process.
2370 */
2371 for (process = proc_table;
2372 (process < proc_table + num_proc); process++) {
2373 if ((process->p_flags & (LIVING|OCCUPIED)) ==
2374 (LIVING|OCCUPIED) && process->p_pid == pid) {
2375
2376 /*
2377 * Mark this process as having died and store the exit
2378 * status. Also set the wakeup flag for a dead child
2379 * and break out of the loop.
2380 */
2381 process->p_flags &= ~LIVING;
2382 process->p_exit = (short)status;
2383 wakeup.w_flags.w_childdeath = 1;
2384
2385 return;
2386 }
2387 }
2388
2389 /*
2390 * No process was found above, look through auxiliary list.
2391 */
2392 (void) sighold(SIGPOLL);
2393 pp = Plhead;
2394 while (pp) {
2395 if (pid > pp->pl_pid) {
2396 /*
2397 * Keep on looking.
2398 */
2399 pp = pp->pl_next;
2400 continue;
2401 } else if (pid < pp->pl_pid) {
2402 /*
2403 * Not in the list.
2404 */
2405 break;
2406 } else {
2407 /*
2408 * This is a dead "godchild".
2409 */
2410 pp->pl_dflag = 1;
2411 pp->pl_exit = (short)status;
2412 wakeup.w_flags.w_childdeath = 1;
2413 Gchild = 1; /* Notice to call cleanaux(). */
2414 break;
2415 }
2416 }
2417
2418 (void) sigrelse(SIGPOLL);
2419 }
2420
2421 /* ARGSUSED */
2422 static void
2423 childeath(int signo)
2424 {
2425 pid_t pid;
2426 int status;
2427
2428 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
2429 childeath_single(pid, status);
2430 }
2431
2432 static void
2433 powerfail()
2434 {
2435 (void) nice(-19);
2436 wakeup.w_flags.w_powerhit = 1;
2437 }
2438
2439 /*
2440 * efork() forks a child and the parent inserts the process in its table
2441 * of processes that are directly a result of forks that it has performed.
2442 * The child just changes the "global" with the process id for this process
2443 * to it's new value.
2444 * If efork() is called with a pointer into the proc_table it uses that slot,
2445 * otherwise it searches for a free slot. Regardless of how it was called,
2446 * it returns the pointer to the proc_table entry
2447 *
2448 * The SIGCLD signal is blocked (held) before calling efork()
2449 * and is unblocked (released) after efork() returns.
2450 *
2451 * Ideally, this should be rewritten to use modern signal semantics.
2452 */
2453 static struct PROC_TABLE *
2454 efork(int action, struct PROC_TABLE *process, int modes)
2455 {
2456 pid_t childpid;
2457 struct PROC_TABLE *proc;
2458 int i;
2459 /*
2460 * Freshen up the proc_table, removing any entries for dead processes
2461 * that don't have NOCLEANUP set. Perform the necessary accounting.
2462 */
2463 for (proc = proc_table; (proc < proc_table + num_proc); proc++) {
2464 if ((proc->p_flags & (OCCUPIED|LIVING|NOCLEANUP)) ==
2465 (OCCUPIED)) {
2466 /*
2467 * Is this a named process?
2468 * If so, do the necessary bookkeeping.
2469 */
2470 if (proc->p_flags & NAMED)
2471 (void) account(DEAD_PROCESS, proc, NULL);
2472
2473 /*
2474 * Free this entry for new usage.
2475 */
2476 proc->p_flags = 0;
2477 }
2478 }
2479
2480 while ((childpid = fork()) == FAILURE) {
2481 /*
2482 * Shorten the alarm timer in case someone else's child dies
2483 * and free up a slot in the process table.
2484 */
2485 setimer(5);
2486
2487 /*
2488 * Wait for some children to die. Since efork()
2489 * is always called with SIGCLD blocked, unblock
2490 * it here so that child death signals can come in.
2491 */
2492 (void) sigrelse(SIGCLD);
2493 (void) pause();
2494 (void) sighold(SIGCLD);
2495 setimer(0);
2496 }
2497
2498 if (childpid != 0) {
2499
2500 if (process == NULLPROC) {
2501 /*
2502 * No proc table pointer specified so search
2503 * for a free slot.
2504 */
2505 for (process = proc_table; process->p_flags != 0 &&
2506 (process < proc_table + num_proc); process++)
2507 ;
2508
2509 if (process == (proc_table + num_proc)) {
2510 int old_proc_table_size = num_proc;
2511
2512 /* Increase the process table size */
2513 increase_proc_table_size();
2514 if (old_proc_table_size == num_proc) {
2515 /* didn't grow: memory failure */
2516 return (NO_ROOM);
2517 } else {
2518 process =
2519 proc_table + old_proc_table_size;
2520 }
2521 }
2522
2523 process->p_time = 0L;
2524 process->p_count = 0;
2525 }
2526 process->p_id[0] = '\0';
2527 process->p_id[1] = '\0';
2528 process->p_id[2] = '\0';
2529 process->p_id[3] = '\0';
2530 process->p_pid = childpid;
2531 process->p_flags = (LIVING | OCCUPIED | modes);
2532 process->p_exit = 0;
2533
2534 st_write();
2535 } else {
2536 if ((action & (M_WAIT | M_BOOTWAIT)) == 0)
2537 (void) setpgrp();
2538
2539 process = NULLPROC;
2540
2541 /*
2542 * Reset all signals to the system defaults.
2543 */
2544 for (i = SIGHUP; i <= SIGRTMAX; i++)
2545 (void) sigset(i, SIG_DFL);
2546
2547 /*
2548 * POSIX B.2.2.2 advises that init should set SIGTTOU,
2549 * SIGTTIN, and SIGTSTP to SIG_IGN.
2550 *
2551 * Make sure that SIGXCPU and SIGXFSZ also remain ignored,
2552 * for backward compatibility.
2553 */
2554 (void) sigset(SIGTTIN, SIG_IGN);
2555 (void) sigset(SIGTTOU, SIG_IGN);
2556 (void) sigset(SIGTSTP, SIG_IGN);
2557 (void) sigset(SIGXCPU, SIG_IGN);
2558 (void) sigset(SIGXFSZ, SIG_IGN);
2559 }
2560 return (process);
2561 }
2562
2563
2564 /*
2565 * waitproc() waits for a specified process to die. For this function to
2566 * work, the specified process must already in the proc_table. waitproc()
2567 * returns the exit status of the specified process when it dies.
2568 */
2569 static long
2570 waitproc(struct PROC_TABLE *process)
2571 {
2572 int answer;
2573 sigset_t oldmask, newmask, zeromask;
2574
2575 (void) sigemptyset(&zeromask);
2576 (void) sigemptyset(&newmask);
2577
2578 (void) sigaddset(&newmask, SIGCLD);
2579
2580 /* Block SIGCLD and save the current signal mask */
2581 if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
2582 perror("SIG_BLOCK error");
2583
2584 /*
2585 * Wait around until the process dies.
2586 */
2587 if (process->p_flags & LIVING)
2588 (void) sigsuspend(&zeromask);
2589
2590 /* Reset signal mask to unblock SIGCLD */
2591 if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
2592 perror("SIG_SETMASK error");
2593
2594 if (process->p_flags & LIVING)
2595 return (FAILURE);
2596
2597 /*
2598 * Make sure to only return 16 bits so that answer will always
2599 * be positive whenever the process of interest really died.
2600 */
2601 answer = (process->p_exit & 0xffff);
2602
2603 /*
2604 * Free the slot in the proc_table.
2605 */
2606 process->p_flags = 0;
2607 return (answer);
2608 }
2609
2610 /*
2611 * notify_pam_dead(): calls into the PAM framework to close the given session.
2612 */
2613 static void
2614 notify_pam_dead(struct utmpx *up)
2615 {
2616 pam_handle_t *pamh;
2617 char user[sizeof (up->ut_user) + 1];
2618 char ttyn[sizeof (up->ut_line) + 1];
2619 char host[sizeof (up->ut_host) + 1];
2620
2621 /*
2622 * PAM does not take care of updating utmpx/wtmpx.
2623 */
2624 (void) snprintf(user, sizeof (user), "%s", up->ut_user);
2625 (void) snprintf(ttyn, sizeof (ttyn), "%s", up->ut_line);
2626 (void) snprintf(host, sizeof (host), "%s", up->ut_host);
2627
2628 if (pam_start("init", user, NULL, &pamh) == PAM_SUCCESS) {
2629 (void) pam_set_item(pamh, PAM_TTY, ttyn);
2630 (void) pam_set_item(pamh, PAM_RHOST, host);
2631 (void) pam_close_session(pamh, 0);
2632 (void) pam_end(pamh, PAM_SUCCESS);
2633 }
2634 }
2635
2636 /*
2637 * Check you can access utmpx (As / may be read-only and
2638 * /var may not be mounted yet).
2639 */
2640 static int
2641 access_utmpx(void)
2642 {
2643 do {
2644 utmpx_ok = (access(UTMPX, R_OK|W_OK) == 0);
2645 } while (!utmpx_ok && errno == EINTR);
2646
2647 return (utmpx_ok);
2648 }
2649
2650 /*
2651 * account() updates entries in utmpx and appends new entries to the end of
2652 * wtmpx (assuming they exist). The program argument indicates the name of
2653 * program if INIT_PROCESS, otherwise should be NULL.
2654 *
2655 * account() only blocks for INIT_PROCESS requests.
2656 *
2657 * Returns non-zero if write failed.
2658 */
2659 static int
2660 account(short state, struct PROC_TABLE *process, char *program)
2661 {
2662 struct utmpx utmpbuf, *u, *oldu;
2663 int tmplen;
2664 char fail_buf[UT_LINE_SZ];
2665 sigset_t block, unblock;
2666
2667 if (!utmpx_ok && !access_utmpx()) {
2668 return (-1);
2669 }
2670
2671 /*
2672 * Set up the prototype for the utmp structure we want to write.
2673 */
2674 u = &utmpbuf;
2675 (void) memset(u, 0, sizeof (struct utmpx));
2676
2677 /*
2678 * Fill in the various fields of the utmp structure.
2679 */
2680 u->ut_id[0] = process->p_id[0];
2681 u->ut_id[1] = process->p_id[1];
2682 u->ut_id[2] = process->p_id[2];
2683 u->ut_id[3] = process->p_id[3];
2684 u->ut_pid = process->p_pid;
2685
2686 /*
2687 * Fill the "ut_exit" structure.
2688 */
2689 u->ut_exit.e_termination = WTERMSIG(process->p_exit);
2690 u->ut_exit.e_exit = WEXITSTATUS(process->p_exit);
2691 u->ut_type = state;
2692
2693 (void) time(&u->ut_tv.tv_sec);
2694
2695 /*
2696 * Block signals for utmp update.
2697 */
2698 (void) sigfillset(&block);
2699 (void) sigprocmask(SIG_BLOCK, &block, &unblock);
2700
2701 /*
2702 * See if there already is such an entry in the "utmpx" file.
2703 */
2704 setutxent(); /* Start at beginning of utmpx file. */
2705
2706 if ((oldu = getutxid(u)) != NULL) {
2707 /*
2708 * Copy in the old "user", "line" and "host" fields
2709 * to our new structure.
2710 */
2711 bcopy(oldu->ut_user, u->ut_user, sizeof (u->ut_user));
2712 bcopy(oldu->ut_line, u->ut_line, sizeof (u->ut_line));
2713 bcopy(oldu->ut_host, u->ut_host, sizeof (u->ut_host));
2714 u->ut_syslen = (tmplen = strlen(u->ut_host)) ?
2715 min(tmplen + 1, sizeof (u->ut_host)) : 0;
2716
2717 if (oldu->ut_type == USER_PROCESS && state == DEAD_PROCESS) {
2718 notify_pam_dead(oldu);
2719 }
2720 }
2721
2722 /*
2723 * Perform special accounting. Insert the special string into the
2724 * ut_line array. For INIT_PROCESSes put in the name of the
2725 * program in the "ut_user" field.
2726 */
2727 switch (state) {
2728 case INIT_PROCESS:
2729 (void) strncpy(u->ut_user, program, sizeof (u->ut_user));
2730 (void) strcpy(fail_buf, "INIT_PROCESS");
2731 break;
2732
2733 default:
2734 (void) strlcpy(fail_buf, u->ut_id, sizeof (u->ut_id) + 1);
2735 break;
2736 }
2737
2738 /*
2739 * Write out the updated entry to utmpx file.
2740 */
2741 if (pututxline(u) == NULL) {
2742 console(B_TRUE, "Failed write of utmpx entry: \"%s\": %s\n",
2743 fail_buf, strerror(errno));
2744 endutxent();
2745 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
2746 return (-1);
2747 }
2748
2749 /*
2750 * If we're able to write to utmpx, then attempt to add to the
2751 * end of the wtmpx file.
2752 */
2753 updwtmpx(WTMPX, u);
2754
2755 endutxent();
2756
2757 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
2758
2759 return (0);
2760 }
2761
2762 static void
2763 clearent(pid_t pid, short status)
2764 {
2765 struct utmpx *up;
2766 sigset_t block, unblock;
2767
2768 /*
2769 * Block signals for utmp update.
2770 */
2771 (void) sigfillset(&block);
2772 (void) sigprocmask(SIG_BLOCK, &block, &unblock);
2773
2774 /*
2775 * No error checking for now.
2776 */
2777
2778 setutxent();
2779 while (up = getutxent()) {
2780 if (up->ut_pid == pid) {
2781 if (up->ut_type == DEAD_PROCESS) {
2782 /*
2783 * Cleaned up elsewhere.
2784 */
2785 continue;
2786 }
2787
2788 notify_pam_dead(up);
2789
2790 up->ut_type = DEAD_PROCESS;
2791 up->ut_exit.e_termination = WTERMSIG(status);
2792 up->ut_exit.e_exit = WEXITSTATUS(status);
2793 (void) time(&up->ut_tv.tv_sec);
2794
2795 (void) pututxline(up);
2796 /*
2797 * Now attempt to add to the end of the
2798 * wtmp and wtmpx files. Do not create
2799 * if they don't already exist.
2800 */
2801 updwtmpx(WTMPX, up);
2802
2803 break;
2804 }
2805 }
2806
2807 endutxent();
2808 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
2809 }
2810
2811 /*
2812 * prog_name() searches for the word or unix path name and
2813 * returns a pointer to the last element of the pathname.
2814 */
2815 static char *
2816 prog_name(char *string)
2817 {
2818 char *ptr, *ptr2;
2819 static char word[UT_USER_SZ + 1];
2820
2821 /*
2822 * Search for the first word skipping leading spaces and tabs.
2823 */
2824 while (*string == ' ' || *string == '\t')
2825 string++;
2826
2827 /*
2828 * If the first non-space non-tab character is not one allowed in
2829 * a word, return a pointer to a null string, otherwise parse the
2830 * pathname.
2831 */
2832 if (*string != '.' && *string != '/' && *string != '_' &&
2833 (*string < 'a' || *string > 'z') &&
2834 (*string < 'A' || * string > 'Z') &&
2835 (*string < '0' || *string > '9'))
2836 return ("");
2837
2838 /*
2839 * Parse the pathname looking forward for '/', ' ', '\t', '\n' or
2840 * '\0'. Each time a '/' is found, move "ptr" to one past the
2841 * '/', thus when a ' ', '\t', '\n', or '\0' is found, "ptr" will
2842 * point to the last element of the pathname.
2843 */
2844 for (ptr = string; *string != ' ' && *string != '\t' &&
2845 *string != '\n' && *string != '\0'; string++) {
2846 if (*string == '/')
2847 ptr = string+1;
2848 }
2849
2850 /*
2851 * Copy out up to the size of the "ut_user" array into "word",
2852 * null terminate it and return a pointer to it.
2853 */
2854 for (ptr2 = &word[0]; ptr2 < &word[UT_USER_SZ] &&
2855 ptr < string; /* CSTYLED */)
2856 *ptr2++ = *ptr++;
2857
2858 *ptr2 = '\0';
2859 return (&word[0]);
2860 }
2861
2862
2863 /*
2864 * realcon() returns a nonzero value if there is a character device
2865 * associated with SYSCON that has the same device number as CONSOLE.
2866 */
2867 static int
2868 realcon()
2869 {
2870 struct stat sconbuf, conbuf;
2871
2872 if (stat(SYSCON, &sconbuf) != -1 &&
2873 stat(CONSOLE, &conbuf) != -1 &&
2874 S_ISCHR(sconbuf.st_mode) &&
2875 S_ISCHR(conbuf.st_mode) &&
2876 sconbuf.st_rdev == conbuf.st_rdev) {
2877 return (1);
2878 } else {
2879 return (0);
2880 }
2881 }
2882
2883
2884 /*
2885 * get_ioctl_syscon() retrieves the SYSCON settings from the IOCTLSYSCON file.
2886 * Returns true if the IOCTLSYSCON file needs to be written (with
2887 * write_ioctl_syscon() below)
2888 */
2889 static int
2890 get_ioctl_syscon()
2891 {
2892 FILE *fp;
2893 unsigned int iflags, oflags, cflags, lflags, ldisc, cc[18];
2894 int i, valid_format = 0;
2895
2896 /*
2897 * Read in the previous modes for SYSCON from IOCTLSYSCON.
2898 */
2899 if ((fp = fopen(IOCTLSYSCON, "r")) == NULL) {
2900 stored_syscon_termios = dflt_termios;
2901 console(B_TRUE,
2902 "warning:%s does not exist, default settings assumed\n",
2903 IOCTLSYSCON);
2904 } else {
2905
2906 i = fscanf(fp,
2907 "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x",
2908 &iflags, &oflags, &cflags, &lflags,
2909 &cc[0], &cc[1], &cc[2], &cc[3], &cc[4], &cc[5], &cc[6],
2910 &cc[7], &cc[8], &cc[9], &cc[10], &cc[11], &cc[12], &cc[13],
2911 &cc[14], &cc[15], &cc[16], &cc[17]);
2912
2913 if (i == 22) {
2914 stored_syscon_termios.c_iflag = iflags;
2915 stored_syscon_termios.c_oflag = oflags;
2916 stored_syscon_termios.c_cflag = cflags;
2917 stored_syscon_termios.c_lflag = lflags;
2918 for (i = 0; i < 18; i++)
2919 stored_syscon_termios.c_cc[i] = (char)cc[i];
2920 valid_format = 1;
2921 } else if (i == 13) {
2922 rewind(fp);
2923 i = fscanf(fp, "%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x:%x",
2924 &iflags, &oflags, &cflags, &lflags, &ldisc, &cc[0], &cc[1],
2925 &cc[2], &cc[3], &cc[4], &cc[5], &cc[6], &cc[7]);
2926
2927 /*
2928 * If the file is formatted properly, use the values to
2929 * initialize the console terminal condition.
2930 */
2931 stored_syscon_termios.c_iflag = (ushort_t)iflags;
2932 stored_syscon_termios.c_oflag = (ushort_t)oflags;
2933 stored_syscon_termios.c_cflag = (ushort_t)cflags;
2934 stored_syscon_termios.c_lflag = (ushort_t)lflags;
2935 for (i = 0; i < 8; i++)
2936 stored_syscon_termios.c_cc[i] = (char)cc[i];
2937 valid_format = 1;
2938 }
2939 (void) fclose(fp);
2940
2941 /* If the file is badly formatted, use the default settings. */
2942 if (!valid_format)
2943 stored_syscon_termios = dflt_termios;
2944 }
2945
2946 /* If the file had a bad format, rewrite it later. */
2947 return (!valid_format);
2948 }
2949
2950
2951 static void
2952 write_ioctl_syscon()
2953 {
2954 FILE *fp;
2955 int i;
2956
2957 (void) unlink(SYSCON);
2958 (void) link(SYSTTY, SYSCON);
2959 (void) umask(022);
2960 fp = fopen(IOCTLSYSCON, "w");
2961
2962 (void) fprintf(fp, "%x:%x:%x:%x:0", stored_syscon_termios.c_iflag,
2963 stored_syscon_termios.c_oflag, stored_syscon_termios.c_cflag,
2964 stored_syscon_termios.c_lflag);
2965 for (i = 0; i < 8; ++i)
2966 (void) fprintf(fp, ":%x", stored_syscon_termios.c_cc[i]);
2967 (void) putc('\n', fp);
2968
2969 (void) fflush(fp);
2970 (void) fsync(fileno(fp));
2971 (void) fclose(fp);
2972 (void) umask(cmask);
2973 }
2974
2975
2976 /*
2977 * void console(boolean_t, char *, ...)
2978 * Outputs the requested message to the system console. Note that the number
2979 * of arguments passed to console() should be determined by the print format.
2980 *
2981 * The "prefix" parameter indicates whether or not "INIT: " should precede the
2982 * message.
2983 *
2984 * To make sure we write to the console in a sane fashion, we use the modes
2985 * we keep in stored_syscon_termios (which we read out of /etc/ioctl.syscon).
2986 * Afterwards we restore whatever modes were already there.
2987 */
2988 /* PRINTFLIKE2 */
2989 static void
2990 console(boolean_t prefix, char *format, ...)
2991 {
2992 char outbuf[BUFSIZ];
2993 va_list args;
2994 int fd, getret;
2995 struct termios old_syscon_termios;
2996 FILE *f;
2997
2998 /*
2999 * We open SYSCON anew each time in case it has changed (see
3000 * userinit()).
3001 */
3002 if ((fd = open(SYSCON, O_RDWR | O_NOCTTY)) < 0 ||
3003 (f = fdopen(fd, "r+")) == NULL) {
3004 if (prefix)
3005 syslog(LOG_WARNING, "INIT: ");
3006 va_start(args, format);
3007 vsyslog(LOG_WARNING, format, args);
3008 va_end(args);
3009 if (fd >= 0)
3010 (void) close(fd);
3011 return;
3012 }
3013 setbuf(f, &outbuf[0]);
3014
3015 getret = tcgetattr(fd, &old_syscon_termios);
3016 old_syscon_termios.c_cflag &= ~HUPCL;
3017 if (realcon())
3018 /* Don't overwrite cflag of real console. */
3019 stored_syscon_termios.c_cflag = old_syscon_termios.c_cflag;
3020
3021 stored_syscon_termios.c_cflag &= ~HUPCL;
3022
3023 (void) tcsetattr(fd, TCSANOW, &stored_syscon_termios);
3024
3025 if (prefix)
3026 (void) fprintf(f, "\nINIT: ");
3027 va_start(args, format);
3028 (void) vfprintf(f, format, args);
3029 va_end(args);
3030
3031 if (getret == 0)
3032 (void) tcsetattr(fd, TCSADRAIN, &old_syscon_termios);
3033
3034 (void) fclose(f);
3035 }
3036
3037 /*
3038 * timer() is a substitute for sleep() which uses alarm() and pause().
3039 */
3040 static void
3041 timer(int waitime)
3042 {
3043 setimer(waitime);
3044 while (time_up == FALSE)
3045 (void) pause();
3046 }
3047
3048 static void
3049 setimer(int timelimit)
3050 {
3051 alarmclk();
3052 (void) alarm(timelimit);
3053 time_up = (timelimit ? FALSE : TRUE);
3054 }
3055
3056 /*
3057 * Fails with
3058 * ENOMEM - out of memory
3059 * ECONNABORTED - repository connection broken
3060 * EPERM - permission denied
3061 * EACCES - backend access denied
3062 * EROFS - backend readonly
3063 */
3064 static int
3065 get_or_add_startd(scf_instance_t *inst)
3066 {
3067 scf_handle_t *h;
3068 scf_scope_t *scope = NULL;
3069 scf_service_t *svc = NULL;
3070 int ret = 0;
3071
3072 h = scf_instance_handle(inst);
3073
3074 if (scf_handle_decode_fmri(h, SCF_SERVICE_STARTD, NULL, NULL, inst,
3075 NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0)
3076 return (0);
3077
3078 switch (scf_error()) {
3079 case SCF_ERROR_CONNECTION_BROKEN:
3080 return (ECONNABORTED);
3081
3082 case SCF_ERROR_NOT_FOUND:
3083 break;
3084
3085 case SCF_ERROR_HANDLE_MISMATCH:
3086 case SCF_ERROR_INVALID_ARGUMENT:
3087 case SCF_ERROR_CONSTRAINT_VIOLATED:
3088 default:
3089 bad_error("scf_handle_decode_fmri", scf_error());
3090 }
3091
3092 /* Make sure we're right, since we're adding piece-by-piece. */
3093 assert(strcmp(SCF_SERVICE_STARTD,
3094 "svc:/system/svc/restarter:default") == 0);
3095
3096 if ((scope = scf_scope_create(h)) == NULL ||
3097 (svc = scf_service_create(h)) == NULL) {
3098 ret = ENOMEM;
3099 goto out;
3100 }
3101
3102 get_scope:
3103 if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, scope) != 0) {
3104 switch (scf_error()) {
3105 case SCF_ERROR_CONNECTION_BROKEN:
3106 ret = ECONNABORTED;
3107 goto out;
3108
3109 case SCF_ERROR_NOT_FOUND:
3110 (void) fputs(gettext(
3111 "smf(5) repository missing local scope.\n"),
3112 stderr);
3113 exit(1);
3114 /* NOTREACHED */
3115
3116 case SCF_ERROR_HANDLE_MISMATCH:
3117 case SCF_ERROR_INVALID_ARGUMENT:
3118 default:
3119 bad_error("scf_handle_get_scope", scf_error());
3120 }
3121 }
3122
3123 get_svc:
3124 if (scf_scope_get_service(scope, "system/svc/restarter", svc) != 0) {
3125 switch (scf_error()) {
3126 case SCF_ERROR_CONNECTION_BROKEN:
3127 ret = ECONNABORTED;
3128 goto out;
3129
3130 case SCF_ERROR_DELETED:
3131 goto get_scope;
3132
3133 case SCF_ERROR_NOT_FOUND:
3134 break;
3135
3136 case SCF_ERROR_HANDLE_MISMATCH:
3137 case SCF_ERROR_INVALID_ARGUMENT:
3138 case SCF_ERROR_NOT_SET:
3139 default:
3140 bad_error("scf_scope_get_service", scf_error());
3141 }
3142
3143 add_svc:
3144 if (scf_scope_add_service(scope, "system/svc/restarter", svc) !=
3145 0) {
3146 switch (scf_error()) {
3147 case SCF_ERROR_CONNECTION_BROKEN:
3148 ret = ECONNABORTED;
3149 goto out;
3150
3151 case SCF_ERROR_EXISTS:
3152 goto get_svc;
3153
3154 case SCF_ERROR_PERMISSION_DENIED:
3155 ret = EPERM;
3156 goto out;
3157
3158 case SCF_ERROR_BACKEND_ACCESS:
3159 ret = EACCES;
3160 goto out;
3161
3162 case SCF_ERROR_BACKEND_READONLY:
3163 ret = EROFS;
3164 goto out;
3165
3166 case SCF_ERROR_HANDLE_MISMATCH:
3167 case SCF_ERROR_INVALID_ARGUMENT:
3168 case SCF_ERROR_NOT_SET:
3169 default:
3170 bad_error("scf_scope_add_service", scf_error());
3171 }
3172 }
3173 }
3174
3175 get_inst:
3176 if (scf_service_get_instance(svc, "default", inst) != 0) {
3177 switch (scf_error()) {
3178 case SCF_ERROR_CONNECTION_BROKEN:
3179 ret = ECONNABORTED;
3180 goto out;
3181
3182 case SCF_ERROR_DELETED:
3183 goto add_svc;
3184
3185 case SCF_ERROR_NOT_FOUND:
3186 break;
3187
3188 case SCF_ERROR_HANDLE_MISMATCH:
3189 case SCF_ERROR_INVALID_ARGUMENT:
3190 case SCF_ERROR_NOT_SET:
3191 default:
3192 bad_error("scf_service_get_instance", scf_error());
3193 }
3194
3195 if (scf_service_add_instance(svc, "default", inst) !=
3196 0) {
3197 switch (scf_error()) {
3198 case SCF_ERROR_CONNECTION_BROKEN:
3199 ret = ECONNABORTED;
3200 goto out;
3201
3202 case SCF_ERROR_DELETED:
3203 goto add_svc;
3204
3205 case SCF_ERROR_EXISTS:
3206 goto get_inst;
3207
3208 case SCF_ERROR_PERMISSION_DENIED:
3209 ret = EPERM;
3210 goto out;
3211
3212 case SCF_ERROR_BACKEND_ACCESS:
3213 ret = EACCES;
3214 goto out;
3215
3216 case SCF_ERROR_BACKEND_READONLY:
3217 ret = EROFS;
3218 goto out;
3219
3220 case SCF_ERROR_HANDLE_MISMATCH:
3221 case SCF_ERROR_INVALID_ARGUMENT:
3222 case SCF_ERROR_NOT_SET:
3223 default:
3224 bad_error("scf_service_add_instance",
3225 scf_error());
3226 }
3227 }
3228 }
3229
3230 ret = 0;
3231
3232 out:
3233 scf_service_destroy(svc);
3234 scf_scope_destroy(scope);
3235 return (ret);
3236 }
3237
3238 /*
3239 * Fails with
3240 * ECONNABORTED - repository connection broken
3241 * ECANCELED - the transaction's property group was deleted
3242 */
3243 static int
3244 transaction_add_set(scf_transaction_t *tx, scf_transaction_entry_t *ent,
3245 const char *pname, scf_type_t type)
3246 {
3247 change_type:
3248 if (scf_transaction_property_change_type(tx, ent, pname, type) == 0)
3249 return (0);
3250
3251 switch (scf_error()) {
3252 case SCF_ERROR_CONNECTION_BROKEN:
3253 return (ECONNABORTED);
3254
3255 case SCF_ERROR_DELETED:
3256 return (ECANCELED);
3257
3258 case SCF_ERROR_NOT_FOUND:
3259 goto new;
3260
3261 case SCF_ERROR_HANDLE_MISMATCH:
3262 case SCF_ERROR_INVALID_ARGUMENT:
3263 case SCF_ERROR_NOT_BOUND:
3264 case SCF_ERROR_NOT_SET:
3265 default:
3266 bad_error("scf_transaction_property_change_type", scf_error());
3267 }
3268
3269 new:
3270 if (scf_transaction_property_new(tx, ent, pname, type) == 0)
3271 return (0);
3272
3273 switch (scf_error()) {
3274 case SCF_ERROR_CONNECTION_BROKEN:
3275 return (ECONNABORTED);
3276
3277 case SCF_ERROR_DELETED:
3278 return (ECANCELED);
3279
3280 case SCF_ERROR_EXISTS:
3281 goto change_type;
3282
3283 case SCF_ERROR_HANDLE_MISMATCH:
3284 case SCF_ERROR_INVALID_ARGUMENT:
3285 case SCF_ERROR_NOT_BOUND:
3286 case SCF_ERROR_NOT_SET:
3287 default:
3288 bad_error("scf_transaction_property_new", scf_error());
3289 /* NOTREACHED */
3290 }
3291 }
3292
3293 static void
3294 scferr(void)
3295 {
3296 switch (scf_error()) {
3297 case SCF_ERROR_NO_MEMORY:
3298 console(B_TRUE, gettext("Out of memory.\n"));
3299 break;
3300
3301 case SCF_ERROR_CONNECTION_BROKEN:
3302 console(B_TRUE, gettext(
3303 "Connection to smf(5) repository server broken.\n"));
3304 break;
3305
3306 case SCF_ERROR_NO_RESOURCES:
3307 console(B_TRUE, gettext(
3308 "smf(5) repository server is out of memory.\n"));
3309 break;
3310
3311 case SCF_ERROR_PERMISSION_DENIED:
3312 console(B_TRUE, gettext("Insufficient privileges.\n"));
3313 break;
3314
3315 default:
3316 console(B_TRUE, gettext("libscf error: %s\n"),
3317 scf_strerror(scf_error()));
3318 }
3319 }
3320
3321 static void
3322 lscf_set_runlevel(char rl)
3323 {
3324 scf_handle_t *h;
3325 scf_instance_t *inst = NULL;
3326 scf_propertygroup_t *pg = NULL;
3327 scf_transaction_t *tx = NULL;
3328 scf_transaction_entry_t *ent = NULL;
3329 scf_value_t *val = NULL;
3330 char buf[2];
3331 int r;
3332
3333 h = scf_handle_create(SCF_VERSION);
3334 if (h == NULL) {
3335 scferr();
3336 return;
3337 }
3338
3339 if (scf_handle_bind(h) != 0) {
3340 switch (scf_error()) {
3341 case SCF_ERROR_NO_SERVER:
3342 console(B_TRUE,
3343 gettext("smf(5) repository server not running.\n"));
3344 goto bail;
3345
3346 default:
3347 scferr();
3348 goto bail;
3349 }
3350 }
3351
3352 if ((inst = scf_instance_create(h)) == NULL ||
3353 (pg = scf_pg_create(h)) == NULL ||
3354 (val = scf_value_create(h)) == NULL ||
3355 (tx = scf_transaction_create(h)) == NULL ||
3356 (ent = scf_entry_create(h)) == NULL) {
3357 scferr();
3358 goto bail;
3359 }
3360
3361 get_inst:
3362 r = get_or_add_startd(inst);
3363 switch (r) {
3364 case 0:
3365 break;
3366
3367 case ENOMEM:
3368 case ECONNABORTED:
3369 case EPERM:
3370 case EACCES:
3371 case EROFS:
3372 scferr();
3373 goto bail;
3374 default:
3375 bad_error("get_or_add_startd", r);
3376 }
3377
3378 get_pg:
3379 if (scf_instance_get_pg(inst, SCF_PG_OPTIONS_OVR, pg) != 0) {
3380 switch (scf_error()) {
3381 case SCF_ERROR_CONNECTION_BROKEN:
3382 scferr();
3383 goto bail;
3384
3385 case SCF_ERROR_DELETED:
3386 goto get_inst;
3387
3388 case SCF_ERROR_NOT_FOUND:
3389 break;
3390
3391 case SCF_ERROR_HANDLE_MISMATCH:
3392 case SCF_ERROR_INVALID_ARGUMENT:
3393 case SCF_ERROR_NOT_SET:
3394 default:
3395 bad_error("scf_instance_get_pg", scf_error());
3396 }
3397
3398 add_pg:
3399 if (scf_instance_add_pg(inst, SCF_PG_OPTIONS_OVR,
3400 SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS, pg) !=
3401 0) {
3402 switch (scf_error()) {
3403 case SCF_ERROR_CONNECTION_BROKEN:
3404 case SCF_ERROR_PERMISSION_DENIED:
3405 case SCF_ERROR_BACKEND_ACCESS:
3406 scferr();
3407 goto bail;
3408
3409 case SCF_ERROR_DELETED:
3410 goto get_inst;
3411
3412 case SCF_ERROR_EXISTS:
3413 goto get_pg;
3414
3415 case SCF_ERROR_HANDLE_MISMATCH:
3416 case SCF_ERROR_INVALID_ARGUMENT:
3417 case SCF_ERROR_NOT_SET:
3418 default:
3419 bad_error("scf_instance_add_pg", scf_error());
3420 }
3421 }
3422 }
3423
3424 buf[0] = rl;
3425 buf[1] = '\0';
3426 r = scf_value_set_astring(val, buf);
3427 assert(r == 0);
3428
3429 for (;;) {
3430 if (scf_transaction_start(tx, pg) != 0) {
3431 switch (scf_error()) {
3432 case SCF_ERROR_CONNECTION_BROKEN:
3433 case SCF_ERROR_PERMISSION_DENIED:
3434 case SCF_ERROR_BACKEND_ACCESS:
3435 scferr();
3436 goto bail;
3437
3438 case SCF_ERROR_DELETED:
3439 goto add_pg;
3440
3441 case SCF_ERROR_HANDLE_MISMATCH:
3442 case SCF_ERROR_NOT_BOUND:
3443 case SCF_ERROR_IN_USE:
3444 case SCF_ERROR_NOT_SET:
3445 default:
3446 bad_error("scf_transaction_start", scf_error());
3447 }
3448 }
3449
3450 r = transaction_add_set(tx, ent, "runlevel", SCF_TYPE_ASTRING);
3451 switch (r) {
3452 case 0:
3453 break;
3454
3455 case ECONNABORTED:
3456 scferr();
3457 goto bail;
3458
3459 case ECANCELED:
3460 scf_transaction_reset(tx);
3461 goto add_pg;
3462
3463 default:
3464 bad_error("transaction_add_set", r);
3465 }
3466
3467 r = scf_entry_add_value(ent, val);
3468 assert(r == 0);
3469
3470 r = scf_transaction_commit(tx);
3471 if (r == 1)
3472 break;
3473
3474 if (r != 0) {
3475 switch (scf_error()) {
3476 case SCF_ERROR_CONNECTION_BROKEN:
3477 case SCF_ERROR_PERMISSION_DENIED:
3478 case SCF_ERROR_BACKEND_ACCESS:
3479 case SCF_ERROR_BACKEND_READONLY:
3480 scferr();
3481 goto bail;
3482
3483 case SCF_ERROR_DELETED:
3484 scf_transaction_reset(tx);
3485 goto add_pg;
3486
3487 case SCF_ERROR_INVALID_ARGUMENT:
3488 case SCF_ERROR_NOT_BOUND:
3489 case SCF_ERROR_NOT_SET:
3490 default:
3491 bad_error("scf_transaction_commit",
3492 scf_error());
3493 }
3494 }
3495
3496 scf_transaction_reset(tx);
3497 (void) scf_pg_update(pg);
3498 }
3499
3500 bail:
3501 scf_transaction_destroy(tx);
3502 scf_entry_destroy(ent);
3503 scf_value_destroy(val);
3504 scf_pg_destroy(pg);
3505 scf_instance_destroy(inst);
3506
3507 (void) scf_handle_unbind(h);
3508 scf_handle_destroy(h);
3509 }
3510
3511 /*
3512 * Function to handle requests from users to main init running as process 1.
3513 */
3514 static void
3515 userinit(int argc, char **argv)
3516 {
3517 FILE *fp;
3518 char *ln;
3519 int init_signal;
3520 struct stat sconbuf, conbuf;
3521 const char *usage_msg = "Usage: init [0123456SsQqabc]\n";
3522
3523 /*
3524 * We are a user invoked init. Is there an argument and is it
3525 * a single character? If not, print usage message and quit.
3526 */
3527 if (argc != 2 || argv[1][1] != '\0') {
3528 (void) fprintf(stderr, usage_msg);
3529 exit(0);
3530 }
3531
3532 if ((init_signal = lvlname_to_state((char)argv[1][0])) == -1) {
3533 (void) fprintf(stderr, usage_msg);
3534 (void) audit_put_record(ADT_FAILURE, ADT_FAIL_VALUE_BAD_CMD,
3535 argv[1]);
3536 exit(1);
3537 }
3538
3539 if (init_signal == SINGLE_USER) {
3540 /*
3541 * Make sure this process is talking to a legal tty line
3542 * and that /dev/syscon is linked to this line.
3543 */
3544 ln = ttyname(0); /* Get the name of tty */
3545 if (ln == NULL) {
3546 (void) fprintf(stderr,
3547 "Standard input not a tty line\n");
3548 (void) audit_put_record(ADT_FAILURE,
3549 ADT_FAIL_VALUE_BAD_TTY, argv[1]);
3550 exit(1);
3551 }
3552
3553 if ((stat(ln, &sconbuf) != -1) &&
3554 (stat(SYSCON, &conbuf) == -1 ||
3555 sconbuf.st_rdev != conbuf.st_rdev)) {
3556 /*
3557 * /dev/syscon needs to change.
3558 * Unlink /dev/syscon and relink it to the current line.
3559 */
3560 if (lstat(SYSCON, &conbuf) != -1 &&
3561 unlink(SYSCON) == FAILURE) {
3562 perror("Can't unlink /dev/syscon");
3563 (void) fprintf(stderr,
3564 "Run command on the system console.\n");
3565 (void) audit_put_record(ADT_FAILURE,
3566 ADT_FAIL_VALUE_PROGRAM, argv[1]);
3567 exit(1);
3568 }
3569 if (symlink(ln, SYSCON) == FAILURE) {
3570 (void) fprintf(stderr,
3571 "Can't symlink /dev/syscon to %s: %s", ln,
3572 strerror(errno));
3573
3574 /* Try to leave a syscon */
3575 (void) link(SYSTTY, SYSCON);
3576 (void) audit_put_record(ADT_FAILURE,
3577 ADT_FAIL_VALUE_PROGRAM, argv[1]);
3578 exit(1);
3579 }
3580
3581 /*
3582 * Try to leave a message on system console saying where
3583 * /dev/syscon is currently connected.
3584 */
3585 if ((fp = fopen(SYSTTY, "r+")) != NULL) {
3586 (void) fprintf(fp,
3587 "\n**** SYSCON CHANGED TO %s ****\n",
3588 ln);
3589 (void) fclose(fp);
3590 }
3591 }
3592 }
3593
3594 update_boot_archive(init_signal);
3595
3596 (void) audit_put_record(ADT_SUCCESS, ADT_SUCCESS, argv[1]);
3597
3598 /*
3599 * Signal init; init will take care of telling svc.startd.
3600 */
3601 if (kill(init_pid, init_signal) == FAILURE) {
3602 (void) fprintf(stderr, "Must be super-user\n");
3603 (void) audit_put_record(ADT_FAILURE,
3604 ADT_FAIL_VALUE_AUTH, argv[1]);
3605 exit(1);
3606 }
3607
3608 exit(0);
3609 }
3610
3611
3612 #define DELTA 25 /* Number of pidlist elements to allocate at a time */
3613
3614 /* ARGSUSED */
3615 void
3616 sigpoll(int n)
3617 {
3618 struct pidrec prec;
3619 struct pidrec *p = ≺
3620 struct pidlist *plp;
3621 struct pidlist *tp, *savetp;
3622 int i;
3623
3624 if (Pfd < 0) {
3625 return;
3626 }
3627
3628 for (;;) {
3629 /*
3630 * Important Note: Either read will really fail (in which case
3631 * return is all we can do) or will get EAGAIN (Pfd was opened
3632 * O_NDELAY), in which case we also want to return.
3633 * Always return from here!
3634 */
3635 if (read(Pfd, p, sizeof (struct pidrec)) !=
3636 sizeof (struct pidrec)) {
3637 return;
3638 }
3639 switch (p->pd_type) {
3640
3641 case ADDPID:
3642 /*
3643 * New "godchild", add to list.
3644 */
3645 if (Plfree == NULL) {
3646 plp = (struct pidlist *)calloc(DELTA,
3647 sizeof (struct pidlist));
3648 if (plp == NULL) {
3649 /* Can't save pid */
3650 break;
3651 }
3652 /*
3653 * Point at 2nd record allocated, we'll use plp.
3654 */
3655 tp = plp + 1;
3656 /*
3657 * Link them into a chain.
3658 */
3659 Plfree = tp;
3660 for (i = 0; i < DELTA - 2; i++) {
3661 tp->pl_next = tp + 1;
3662 tp++;
3663 }
3664 } else {
3665 plp = Plfree;
3666 Plfree = plp->pl_next;
3667 }
3668 plp->pl_pid = p->pd_pid;
3669 plp->pl_dflag = 0;
3670 plp->pl_next = NULL;
3671 /*
3672 * Note - pid list is kept in increasing order of pids.
3673 */
3674 if (Plhead == NULL) {
3675 Plhead = plp;
3676 /* Back up to read next record */
3677 break;
3678 } else {
3679 savetp = tp = Plhead;
3680 while (tp) {
3681 if (plp->pl_pid > tp->pl_pid) {
3682 savetp = tp;
3683 tp = tp->pl_next;
3684 continue;
3685 } else if (plp->pl_pid < tp->pl_pid) {
3686 if (tp == Plhead) {
3687 plp->pl_next = Plhead;
3688 Plhead = plp;
3689 } else {
3690 plp->pl_next =
3691 savetp->pl_next;
3692 savetp->pl_next = plp;
3693 }
3694 break;
3695 } else {
3696 /* Already in list! */
3697 plp->pl_next = Plfree;
3698 Plfree = plp;
3699 break;
3700 }
3701 }
3702 if (tp == NULL) {
3703 /* Add to end of list */
3704 savetp->pl_next = plp;
3705 }
3706 }
3707 /* Back up to read next record. */
3708 break;
3709
3710 case REMPID:
3711 /*
3712 * This one was handled by someone else,
3713 * purge it from the list.
3714 */
3715 if (Plhead == NULL) {
3716 /* Back up to read next record. */
3717 break;
3718 }
3719 savetp = tp = Plhead;
3720 while (tp) {
3721 if (p->pd_pid > tp->pl_pid) {
3722 /* Keep on looking. */
3723 savetp = tp;
3724 tp = tp->pl_next;
3725 continue;
3726 } else if (p->pd_pid < tp->pl_pid) {
3727 /* Not in list. */
3728 break;
3729 } else {
3730 /* Found it. */
3731 if (tp == Plhead)
3732 Plhead = tp->pl_next;
3733 else
3734 savetp->pl_next = tp->pl_next;
3735 tp->pl_next = Plfree;
3736 Plfree = tp;
3737 break;
3738 }
3739 }
3740 /* Back up to read next record. */
3741 break;
3742 default:
3743 console(B_TRUE, "Bad message on initpipe\n");
3744 break;
3745 }
3746 }
3747 }
3748
3749
3750 static void
3751 cleanaux()
3752 {
3753 struct pidlist *savep, *p;
3754 pid_t pid;
3755 short status;
3756
3757 (void) sighold(SIGCLD);
3758 Gchild = 0; /* Note - Safe to do this here since no SIGCLDs */
3759 (void) sighold(SIGPOLL);
3760 savep = p = Plhead;
3761 while (p) {
3762 if (p->pl_dflag) {
3763 /*
3764 * Found an entry to delete,
3765 * remove it from list first.
3766 */
3767 pid = p->pl_pid;
3768 status = p->pl_exit;
3769 if (p == Plhead) {
3770 Plhead = p->pl_next;
3771 p->pl_next = Plfree;
3772 Plfree = p;
3773 savep = p = Plhead;
3774 } else {
3775 savep->pl_next = p->pl_next;
3776 p->pl_next = Plfree;
3777 Plfree = p;
3778 p = savep->pl_next;
3779 }
3780 clearent(pid, status);
3781 continue;
3782 }
3783 savep = p;
3784 p = p->pl_next;
3785 }
3786 (void) sigrelse(SIGPOLL);
3787 (void) sigrelse(SIGCLD);
3788 }
3789
3790
3791 /*
3792 * /etc/inittab has more entries and we have run out of room in the proc_table
3793 * array. Double the size of proc_table to accomodate the extra entries.
3794 */
3795 static void
3796 increase_proc_table_size()
3797 {
3798 sigset_t block, unblock;
3799 void *ptr;
3800 size_t delta = num_proc * sizeof (struct PROC_TABLE);
3801
3802
3803 /*
3804 * Block signals for realloc.
3805 */
3806 (void) sigfillset(&block);
3807 (void) sigprocmask(SIG_BLOCK, &block, &unblock);
3808
3809
3810 /*
3811 * On failure we just return because callers of this function check
3812 * for failure.
3813 */
3814 do
3815 ptr = realloc(g_state, g_state_sz + delta);
3816 while (ptr == NULL && errno == EAGAIN)
3817 ;
3818
3819 if (ptr != NULL) {
3820 /* ensure that the new part is initialized to zero */
3821 bzero((caddr_t)ptr + g_state_sz, delta);
3822
3823 g_state = ptr;
3824 g_state_sz += delta;
3825 num_proc <<= 1;
3826 }
3827
3828
3829 /* unblock our signals before returning */
3830 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
3831 }
3832
3833
3834
3835 /*
3836 * Sanity check g_state.
3837 */
3838 static int
3839 st_sane()
3840 {
3841 int i;
3842 struct PROC_TABLE *ptp;
3843
3844
3845 /* Note: cur_state is encoded as a signal number */
3846 if (cur_state < 1 || cur_state == 9 || cur_state > 13)
3847 return (0);
3848
3849 /* Check num_proc */
3850 if (g_state_sz != sizeof (struct init_state) + (num_proc - 1) *
3851 sizeof (struct PROC_TABLE))
3852 return (0);
3853
3854 /* Check proc_table */
3855 for (i = 0, ptp = proc_table; i < num_proc; ++i, ++ptp) {
3856 /* skip unoccupied entries */
3857 if (!(ptp->p_flags & OCCUPIED))
3858 continue;
3859
3860 /* p_flags has no bits outside of PF_MASK */
3861 if (ptp->p_flags & ~(PF_MASK))
3862 return (0);
3863
3864 /* 5 <= pid <= MAXPID */
3865 if (ptp->p_pid < 5 || ptp->p_pid > MAXPID)
3866 return (0);
3867
3868 /* p_count >= 0 */
3869 if (ptp->p_count < 0)
3870 return (0);
3871
3872 /* p_time >= 0 */
3873 if (ptp->p_time < 0)
3874 return (0);
3875 }
3876
3877 return (1);
3878 }
3879
3880 /*
3881 * Initialize our state.
3882 *
3883 * If the system just booted, then init_state_file, which is located on an
3884 * everpresent tmpfs filesystem, should not exist.
3885 *
3886 * If we were restarted, then init_state_file should exist, in
3887 * which case we'll read it in, sanity check it, and use it.
3888 *
3889 * Note: You can't call console() until proc_table is ready.
3890 */
3891 void
3892 st_init()
3893 {
3894 struct stat stb;
3895 int ret, st_fd, insane = 0;
3896 size_t to_be_read;
3897 char *ptr;
3898
3899
3900 booting = 1;
3901
3902 do {
3903 /*
3904 * If we can exclusively create the file, then we're the
3905 * initial invocation of init(1M).
3906 */
3907 st_fd = open(init_state_file, O_RDWR | O_CREAT | O_EXCL,
3908 S_IRUSR | S_IWUSR);
3909 } while (st_fd == -1 && errno == EINTR);
3910 if (st_fd != -1)
3911 goto new_state;
3912
3913 booting = 0;
3914
3915 do {
3916 st_fd = open(init_state_file, O_RDWR, S_IRUSR | S_IWUSR);
3917 } while (st_fd == -1 && errno == EINTR);
3918 if (st_fd == -1)
3919 goto new_state;
3920
3921 /* Get the size of the file. */
3922 do
3923 ret = fstat(st_fd, &stb);
3924 while (ret == -1 && errno == EINTR)
3925 ;
3926 if (ret == -1)
3927 goto new_state;
3928
3929 do
3930 g_state = malloc(stb.st_size);
3931 while (g_state == NULL && errno == EAGAIN)
3932 ;
3933 if (g_state == NULL)
3934 goto new_state;
3935
3936 to_be_read = stb.st_size;
3937 ptr = (char *)g_state;
3938 while (to_be_read > 0) {
3939 ssize_t read_ret;
3940
3941 read_ret = read(st_fd, ptr, to_be_read);
3942 if (read_ret < 0) {
3943 if (errno == EINTR)
3944 continue;
3945
3946 goto new_state;
3947 }
3948
3949 to_be_read -= read_ret;
3950 ptr += read_ret;
3951 }
3952
3953 (void) close(st_fd);
3954
3955 g_state_sz = stb.st_size;
3956
3957 if (st_sane()) {
3958 console(B_TRUE, "Restarting.\n");
3959 return;
3960 }
3961
3962 insane = 1;
3963
3964 new_state:
3965 if (st_fd >= 0)
3966 (void) close(st_fd);
3967 else
3968 (void) unlink(init_state_file);
3969
3970 if (g_state != NULL)
3971 free(g_state);
3972
3973 /* Something went wrong, so allocate new state. */
3974 g_state_sz = sizeof (struct init_state) +
3975 ((init_num_proc - 1) * sizeof (struct PROC_TABLE));
3976 do
3977 g_state = calloc(1, g_state_sz);
3978 while (g_state == NULL && errno == EAGAIN)
3979 ;
3980 if (g_state == NULL) {
3981 /* Fatal error! */
3982 exit(errno);
3983 }
3984
3985 g_state->ist_runlevel = -1;
3986 num_proc = init_num_proc;
3987
3988 if (!booting) {
3989 console(B_TRUE, "Restarting.\n");
3990
3991 /* Overwrite the bad state file. */
3992 st_write();
3993
3994 if (!insane) {
3995 console(B_TRUE,
3996 "Error accessing persistent state file `%s'. "
3997 "Ignored.\n", init_state_file);
3998 } else {
3999 console(B_TRUE,
4000 "Persistent state file `%s' is invalid and was "
4001 "ignored.\n", init_state_file);
4002 }
4003 }
4004 }
4005
4006 /*
4007 * Write g_state out to the state file.
4008 */
4009 void
4010 st_write()
4011 {
4012 static int complained = 0;
4013
4014 int st_fd;
4015 char *cp;
4016 size_t sz;
4017 ssize_t ret;
4018
4019
4020 do {
4021 st_fd = open(init_next_state_file,
4022 O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
4023 } while (st_fd < 0 && errno == EINTR);
4024 if (st_fd < 0)
4025 goto err;
4026
4027 cp = (char *)g_state;
4028 sz = g_state_sz;
4029 while (sz > 0) {
4030 ret = write(st_fd, cp, sz);
4031 if (ret < 0) {
4032 if (errno == EINTR)
4033 continue;
4034
4035 goto err;
4036 }
4037
4038 sz -= ret;
4039 cp += ret;
4040 }
4041
4042 (void) close(st_fd);
4043 st_fd = -1;
4044 if (rename(init_next_state_file, init_state_file)) {
4045 (void) unlink(init_next_state_file);
4046 goto err;
4047 }
4048 complained = 0;
4049
4050 return;
4051
4052 err:
4053 if (st_fd >= 0)
4054 (void) close(st_fd);
4055
4056 if (!booting && !complained) {
4057 /*
4058 * Only complain after the filesystem should have come up.
4059 * And only do it once so we don't loop between console()
4060 * & efork().
4061 */
4062 complained = 1;
4063 if (st_fd)
4064 console(B_TRUE, "Couldn't write persistent state "
4065 "file `%s'.\n", init_state_file);
4066 else
4067 console(B_TRUE, "Couldn't move persistent state "
4068 "file `%s' to `%s'.\n", init_next_state_file,
4069 init_state_file);
4070 }
4071 }
4072
4073 /*
4074 * Create a contract with these parameters.
4075 */
4076 static int
4077 contract_make_template(uint_t info, uint_t critical, uint_t fatal,
4078 uint64_t cookie)
4079 {
4080 int fd, err;
4081
4082 char *ioctl_tset_emsg =
4083 "Couldn't set \"%s\" contract template parameter: %s.\n";
4084
4085 do
4086 fd = open64(CTFS_ROOT "/process/template", O_RDWR);
4087 while (fd < 0 && errno == EINTR)
4088 ;
4089 if (fd < 0) {
4090 console(B_TRUE, "Couldn't create process template: %s.\n",
4091 strerror(errno));
4092 return (-1);
4093 }
4094
4095 if (err = ct_pr_tmpl_set_param(fd, CT_PR_INHERIT | CT_PR_REGENT))
4096 console(B_TRUE, "Contract set template inherit, regent "
4097 "failed: %s.\n", strerror(err));
4098
4099 /*
4100 * These errors result in a misconfigured template, which is better
4101 * than no template at all, so warn but don't abort.
4102 */
4103 if (err = ct_tmpl_set_informative(fd, info))
4104 console(B_TRUE, ioctl_tset_emsg, "informative", strerror(err));
4105
4106 if (err = ct_tmpl_set_critical(fd, critical))
4107 console(B_TRUE, ioctl_tset_emsg, "critical", strerror(err));
4108
4109 if (err = ct_pr_tmpl_set_fatal(fd, fatal))
4110 console(B_TRUE, ioctl_tset_emsg, "fatal", strerror(err));
4111
4112 if (err = ct_tmpl_set_cookie(fd, cookie))
4113 console(B_TRUE, ioctl_tset_emsg, "cookie", strerror(err));
4114
4115 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
4116
4117 return (fd);
4118 }
4119
4120 /*
4121 * Create the templates and open an event file descriptor. We use dup2(2) to
4122 * get these descriptors away from the stdin/stdout/stderr group.
4123 */
4124 static void
4125 contracts_init()
4126 {
4127 int err, fd;
4128
4129 /*
4130 * Create & configure a legacy template. We only want empty events so
4131 * we know when to abandon them.
4132 */
4133 legacy_tmpl = contract_make_template(0, CT_PR_EV_EMPTY, CT_PR_EV_HWERR,
4134 ORDINARY_COOKIE);
4135 if (legacy_tmpl >= 0) {
4136 err = ct_tmpl_activate(legacy_tmpl);
4137 if (err != 0) {
4138 (void) close(legacy_tmpl);
4139 legacy_tmpl = -1;
4140 console(B_TRUE,
4141 "Couldn't activate legacy template (%s); "
4142 "legacy services will be in init's contract.\n",
4143 strerror(err));
4144 }
4145 } else
4146 console(B_TRUE,
4147 "Legacy services will be in init's contract.\n");
4148
4149 if (dup2(legacy_tmpl, 255) == -1) {
4150 console(B_TRUE, "Could not duplicate legacy template: %s.\n",
4151 strerror(errno));
4152 } else {
4153 (void) close(legacy_tmpl);
4154 legacy_tmpl = 255;
4155 }
4156
4157 (void) fcntl(legacy_tmpl, F_SETFD, FD_CLOEXEC);
4158
4159 startd_tmpl = contract_make_template(0, CT_PR_EV_EMPTY,
4160 CT_PR_EV_HWERR | CT_PR_EV_SIGNAL | CT_PR_EV_CORE, STARTD_COOKIE);
4161
4162 if (dup2(startd_tmpl, 254) == -1) {
4163 console(B_TRUE, "Could not duplicate startd template: %s.\n",
4164 strerror(errno));
4165 } else {
4166 (void) close(startd_tmpl);
4167 startd_tmpl = 254;
4168 }
4169
4170 (void) fcntl(startd_tmpl, F_SETFD, FD_CLOEXEC);
4171
4172 if (legacy_tmpl < 0 && startd_tmpl < 0) {
4173 /* The creation errors have already been reported. */
4174 console(B_TRUE,
4175 "Ignoring contract events. Core smf(5) services will not "
4176 "be restarted.\n");
4177 return;
4178 }
4179
4180 /*
4181 * Open an event endpoint.
4182 */
4183 do
4184 fd = open64(CTFS_ROOT "/process/pbundle", O_RDONLY);
4185 while (fd < 0 && errno == EINTR)
4186 ;
4187 if (fd < 0) {
4188 console(B_TRUE,
4189 "Couldn't open process pbundle: %s. Core smf(5) services "
4190 "will not be restarted.\n", strerror(errno));
4191 return;
4192 }
4193
4194 if (dup2(fd, 253) == -1) {
4195 console(B_TRUE, "Could not duplicate process bundle: %s.\n",
4196 strerror(errno));
4197 } else {
4198 (void) close(fd);
4199 fd = 253;
4200 }
4201
4202 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
4203
4204 /* Reset in case we've been restarted. */
4205 (void) ct_event_reset(fd);
4206
4207 poll_fds[0].fd = fd;
4208 poll_fds[0].events = POLLIN;
4209 poll_nfds = 1;
4210 }
4211
4212 static int
4213 contract_getfile(ctid_t id, const char *name, int oflag)
4214 {
4215 int fd;
4216
4217 do
4218 fd = contract_open(id, "process", name, oflag);
4219 while (fd < 0 && errno == EINTR)
4220 ;
4221
4222 if (fd < 0)
4223 console(B_TRUE, "Couldn't open %s for contract %ld: %s.\n",
4224 name, id, strerror(errno));
4225
4226 return (fd);
4227 }
4228
4229 static int
4230 contract_cookie(ctid_t id, uint64_t *cp)
4231 {
4232 int fd, err;
4233 ct_stathdl_t sh;
4234
4235 fd = contract_getfile(id, "status", O_RDONLY);
4236 if (fd < 0)
4237 return (-1);
4238
4239 err = ct_status_read(fd, CTD_COMMON, &sh);
4240 if (err != 0) {
4241 console(B_TRUE, "Couldn't read status of contract %ld: %s.\n",
4242 id, strerror(err));
4243 (void) close(fd);
4244 return (-1);
4245 }
4246
4247 (void) close(fd);
4248
4249 *cp = ct_status_get_cookie(sh);
4250
4251 ct_status_free(sh);
4252 return (0);
4253 }
4254
4255 static void
4256 contract_ack(ct_evthdl_t e)
4257 {
4258 int fd;
4259
4260 if (ct_event_get_flags(e) & CTE_INFO)
4261 return;
4262
4263 fd = contract_getfile(ct_event_get_ctid(e), "ctl", O_WRONLY);
4264 if (fd < 0)
4265 return;
4266
4267 (void) ct_ctl_ack(fd, ct_event_get_evid(e));
4268 (void) close(fd);
4269 }
4270
4271 /*
4272 * Process a contract event.
4273 */
4274 static void
4275 contract_event(struct pollfd *poll)
4276 {
4277 ct_evthdl_t e;
4278 int err;
4279 ctid_t ctid;
4280
4281 if (!(poll->revents & POLLIN)) {
4282 if (poll->revents & POLLERR)
4283 console(B_TRUE,
4284 "Unknown poll error on my process contract "
4285 "pbundle.\n");
4286 return;
4287 }
4288
4289 err = ct_event_read(poll->fd, &e);
4290 if (err != 0) {
4291 console(B_TRUE, "Error retrieving contract event: %s.\n",
4292 strerror(err));
4293 return;
4294 }
4295
4296 ctid = ct_event_get_ctid(e);
4297
4298 if (ct_event_get_type(e) == CT_PR_EV_EMPTY) {
4299 uint64_t cookie;
4300 int ret, abandon = 1;
4301
4302 /* If it's svc.startd, restart it. Else, abandon. */
4303 ret = contract_cookie(ctid, &cookie);
4304
4305 if (ret == 0) {
4306 if (cookie == STARTD_COOKIE &&
4307 do_restart_startd) {
4308 if (smf_debug)
4309 console(B_TRUE, "Restarting "
4310 "svc.startd.\n");
4311
4312 /*
4313 * Account for the failure. If the failure rate
4314 * exceeds a threshold, then drop to maintenance
4315 * mode.
4316 */
4317 startd_record_failure();
4318 if (startd_failure_rate_critical())
4319 enter_maintenance();
4320
4321 if (startd_tmpl < 0)
4322 console(B_TRUE,
4323 "Restarting svc.startd in "
4324 "improper contract (bad "
4325 "template).\n");
4326
4327 (void) startd_run(startd_cline, startd_tmpl,
4328 ctid);
4329
4330 abandon = 0;
4331 }
4332 }
4333
4334 if (abandon && (err = contract_abandon_id(ctid))) {
4335 console(B_TRUE, "Couldn't abandon contract %ld: %s.\n",
4336 ctid, strerror(err));
4337 }
4338
4339 /*
4340 * No need to acknowledge the event since either way the
4341 * originating contract should be abandoned.
4342 */
4343 } else {
4344 console(B_TRUE,
4345 "Received contract event of unexpected type %d from "
4346 "contract %ld.\n", ct_event_get_type(e), ctid);
4347
4348 if ((ct_event_get_flags(e) & (CTE_INFO | CTE_ACK)) == 0)
4349 /* Allow unexpected critical events to be released. */
4350 contract_ack(e);
4351 }
4352
4353 ct_event_free(e);
4354 }
4355
4356 /*
4357 * svc.startd(1M) Management
4358 */
4359
4360 /*
4361 * (Re)start svc.startd(1M). old_ctid should be the contract ID of the old
4362 * contract, or 0 if we're starting it for the first time. If wait is true
4363 * we'll wait for and return the exit value of the child.
4364 */
4365 static int
4366 startd_run(const char *cline, int tmpl, ctid_t old_ctid)
4367 {
4368 int err, i, ret, did_activate;
4369 pid_t pid;
4370 struct stat sb;
4371
4372 if (cline[0] == '\0')
4373 return (-1);
4374
4375 /*
4376 * Don't restart startd if the system is rebooting or shutting down.
4377 */
4378 do {
4379 ret = stat("/etc/svc/volatile/resetting", &sb);
4380 } while (ret == -1 && errno == EINTR);
4381
4382 if (ret == 0) {
4383 if (smf_debug)
4384 console(B_TRUE, "Quiescing for reboot.\n");
4385 (void) pause();
4386 return (-1);
4387 }
4388
4389 err = ct_pr_tmpl_set_transfer(tmpl, old_ctid);
4390 if (err == EINVAL) {
4391 console(B_TRUE, "Remake startd_tmpl; reattempt transfer.\n");
4392 tmpl = startd_tmpl = contract_make_template(0, CT_PR_EV_EMPTY,
4393 CT_PR_EV_HWERR, STARTD_COOKIE);
4394
4395 err = ct_pr_tmpl_set_transfer(tmpl, old_ctid);
4396 }
4397 if (err != 0) {
4398 console(B_TRUE,
4399 "Couldn't set transfer parameter of contract template: "
4400 "%s.\n", strerror(err));
4401 }
4402
4403 if ((err = ct_pr_tmpl_set_svc_fmri(startd_tmpl,
4404 SCF_SERVICE_STARTD)) != 0)
4405 console(B_TRUE,
4406 "Can not set svc_fmri in contract template: %s\n",
4407 strerror(err));
4408 if ((err = ct_pr_tmpl_set_svc_aux(startd_tmpl,
4409 startd_svc_aux)) != 0)
4410 console(B_TRUE,
4411 "Can not set svc_aux in contract template: %s\n",
4412 strerror(err));
4413 did_activate = !(ct_tmpl_activate(tmpl));
4414 if (!did_activate)
4415 console(B_TRUE,
4416 "Template activation failed; not starting \"%s\" in "
4417 "proper contract.\n", cline);
4418
4419 /* Hold SIGCLD so we can wait if necessary. */
4420 (void) sighold(SIGCLD);
4421
4422 while ((pid = fork()) < 0) {
4423 if (errno == EPERM) {
4424 console(B_TRUE, "Insufficient permission to fork.\n");
4425
4426 /* Now that's a doozy. */
4427 exit(1);
4428 }
4429
4430 console(B_TRUE,
4431 "fork() for svc.startd failed: %s. Will retry in 1 "
4432 "second...\n", strerror(errno));
4433
4434 (void) sleep(1);
4435
4436 /* Eventually give up? */
4437 }
4438
4439 if (pid == 0) {
4440 /* child */
4441
4442 /* See the comment in efork() */
4443 for (i = SIGHUP; i <= SIGRTMAX; ++i) {
4444 if (i == SIGTTOU || i == SIGTTIN || i == SIGTSTP)
4445 (void) sigset(i, SIG_IGN);
4446 else
4447 (void) sigset(i, SIG_DFL);
4448 }
4449
4450 if (smf_options != NULL) {
4451 /* Put smf_options in the environment. */
4452 glob_envp[glob_envn] =
4453 malloc(sizeof ("SMF_OPTIONS=") - 1 +
4454 strlen(smf_options) + 1);
4455
4456 if (glob_envp[glob_envn] != NULL) {
4457 /* LINTED */
4458 (void) sprintf(glob_envp[glob_envn],
4459 "SMF_OPTIONS=%s", smf_options);
4460 glob_envp[glob_envn+1] = NULL;
4461 } else {
4462 console(B_TRUE,
4463 "Could not set SMF_OPTIONS (%s).\n",
4464 strerror(errno));
4465 }
4466 }
4467
4468 if (smf_debug)
4469 console(B_TRUE, "Executing svc.startd\n");
4470
4471 (void) execle(SH, "INITSH", "-c", cline, NULL, glob_envp);
4472
4473 console(B_TRUE, "Could not exec \"%s\" (%s).\n", SH,
4474 strerror(errno));
4475
4476 exit(1);
4477 }
4478
4479 /* parent */
4480
4481 if (did_activate) {
4482 if (legacy_tmpl < 0 || ct_tmpl_activate(legacy_tmpl) != 0)
4483 (void) ct_tmpl_clear(tmpl);
4484 }
4485
4486 /* Clear the old_ctid reference so the kernel can reclaim it. */
4487 if (old_ctid != 0)
4488 (void) ct_pr_tmpl_set_transfer(tmpl, 0);
4489
4490 (void) sigrelse(SIGCLD);
4491
4492 return (0);
4493 }
4494
4495 /*
4496 * void startd_record_failure(void)
4497 * Place the current time in our circular array of svc.startd failures.
4498 */
4499 void
4500 startd_record_failure()
4501 {
4502 int index = startd_failure_index++ % NSTARTD_FAILURE_TIMES;
4503
4504 startd_failure_time[index] = gethrtime();
4505 }
4506
4507 /*
4508 * int startd_failure_rate_critical(void)
4509 * Return true if the average failure interval is less than the permitted
4510 * interval. Implicit success if insufficient measurements for an average
4511 * exist.
4512 */
4513 int
4514 startd_failure_rate_critical()
4515 {
4516 int n = startd_failure_index;
4517 hrtime_t avg_ns = 0;
4518
4519 if (startd_failure_index < NSTARTD_FAILURE_TIMES)
4520 return (0);
4521
4522 avg_ns =
4523 (startd_failure_time[(n - 1) % NSTARTD_FAILURE_TIMES] -
4524 startd_failure_time[n % NSTARTD_FAILURE_TIMES]) /
4525 NSTARTD_FAILURE_TIMES;
4526
4527 return (avg_ns < STARTD_FAILURE_RATE_NS);
4528 }
4529
4530 /*
4531 * returns string that must be free'd
4532 */
4533
4534 static char
4535 *audit_boot_msg()
4536 {
4537 char *b, *p;
4538 char desc[] = "booted";
4539 zoneid_t zid = getzoneid();
4540
4541 b = malloc(sizeof (desc) + MAXNAMELEN + 3);
4542 if (b == NULL)
4543 return (b);
4544
4545 p = b;
4546 p += strlcpy(p, desc, sizeof (desc));
4547 if (zid != GLOBAL_ZONEID) {
4548 p += strlcpy(p, ": ", 3);
4549 (void) getzonenamebyid(zid, p, MAXNAMELEN);
4550 }
4551 return (b);
4552 }
4553
4554 /*
4555 * Generate AUE_init_solaris audit record. Return 1 if
4556 * auditing is enabled in case the caller cares.
4557 *
4558 * In the case of userint() or a local zone invocation of
4559 * one_true_init, the process initially contains the audit
4560 * characteristics of the process that invoked init. The first pass
4561 * through here uses those characteristics then for the case of
4562 * one_true_init in a local zone, clears them so subsequent system
4563 * state changes won't be attributed to the person who booted the
4564 * zone.
4565 */
4566 static int
4567 audit_put_record(int pass_fail, int status, char *msg)
4568 {
4569 adt_session_data_t *ah;
4570 adt_event_data_t *event;
4571
4572 if (!adt_audit_enabled())
4573 return (0);
4574
4575 /*
4576 * the PROC_DATA picks up the context to tell whether this is
4577 * an attributed record (auid = -2 is unattributed)
4578 */
4579 if (adt_start_session(&ah, NULL, ADT_USE_PROC_DATA)) {
4580 console(B_TRUE, "audit failure: %s\n", strerror(errno));
4581 return (1);
4582 }
4583 event = adt_alloc_event(ah, ADT_init_solaris);
4584 if (event == NULL) {
4585 console(B_TRUE, "audit failure: %s\n", strerror(errno));
4586 (void) adt_end_session(ah);
4587 return (1);
4588 }
4589 event->adt_init_solaris.info = msg; /* NULL is ok here */
4590
4591 if (adt_put_event(event, pass_fail, status)) {
4592 console(B_TRUE, "audit failure: %s\n", strerror(errno));
4593 (void) adt_end_session(ah);
4594 return (1);
4595 }
4596 adt_free_event(event);
4597
4598 (void) adt_end_session(ah);
4599
4600 return (1);
4601 }