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