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