xref: /illumos-gate/usr/src/cmd/halt/halt.c (revision bc2cf0f56ec3597d482c5feb91417385d8e8374c)
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
53f2f09c1Sdp  * Common Development and Distribution License (the "License").
63f2f09c1Sdp  * 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  */
217c478bd9Sstevel@tonic-gate /*
22e557d412SChristopher Kiick  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
25*bc2cf0f5SJoshua M. Clulow /*
26*bc2cf0f5SJoshua M. Clulow  * Copyright (c) 2013, Joyent, Inc. All rights reserved.
27*bc2cf0f5SJoshua M. Clulow  */
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
30753a6d45SSherry Moore /*	  All Rights Reserved	*/
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate /*
337c478bd9Sstevel@tonic-gate  * University Copyright- Copyright (c) 1982, 1986, 1988
347c478bd9Sstevel@tonic-gate  * The Regents of the University of California
357c478bd9Sstevel@tonic-gate  * All Rights Reserved
367c478bd9Sstevel@tonic-gate  *
377c478bd9Sstevel@tonic-gate  * University Acknowledgment- Portions of this document are derived from
387c478bd9Sstevel@tonic-gate  * software developed by the University of California, Berkeley, and its
397c478bd9Sstevel@tonic-gate  * contributors.
408e07a41fSKonstantin Ananyev  * Portions contributed by Juergen Keil, <jk@tools.de>.
417c478bd9Sstevel@tonic-gate  */
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate 
447c478bd9Sstevel@tonic-gate /*
457c478bd9Sstevel@tonic-gate  * Common code for halt(1M), poweroff(1M), and reboot(1M).  We use
467c478bd9Sstevel@tonic-gate  * argv[0] to determine which behavior to exhibit.
477c478bd9Sstevel@tonic-gate  */
487c478bd9Sstevel@tonic-gate 
4919397407SSherry Moore #include <stdio.h>
503f2f09c1Sdp #include <procfs.h>
517c478bd9Sstevel@tonic-gate #include <sys/types.h>
5219397407SSherry Moore #include <sys/elf.h>
5319397407SSherry Moore #include <sys/systeminfo.h>
5419397407SSherry Moore #include <sys/stat.h>
557c478bd9Sstevel@tonic-gate #include <sys/uadmin.h>
5619397407SSherry Moore #include <sys/mntent.h>
5719397407SSherry Moore #include <sys/mnttab.h>
5819397407SSherry Moore #include <sys/mount.h>
598e07a41fSKonstantin Ananyev #include <sys/fs/ufs_mount.h>
607c478bd9Sstevel@tonic-gate #include <alloca.h>
617c478bd9Sstevel@tonic-gate #include <assert.h>
627c478bd9Sstevel@tonic-gate #include <errno.h>
637c478bd9Sstevel@tonic-gate #include <fcntl.h>
647c478bd9Sstevel@tonic-gate #include <libgen.h>
657c478bd9Sstevel@tonic-gate #include <libscf.h>
66753a6d45SSherry Moore #include <libscf_priv.h>
6719397407SSherry Moore #include <limits.h>
687c478bd9Sstevel@tonic-gate #include <locale.h>
697c478bd9Sstevel@tonic-gate #include <libintl.h>
707c478bd9Sstevel@tonic-gate #include <syslog.h>
717c478bd9Sstevel@tonic-gate #include <signal.h>
727c478bd9Sstevel@tonic-gate #include <strings.h>
737c478bd9Sstevel@tonic-gate #include <unistd.h>
747c478bd9Sstevel@tonic-gate #include <stdlib.h>
757c478bd9Sstevel@tonic-gate #include <stdio.h>
767c478bd9Sstevel@tonic-gate #include <strings.h>
777c478bd9Sstevel@tonic-gate #include <time.h>
784e1f1c13SKonstantin Ananyev #include <wait.h>
794e1f1c13SKonstantin Ananyev #include <ctype.h>
807c478bd9Sstevel@tonic-gate #include <utmpx.h>
817c478bd9Sstevel@tonic-gate #include <pwd.h>
827c478bd9Sstevel@tonic-gate #include <zone.h>
833a0fa635SEnrico Perla - Sun Microsystems #include <spawn.h>
8419397407SSherry Moore 
8519397407SSherry Moore #include <libzfs.h>
86753a6d45SSherry Moore #if defined(__i386)
87753a6d45SSherry Moore #include <libgrubmgmt.h>
88753a6d45SSherry Moore #endif
8919397407SSherry Moore 
907c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN)
917c478bd9Sstevel@tonic-gate #define	TEXT_DOMAIN	"SYS_TEST"
927c478bd9Sstevel@tonic-gate #endif
937c478bd9Sstevel@tonic-gate 
9419397407SSherry Moore #if defined(__sparc)
9519397407SSherry Moore #define	CUR_ELFDATA	ELFDATA2MSB
9619397407SSherry Moore #elif defined(__i386)
9719397407SSherry Moore #define	CUR_ELFDATA	ELFDATA2LSB
9819397407SSherry Moore #endif
9919397407SSherry Moore 
10019397407SSherry Moore static libzfs_handle_t *g_zfs;
10119397407SSherry Moore 
1027c478bd9Sstevel@tonic-gate extern int audit_halt_setup(int, char **);
1037c478bd9Sstevel@tonic-gate extern int audit_halt_success(void);
1047c478bd9Sstevel@tonic-gate extern int audit_halt_fail(void);
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate extern int audit_reboot_setup(void);
1077c478bd9Sstevel@tonic-gate extern int audit_reboot_success(void);
1087c478bd9Sstevel@tonic-gate extern int audit_reboot_fail(void);
1097c478bd9Sstevel@tonic-gate 
1103f2f09c1Sdp static char *cmdname;	/* basename(argv[0]), the name of the command */
1113f2f09c1Sdp 
1127c478bd9Sstevel@tonic-gate typedef struct ctidlist_struct {
1137c478bd9Sstevel@tonic-gate 	ctid_t ctid;
1147c478bd9Sstevel@tonic-gate 	struct ctidlist_struct *next;
1157c478bd9Sstevel@tonic-gate } ctidlist_t;
1167c478bd9Sstevel@tonic-gate 
1177c478bd9Sstevel@tonic-gate static ctidlist_t *ctidlist = NULL;
1187c478bd9Sstevel@tonic-gate static ctid_t startdct = -1;
1197c478bd9Sstevel@tonic-gate 
1207c478bd9Sstevel@tonic-gate #define	FMRI_STARTD_CONTRACT \
1217c478bd9Sstevel@tonic-gate 	"svc:/system/svc/restarter:default/:properties/restarter/contract"
1227c478bd9Sstevel@tonic-gate 
12380cb75f4SWilliam Kucharski #define	BEADM_PROG	"/usr/sbin/beadm"
124753a6d45SSherry Moore #define	BOOTADM_PROG	"/sbin/bootadm"
12580cb75f4SWilliam Kucharski #define	ZONEADM_PROG	"/usr/sbin/zoneadm"
12680cb75f4SWilliam Kucharski 
12719397407SSherry Moore /*
12819397407SSherry Moore  * The length of FASTBOOT_MOUNTPOINT must be less than MAXPATHLEN.
12919397407SSherry Moore  */
13019397407SSherry Moore #define	FASTBOOT_MOUNTPOINT	"/tmp/.fastboot.root"
13119397407SSherry Moore 
132753a6d45SSherry Moore /*
133753a6d45SSherry Moore  * Fast Reboot related variables
134753a6d45SSherry Moore  */
13519397407SSherry Moore static char	fastboot_mounted[MAXPATHLEN];
136e557d412SChristopher Kiick 
137753a6d45SSherry Moore #if defined(__i386)
138753a6d45SSherry Moore static grub_boot_args_t	fbarg;
139753a6d45SSherry Moore static grub_boot_args_t	*fbarg_used;
140753a6d45SSherry Moore static int fbarg_entnum = GRUB_ENTRY_DEFAULT;
141753a6d45SSherry Moore #endif	/* __i386 */
14219397407SSherry Moore 
14319397407SSherry Moore static int validate_ufs_disk(char *, char *);
14419397407SSherry Moore static int validate_zfs_pool(char *, char *);
14519397407SSherry Moore 
1463f2f09c1Sdp static pid_t
1473f2f09c1Sdp get_initpid()
1483f2f09c1Sdp {
1493f2f09c1Sdp 	static int init_pid = -1;
1503f2f09c1Sdp 
1513f2f09c1Sdp 	if (init_pid == -1) {
1523f2f09c1Sdp 		if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
1533f2f09c1Sdp 		    sizeof (init_pid)) != sizeof (init_pid)) {
1543f2f09c1Sdp 			assert(errno == ESRCH);
1553f2f09c1Sdp 			init_pid = -1;
1563f2f09c1Sdp 		}
1573f2f09c1Sdp 	}
1583f2f09c1Sdp 	return (init_pid);
1593f2f09c1Sdp }
1603f2f09c1Sdp 
1613f2f09c1Sdp /*
1623f2f09c1Sdp  * Quiesce or resume init using /proc.  When stopping init, we can't send
1633f2f09c1Sdp  * SIGTSTP (since init ignores it) or SIGSTOP (since the kernel won't permit
1643f2f09c1Sdp  * it).
1653f2f09c1Sdp  */
1663f2f09c1Sdp static int
1673f2f09c1Sdp direct_init(long command)
1683f2f09c1Sdp {
1693f2f09c1Sdp 	char ctlfile[MAXPATHLEN];
1703f2f09c1Sdp 	pid_t pid;
1713f2f09c1Sdp 	int ctlfd;
1723f2f09c1Sdp 
1733f2f09c1Sdp 	assert(command == PCDSTOP || command == PCRUN);
1743f2f09c1Sdp 	if ((pid = get_initpid()) == -1) {
1753f2f09c1Sdp 		return (-1);
1763f2f09c1Sdp 	}
1773f2f09c1Sdp 
1783f2f09c1Sdp 	(void) snprintf(ctlfile, sizeof (ctlfile), "/proc/%d/ctl", pid);
1793f2f09c1Sdp 	if ((ctlfd = open(ctlfile, O_WRONLY)) == -1)
1803f2f09c1Sdp 		return (-1);
1813f2f09c1Sdp 
1823f2f09c1Sdp 	if (command == PCDSTOP) {
1833f2f09c1Sdp 		if (write(ctlfd, &command, sizeof (long)) == -1) {
1843f2f09c1Sdp 			(void) close(ctlfd);
1853f2f09c1Sdp 			return (-1);
1863f2f09c1Sdp 		}
1873f2f09c1Sdp 	} else {	/* command == PCRUN */
1883f2f09c1Sdp 		long cmds[2];
1893f2f09c1Sdp 		cmds[0] = command;
1903f2f09c1Sdp 		cmds[1] = 0;
1913f2f09c1Sdp 		if (write(ctlfd, cmds, sizeof (cmds)) == -1) {
1923f2f09c1Sdp 			(void) close(ctlfd);
1933f2f09c1Sdp 			return (-1);
1943f2f09c1Sdp 		}
1953f2f09c1Sdp 	}
1963f2f09c1Sdp 	(void) close(ctlfd);
1973f2f09c1Sdp 	return (0);
1983f2f09c1Sdp }
1993f2f09c1Sdp 
2007c478bd9Sstevel@tonic-gate static void
2017c478bd9Sstevel@tonic-gate stop_startd()
2027c478bd9Sstevel@tonic-gate {
2037c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
2047c478bd9Sstevel@tonic-gate 	scf_property_t *prop = NULL;
2057c478bd9Sstevel@tonic-gate 	scf_value_t *val = NULL;
2067c478bd9Sstevel@tonic-gate 	uint64_t uint64;
2077c478bd9Sstevel@tonic-gate 
2083f2f09c1Sdp 	if ((h = scf_handle_create(SCF_VERSION)) == NULL)
2097c478bd9Sstevel@tonic-gate 		return;
2107c478bd9Sstevel@tonic-gate 
2113f2f09c1Sdp 	if ((scf_handle_bind(h) != 0) ||
2123f2f09c1Sdp 	    ((prop = scf_property_create(h)) == NULL) ||
2133f2f09c1Sdp 	    ((val = scf_value_create(h)) == NULL))
2147c478bd9Sstevel@tonic-gate 		goto out;
2157c478bd9Sstevel@tonic-gate 
2163f2f09c1Sdp 	if (scf_handle_decode_fmri(h, FMRI_STARTD_CONTRACT,
2173f2f09c1Sdp 	    NULL, NULL, NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0)
2187c478bd9Sstevel@tonic-gate 		goto out;
2197c478bd9Sstevel@tonic-gate 
2203f2f09c1Sdp 	if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 ||
2213f2f09c1Sdp 	    scf_property_get_value(prop, val) != 0 ||
2223f2f09c1Sdp 	    scf_value_get_count(val, &uint64) != 0)
2237c478bd9Sstevel@tonic-gate 		goto out;
2247c478bd9Sstevel@tonic-gate 
2253f2f09c1Sdp 	startdct = (ctid_t)uint64;
2263f2f09c1Sdp 	(void) sigsend(P_CTID, startdct, SIGSTOP);
2277c478bd9Sstevel@tonic-gate 
2287c478bd9Sstevel@tonic-gate out:
2293f2f09c1Sdp 	scf_property_destroy(prop);
2303f2f09c1Sdp 	scf_value_destroy(val);
2317c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
2327c478bd9Sstevel@tonic-gate }
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate static void
2357c478bd9Sstevel@tonic-gate continue_startd()
2367c478bd9Sstevel@tonic-gate {
2377c478bd9Sstevel@tonic-gate 	if (startdct != -1)
2387c478bd9Sstevel@tonic-gate 		(void) sigsend(P_CTID, startdct, SIGCONT);
2397c478bd9Sstevel@tonic-gate }
2407c478bd9Sstevel@tonic-gate 
2417c478bd9Sstevel@tonic-gate #define	FMRI_RESTARTER_PROP "/:properties/general/restarter"
2427c478bd9Sstevel@tonic-gate #define	FMRI_CONTRACT_PROP "/:properties/restarter/contract"
2437c478bd9Sstevel@tonic-gate 
2447c478bd9Sstevel@tonic-gate static int
2457c478bd9Sstevel@tonic-gate save_ctid(ctid_t ctid)
2467c478bd9Sstevel@tonic-gate {
2477c478bd9Sstevel@tonic-gate 	ctidlist_t *next;
2487c478bd9Sstevel@tonic-gate 
2497c478bd9Sstevel@tonic-gate 	for (next = ctidlist; next != NULL; next = next->next)
2507c478bd9Sstevel@tonic-gate 		if (next->ctid == ctid)
2517c478bd9Sstevel@tonic-gate 			return (-1);
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	next = (ctidlist_t *)malloc(sizeof (ctidlist_t));
2547c478bd9Sstevel@tonic-gate 	if (next == NULL)
2557c478bd9Sstevel@tonic-gate 		return (-1);
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate 	next->ctid = ctid;
2587c478bd9Sstevel@tonic-gate 	next->next = ctidlist;
2597c478bd9Sstevel@tonic-gate 	ctidlist = next;
2607c478bd9Sstevel@tonic-gate 	return (0);
2617c478bd9Sstevel@tonic-gate }
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate static void
2647c478bd9Sstevel@tonic-gate stop_delegates()
2657c478bd9Sstevel@tonic-gate {
2667c478bd9Sstevel@tonic-gate 	ctid_t ctid;
2677c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
2687c478bd9Sstevel@tonic-gate 	scf_scope_t *sc = NULL;
2697c478bd9Sstevel@tonic-gate 	scf_service_t *svc = NULL;
2707c478bd9Sstevel@tonic-gate 	scf_instance_t *inst = NULL;
2717c478bd9Sstevel@tonic-gate 	scf_snapshot_t *snap = NULL;
2727c478bd9Sstevel@tonic-gate 	scf_snapshot_t *isnap = NULL;
2737c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *pg = NULL;
2747c478bd9Sstevel@tonic-gate 	scf_property_t *prop = NULL;
2757c478bd9Sstevel@tonic-gate 	scf_value_t *val = NULL;
2767c478bd9Sstevel@tonic-gate 	scf_iter_t *siter = NULL;
2777c478bd9Sstevel@tonic-gate 	scf_iter_t *iiter = NULL;
2787c478bd9Sstevel@tonic-gate 	char *fmri;
2797c478bd9Sstevel@tonic-gate 	ssize_t length;
2807c478bd9Sstevel@tonic-gate 
2817c478bd9Sstevel@tonic-gate 	uint64_t uint64;
2827c478bd9Sstevel@tonic-gate 	ssize_t bytes;
2837c478bd9Sstevel@tonic-gate 
2847c478bd9Sstevel@tonic-gate 	length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
2857c478bd9Sstevel@tonic-gate 	if (length <= 0)
2867c478bd9Sstevel@tonic-gate 		return;
2877c478bd9Sstevel@tonic-gate 
2887c478bd9Sstevel@tonic-gate 	length++;
2897c478bd9Sstevel@tonic-gate 	fmri = alloca(length * sizeof (char));
2907c478bd9Sstevel@tonic-gate 
2913f2f09c1Sdp 	if ((h = scf_handle_create(SCF_VERSION)) == NULL)
2927c478bd9Sstevel@tonic-gate 		return;
2937c478bd9Sstevel@tonic-gate 
2943f2f09c1Sdp 	if (scf_handle_bind(h) != 0) {
2957c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
2967c478bd9Sstevel@tonic-gate 		return;
2977c478bd9Sstevel@tonic-gate 	}
2987c478bd9Sstevel@tonic-gate 
2993f2f09c1Sdp 	if ((sc = scf_scope_create(h)) == NULL ||
3003f2f09c1Sdp 	    (svc = scf_service_create(h)) == NULL ||
3013f2f09c1Sdp 	    (inst = scf_instance_create(h)) == NULL ||
3023f2f09c1Sdp 	    (snap = scf_snapshot_create(h)) == NULL ||
3033f2f09c1Sdp 	    (pg = scf_pg_create(h)) == NULL ||
3043f2f09c1Sdp 	    (prop = scf_property_create(h)) == NULL ||
3053f2f09c1Sdp 	    (val = scf_value_create(h)) == NULL ||
3063f2f09c1Sdp 	    (siter = scf_iter_create(h)) == NULL ||
3073f2f09c1Sdp 	    (iiter = scf_iter_create(h)) == NULL)
3087c478bd9Sstevel@tonic-gate 		goto out;
3097c478bd9Sstevel@tonic-gate 
3103f2f09c1Sdp 	if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, sc) != 0)
3117c478bd9Sstevel@tonic-gate 		goto out;
3127c478bd9Sstevel@tonic-gate 
3133f2f09c1Sdp 	if (scf_iter_scope_services(siter, sc) != 0)
3147c478bd9Sstevel@tonic-gate 		goto out;
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 	while (scf_iter_next_service(siter, svc) == 1) {
3177c478bd9Sstevel@tonic-gate 
3183f2f09c1Sdp 		if (scf_iter_service_instances(iiter, svc) != 0)
3197c478bd9Sstevel@tonic-gate 			continue;
3207c478bd9Sstevel@tonic-gate 
3217c478bd9Sstevel@tonic-gate 		while (scf_iter_next_instance(iiter, inst) == 1) {
3227c478bd9Sstevel@tonic-gate 
3233f2f09c1Sdp 			if ((scf_instance_get_snapshot(inst, "running",
3243f2f09c1Sdp 			    snap)) != 0)
3253f2f09c1Sdp 				isnap = NULL;
3263f2f09c1Sdp 			else
3273f2f09c1Sdp 				isnap = snap;
3287c478bd9Sstevel@tonic-gate 
3293f2f09c1Sdp 			if (scf_instance_get_pg_composed(inst, isnap,
3303f2f09c1Sdp 			    SCF_PG_GENERAL, pg) != 0)
3317c478bd9Sstevel@tonic-gate 				continue;
3327c478bd9Sstevel@tonic-gate 
3333f2f09c1Sdp 			if (scf_pg_get_property(pg, SCF_PROPERTY_RESTARTER,
3343f2f09c1Sdp 			    prop) != 0 ||
3353f2f09c1Sdp 			    scf_property_get_value(prop, val) != 0)
3367c478bd9Sstevel@tonic-gate 				continue;
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 			bytes = scf_value_get_astring(val, fmri, length);
3397c478bd9Sstevel@tonic-gate 			if (bytes <= 0 || bytes >= length)
3407c478bd9Sstevel@tonic-gate 				continue;
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 			if (strlcat(fmri, FMRI_CONTRACT_PROP, length) >=
3437c478bd9Sstevel@tonic-gate 			    length)
3447c478bd9Sstevel@tonic-gate 				continue;
3457c478bd9Sstevel@tonic-gate 
3463f2f09c1Sdp 			if (scf_handle_decode_fmri(h, fmri, NULL, NULL,
3473f2f09c1Sdp 			    NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0)
3487c478bd9Sstevel@tonic-gate 				continue;
3497c478bd9Sstevel@tonic-gate 
3503f2f09c1Sdp 			if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 ||
3513f2f09c1Sdp 			    scf_property_get_value(prop, val) != 0 ||
3523f2f09c1Sdp 			    scf_value_get_count(val, &uint64) != 0)
3537c478bd9Sstevel@tonic-gate 				continue;
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 			ctid = (ctid_t)uint64;
3567c478bd9Sstevel@tonic-gate 			if (save_ctid(ctid) == 0) {
3577c478bd9Sstevel@tonic-gate 				(void) sigsend(P_CTID, ctid, SIGSTOP);
3587c478bd9Sstevel@tonic-gate 			}
3597c478bd9Sstevel@tonic-gate 		}
3607c478bd9Sstevel@tonic-gate 	}
3617c478bd9Sstevel@tonic-gate out:
3623f2f09c1Sdp 	scf_scope_destroy(sc);
3633f2f09c1Sdp 	scf_service_destroy(svc);
3643f2f09c1Sdp 	scf_instance_destroy(inst);
3653f2f09c1Sdp 	scf_snapshot_destroy(snap);
3663f2f09c1Sdp 	scf_pg_destroy(pg);
3673f2f09c1Sdp 	scf_property_destroy(prop);
3683f2f09c1Sdp 	scf_value_destroy(val);
3693f2f09c1Sdp 	scf_iter_destroy(siter);
3703f2f09c1Sdp 	scf_iter_destroy(iiter);
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate 	(void) scf_handle_unbind(h);
3737c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
3747c478bd9Sstevel@tonic-gate }
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate static void
3777c478bd9Sstevel@tonic-gate continue_delegates()
3787c478bd9Sstevel@tonic-gate {
3797c478bd9Sstevel@tonic-gate 	ctidlist_t *next;
3807c478bd9Sstevel@tonic-gate 	for (next = ctidlist; next != NULL; next = next->next)
3817c478bd9Sstevel@tonic-gate 		(void) sigsend(P_CTID, next->ctid, SIGCONT);
3827c478bd9Sstevel@tonic-gate }
3837c478bd9Sstevel@tonic-gate 
3849db7147eSSherry Moore #define	FMRI_GDM "svc:/application/graphical-login/gdm:default"
3853b860eeeSSherry Moore #define	GDM_STOP_TIMEOUT	10	/* Give gdm 10 seconds to shut down */
3869db7147eSSherry Moore 
3879db7147eSSherry Moore /*
3889db7147eSSherry Moore  * If gdm is running, try to stop gdm.
3899db7147eSSherry Moore  * Returns  0 on success, -1 on failure.
3909db7147eSSherry Moore  */
3919db7147eSSherry Moore static int
3929db7147eSSherry Moore stop_gdm()
3939db7147eSSherry Moore {
3949db7147eSSherry Moore 	char *gdm_state = NULL;
3959db7147eSSherry Moore 	int retry = 0;
3969db7147eSSherry Moore 
3979db7147eSSherry Moore 	/*
3989db7147eSSherry Moore 	 * If gdm is running, try to stop gdm.
3999db7147eSSherry Moore 	 */
4009db7147eSSherry Moore 	while ((gdm_state = smf_get_state(FMRI_GDM)) != NULL &&
4013b860eeeSSherry Moore 	    strcmp(gdm_state, SCF_STATE_STRING_ONLINE) == 0 &&
4023b860eeeSSherry Moore 	    retry++ < GDM_STOP_TIMEOUT) {
4033b860eeeSSherry Moore 
4043b860eeeSSherry Moore 		free(gdm_state);
4053b860eeeSSherry Moore 
4063b860eeeSSherry Moore 		/*
4073b860eeeSSherry Moore 		 * Only need to disable once.
4083b860eeeSSherry Moore 		 */
4093b860eeeSSherry Moore 		if (retry == 1 &&
4103b860eeeSSherry Moore 		    smf_disable_instance(FMRI_GDM, SMF_TEMPORARY) != 0) {
4119db7147eSSherry Moore 			(void) fprintf(stderr,
4129db7147eSSherry Moore 			    gettext("%s: Failed to stop %s: %s.\n"),
4139db7147eSSherry Moore 			    cmdname, FMRI_GDM, scf_strerror(scf_error()));
4149db7147eSSherry Moore 			return (-1);
4159db7147eSSherry Moore 		}
4169db7147eSSherry Moore 		(void) sleep(1);
4179db7147eSSherry Moore 	}
4189db7147eSSherry Moore 
4193b860eeeSSherry Moore 	if (retry >= GDM_STOP_TIMEOUT) {
4209db7147eSSherry Moore 		(void) fprintf(stderr, gettext("%s: Failed to stop %s.\n"),
4219db7147eSSherry Moore 		    cmdname, FMRI_GDM);
4229db7147eSSherry Moore 		return (-1);
4239db7147eSSherry Moore 	}
4249db7147eSSherry Moore 
4259db7147eSSherry Moore 	return (0);
4269db7147eSSherry Moore }
4279db7147eSSherry Moore 
4289db7147eSSherry Moore 
4297c478bd9Sstevel@tonic-gate static void
4307c478bd9Sstevel@tonic-gate stop_restarters()
4317c478bd9Sstevel@tonic-gate {
4327c478bd9Sstevel@tonic-gate 	stop_startd();
4337c478bd9Sstevel@tonic-gate 	stop_delegates();
4347c478bd9Sstevel@tonic-gate }
4357c478bd9Sstevel@tonic-gate 
4367c478bd9Sstevel@tonic-gate static void
4377c478bd9Sstevel@tonic-gate continue_restarters()
4387c478bd9Sstevel@tonic-gate {
4397c478bd9Sstevel@tonic-gate 	continue_startd();
4407c478bd9Sstevel@tonic-gate 	continue_delegates();
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate /*
4447c478bd9Sstevel@tonic-gate  * Copy an array of strings into buf, separated by spaces.  Returns 0 on
4457c478bd9Sstevel@tonic-gate  * success.
4467c478bd9Sstevel@tonic-gate  */
4477c478bd9Sstevel@tonic-gate static int
4487c478bd9Sstevel@tonic-gate gather_args(char **args, char *buf, size_t buf_sz)
4497c478bd9Sstevel@tonic-gate {
4507c478bd9Sstevel@tonic-gate 	if (strlcpy(buf, *args, buf_sz) >= buf_sz)
4517c478bd9Sstevel@tonic-gate 		return (-1);
4527c478bd9Sstevel@tonic-gate 
4537c478bd9Sstevel@tonic-gate 	for (++args; *args != NULL; ++args) {
4547c478bd9Sstevel@tonic-gate 		if (strlcat(buf, " ", buf_sz) >= buf_sz)
4557c478bd9Sstevel@tonic-gate 			return (-1);
4567c478bd9Sstevel@tonic-gate 		if (strlcat(buf, *args, buf_sz) >= buf_sz)
4577c478bd9Sstevel@tonic-gate 			return (-1);
4587c478bd9Sstevel@tonic-gate 	}
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 	return (0);
4617c478bd9Sstevel@tonic-gate }
4627c478bd9Sstevel@tonic-gate 
46326f665e8Sdstaff /*
46426f665e8Sdstaff  * Halt every zone on the system.  We are committed to doing a shutdown
46526f665e8Sdstaff  * even if something goes wrong here. If something goes wrong, we just
46626f665e8Sdstaff  * continue with the shutdown.  Return non-zero if we need to wait for zones to
46726f665e8Sdstaff  * halt later on.
46826f665e8Sdstaff  */
46926f665e8Sdstaff static int
4703f2f09c1Sdp halt_zones()
47126f665e8Sdstaff {
47226f665e8Sdstaff 	pid_t pid;
47326f665e8Sdstaff 	zoneid_t *zones;
4743f2f09c1Sdp 	size_t nz = 0, old_nz;
47526f665e8Sdstaff 	int i;
47626f665e8Sdstaff 	char zname[ZONENAME_MAX];
47726f665e8Sdstaff 
47826f665e8Sdstaff 	/*
47926f665e8Sdstaff 	 * Get a list of zones. If the number of zones changes in between the
48026f665e8Sdstaff 	 * two zone_list calls, try again.
48126f665e8Sdstaff 	 */
48226f665e8Sdstaff 
48326f665e8Sdstaff 	for (;;) {
48426f665e8Sdstaff 		(void) zone_list(NULL, &nz);
48526f665e8Sdstaff 		if (nz == 1)
48626f665e8Sdstaff 			return (0);
48726f665e8Sdstaff 		old_nz = nz;
48826f665e8Sdstaff 		zones = calloc(sizeof (zoneid_t), nz);
48926f665e8Sdstaff 		if (zones == NULL) {
49026f665e8Sdstaff 			(void) fprintf(stderr,
49126f665e8Sdstaff 			    gettext("%s: Could not halt zones"
4923f2f09c1Sdp 			    " (out of memory).\n"), cmdname);
49326f665e8Sdstaff 			return (0);
49426f665e8Sdstaff 		}
49526f665e8Sdstaff 
49626f665e8Sdstaff 		(void) zone_list(zones, &nz);
49726f665e8Sdstaff 		if (old_nz == nz)
49826f665e8Sdstaff 			break;
49926f665e8Sdstaff 		free(zones);
50026f665e8Sdstaff 	}
50126f665e8Sdstaff 
50226f665e8Sdstaff 	if (nz == 2) {
5033f2f09c1Sdp 		(void) fprintf(stderr, gettext("%s: Halting 1 zone.\n"),
5043f2f09c1Sdp 		    cmdname);
50526f665e8Sdstaff 	} else {
5063f2f09c1Sdp 		(void) fprintf(stderr, gettext("%s: Halting %i zones.\n"),
5073f2f09c1Sdp 		    cmdname, nz - 1);
50826f665e8Sdstaff 	}
50926f665e8Sdstaff 
51026f665e8Sdstaff 	for (i = 0; i < nz; i++) {
51126f665e8Sdstaff 		if (zones[i] == GLOBAL_ZONEID)
51226f665e8Sdstaff 			continue;
51326f665e8Sdstaff 		if (getzonenamebyid(zones[i], zname, sizeof (zname)) < 0) {
51426f665e8Sdstaff 			/*
51526f665e8Sdstaff 			 * getzonenamebyid should only fail if we raced with
51626f665e8Sdstaff 			 * another process trying to shut down the zone.
51726f665e8Sdstaff 			 * We assume this happened and ignore the error.
51826f665e8Sdstaff 			 */
51926f665e8Sdstaff 			if (errno != EINVAL) {
52026f665e8Sdstaff 				(void) fprintf(stderr,
52126f665e8Sdstaff 				    gettext("%s: Unexpected error while "
52226f665e8Sdstaff 				    "looking up zone %ul: %s.\n"),
5233f2f09c1Sdp 				    cmdname, zones[i], strerror(errno));
52426f665e8Sdstaff 			}
52526f665e8Sdstaff 
52626f665e8Sdstaff 			continue;
52726f665e8Sdstaff 		}
52826f665e8Sdstaff 		pid = fork();
52926f665e8Sdstaff 		if (pid < 0) {
53026f665e8Sdstaff 			(void) fprintf(stderr,
53126f665e8Sdstaff 			    gettext("%s: Zone \"%s\" could not be"
53226f665e8Sdstaff 			    " halted (could not fork(): %s).\n"),
5333f2f09c1Sdp 			    cmdname, zname, strerror(errno));
53426f665e8Sdstaff 			continue;
53526f665e8Sdstaff 		}
53626f665e8Sdstaff 		if (pid == 0) {
53726f665e8Sdstaff 			(void) execl(ZONEADM_PROG, ZONEADM_PROG,
53826f665e8Sdstaff 			    "-z", zname, "halt", NULL);
53926f665e8Sdstaff 			(void) fprintf(stderr,
54026f665e8Sdstaff 			    gettext("%s: Zone \"%s\" could not be halted"
54126f665e8Sdstaff 			    " (cannot exec(" ZONEADM_PROG "): %s).\n"),
5423f2f09c1Sdp 			    cmdname, zname, strerror(errno));
54326f665e8Sdstaff 			exit(0);
54426f665e8Sdstaff 		}
54526f665e8Sdstaff 	}
54626f665e8Sdstaff 
54726f665e8Sdstaff 	return (1);
54826f665e8Sdstaff }
54926f665e8Sdstaff 
55026f665e8Sdstaff /*
55126f665e8Sdstaff  * This function tries to wait for all non-global zones to go away.
55226f665e8Sdstaff  * It will timeout if no progress is made for 5 seconds, or a total of
55326f665e8Sdstaff  * 30 seconds elapses.
55426f665e8Sdstaff  */
55526f665e8Sdstaff 
55626f665e8Sdstaff static void
5573f2f09c1Sdp check_zones_haltedness()
55826f665e8Sdstaff {
55926f665e8Sdstaff 	int t = 0, t_prog = 0;
56026f665e8Sdstaff 	size_t nz = 0, last_nz;
56126f665e8Sdstaff 
56226f665e8Sdstaff 	do {
56326f665e8Sdstaff 		last_nz = nz;
56426f665e8Sdstaff 		(void) zone_list(NULL, &nz);
56526f665e8Sdstaff 		if (nz == 1)
56626f665e8Sdstaff 			return;
56726f665e8Sdstaff 
56826f665e8Sdstaff 		(void) sleep(1);
56926f665e8Sdstaff 
57026f665e8Sdstaff 		if (last_nz > nz)
57126f665e8Sdstaff 			t_prog = 0;
57226f665e8Sdstaff 
57326f665e8Sdstaff 		t++;
57426f665e8Sdstaff 		t_prog++;
57526f665e8Sdstaff 
57626f665e8Sdstaff 		if (t == 10) {
57726f665e8Sdstaff 			if (nz == 2) {
57826f665e8Sdstaff 				(void) fprintf(stderr,
57926f665e8Sdstaff 				    gettext("%s: Still waiting for 1 zone to "
58026f665e8Sdstaff 				    "halt. Will wait up to 20 seconds.\n"),
5813f2f09c1Sdp 				    cmdname);
58226f665e8Sdstaff 			} else {
58326f665e8Sdstaff 				(void) fprintf(stderr,
58426f665e8Sdstaff 				    gettext("%s: Still waiting for %i zones "
58526f665e8Sdstaff 				    "to halt. Will wait up to 20 seconds.\n"),
5863f2f09c1Sdp 				    cmdname, nz - 1);
58726f665e8Sdstaff 			}
58826f665e8Sdstaff 		}
58926f665e8Sdstaff 
59026f665e8Sdstaff 	} while ((t < 30) && (t_prog < 5));
59126f665e8Sdstaff }
59226f665e8Sdstaff 
59319397407SSherry Moore 
59419397407SSherry Moore /*
59519397407SSherry Moore  * Validate that this is a root disk or dataset
59619397407SSherry Moore  * Returns 0 if it is a root disk or dataset;
59719397407SSherry Moore  * returns 1 if it is a disk argument or dataset, but not valid or not root;
59819397407SSherry Moore  * returns -1 if it is not a valid argument or a disk argument.
59919397407SSherry Moore  */
60019397407SSherry Moore static int
60119397407SSherry Moore validate_disk(char *arg, char *mountpoint)
60219397407SSherry Moore {
60319397407SSherry Moore 	static char root_dev_path[] = "/dev/dsk";
60419397407SSherry Moore 	char kernpath[MAXPATHLEN];
60519397407SSherry Moore 	struct stat64 statbuf;
60619397407SSherry Moore 	int rc = 0;
60719397407SSherry Moore 
60819397407SSherry Moore 	if (strlen(arg) > MAXPATHLEN) {
60919397407SSherry Moore 		(void) fprintf(stderr,
610753a6d45SSherry Moore 		    gettext("%s: Argument is too long\n"), cmdname);
61119397407SSherry Moore 		return (-1);
61219397407SSherry Moore 	}
61319397407SSherry Moore 
61419397407SSherry Moore 	bcopy(FASTBOOT_MOUNTPOINT, mountpoint, sizeof (FASTBOOT_MOUNTPOINT));
61519397407SSherry Moore 
616753a6d45SSherry Moore 	if (strstr(arg, mountpoint) == NULL) {
617753a6d45SSherry Moore 		/*
618753a6d45SSherry Moore 		 * Do a force umount just in case some other filesystem has
619753a6d45SSherry Moore 		 * been mounted there.
620753a6d45SSherry Moore 		 */
621753a6d45SSherry Moore 		(void) umount2(mountpoint, MS_FORCE);
622753a6d45SSherry Moore 	}
62319397407SSherry Moore 
62419397407SSherry Moore 	/* Create the directory if it doesn't already exist */
625753a6d45SSherry Moore 	if (lstat64(mountpoint, &statbuf) != 0) {
62619397407SSherry Moore 		if (mkdirp(mountpoint, 0755) != 0) {
62719397407SSherry Moore 			(void) fprintf(stderr,
628753a6d45SSherry Moore 			    gettext("Failed to create mountpoint %s\n"),
62919397407SSherry Moore 			    mountpoint);
63019397407SSherry Moore 			return (-1);
63119397407SSherry Moore 		}
63219397407SSherry Moore 	}
63319397407SSherry Moore 
63419397407SSherry Moore 	if (strncmp(arg, root_dev_path, strlen(root_dev_path)) == 0) {
63519397407SSherry Moore 		/* ufs root disk argument */
63619397407SSherry Moore 		rc = validate_ufs_disk(arg, mountpoint);
63719397407SSherry Moore 	} else {
63819397407SSherry Moore 		/* zfs root pool argument */
63919397407SSherry Moore 		rc = validate_zfs_pool(arg, mountpoint);
64019397407SSherry Moore 	}
64119397407SSherry Moore 
64219397407SSherry Moore 	if (rc != 0)
64319397407SSherry Moore 		return (rc);
64419397407SSherry Moore 
64519397407SSherry Moore 	(void) snprintf(kernpath, MAXPATHLEN, "%s/platform/i86pc/kernel/unix",
64619397407SSherry Moore 	    mountpoint);
64719397407SSherry Moore 
64819397407SSherry Moore 	if (stat64(kernpath, &statbuf) != 0) {
64919397407SSherry Moore 		(void) fprintf(stderr,
65019397407SSherry Moore 		    gettext("%s: %s is not a root disk or dataset\n"),
65119397407SSherry Moore 		    cmdname, arg);
65219397407SSherry Moore 		return (1);
65319397407SSherry Moore 	}
65419397407SSherry Moore 
65519397407SSherry Moore 	return (0);
65619397407SSherry Moore }
65719397407SSherry Moore 
65819397407SSherry Moore 
65919397407SSherry Moore static int
66019397407SSherry Moore validate_ufs_disk(char *arg, char *mountpoint)
66119397407SSherry Moore {
6628e07a41fSKonstantin Ananyev 	struct ufs_args	ufs_args = { 0 };
6638e07a41fSKonstantin Ananyev 	char mntopts[MNT_LINE_MAX] = MNTOPT_LARGEFILES;
66419397407SSherry Moore 
66519397407SSherry Moore 	/* perform the mount */
6668e07a41fSKonstantin Ananyev 	ufs_args.flags = UFSMNT_LARGEFILES;
66719397407SSherry Moore 	if (mount(arg, mountpoint, MS_DATA|MS_OPTIONSTR,
6688e07a41fSKonstantin Ananyev 	    MNTTYPE_UFS, &ufs_args, sizeof (ufs_args),
6698e07a41fSKonstantin Ananyev 	    mntopts, sizeof (mntopts)) != 0) {
67019397407SSherry Moore 		perror(cmdname);
67119397407SSherry Moore 		(void) fprintf(stderr,
672753a6d45SSherry Moore 		    gettext("%s: Failed to mount %s\n"), cmdname, arg);
67319397407SSherry Moore 		return (-1);
67419397407SSherry Moore 	}
67519397407SSherry Moore 
67619397407SSherry Moore 	return (0);
67719397407SSherry Moore }
67819397407SSherry Moore 
67919397407SSherry Moore static int
68019397407SSherry Moore validate_zfs_pool(char *arg, char *mountpoint)
68119397407SSherry Moore {
68219397407SSherry Moore 	zfs_handle_t *zhp = NULL;
68319397407SSherry Moore 	char mntopts[MNT_LINE_MAX] = { '\0' };
68419397407SSherry Moore 	int rc = 0;
68519397407SSherry Moore 
68619397407SSherry Moore 	if ((g_zfs = libzfs_init()) == NULL) {
687753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("Internal error: failed to "
68819397407SSherry Moore 		    "initialize ZFS library\n"));
68919397407SSherry Moore 		return (-1);
69019397407SSherry Moore 	}
69119397407SSherry Moore 
69219397407SSherry Moore 	/* Try to open the dataset */
69319397407SSherry Moore 	if ((zhp = zfs_open(g_zfs, arg,
69419397407SSherry Moore 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL)
69519397407SSherry Moore 		return (-1);
69619397407SSherry Moore 
69719397407SSherry Moore 	/* perform the mount */
698753a6d45SSherry Moore 	if (mount(zfs_get_name(zhp), mountpoint, MS_DATA|MS_OPTIONSTR|MS_RDONLY,
69919397407SSherry Moore 	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {
70019397407SSherry Moore 		perror(cmdname);
70119397407SSherry Moore 		(void) fprintf(stderr,
702753a6d45SSherry Moore 		    gettext("%s: Failed to mount %s\n"), cmdname, arg);
70319397407SSherry Moore 		rc = -1;
70419397407SSherry Moore 	}
70519397407SSherry Moore 
70619397407SSherry Moore validate_zfs_err_out:
70719397407SSherry Moore 	if (zhp != NULL)
70819397407SSherry Moore 		zfs_close(zhp);
70919397407SSherry Moore 
71019397407SSherry Moore 	libzfs_fini(g_zfs);
71119397407SSherry Moore 	return (rc);
71219397407SSherry Moore }
71319397407SSherry Moore 
71419397407SSherry Moore /*
71519397407SSherry Moore  * Return 0 if not zfs, or is zfs and have successfully constructed the
71619397407SSherry Moore  * boot argument; returns non-zero otherwise.
71719397407SSherry Moore  * At successful completion fpth contains pointer where mount point ends.
71819397407SSherry Moore  * NOTE: arg is supposed to be the resolved path
71919397407SSherry Moore  */
72019397407SSherry Moore static int
72119397407SSherry Moore get_zfs_bootfs_arg(const char *arg, const char ** fpth, int *is_zfs,
72219397407SSherry Moore 		char *bootfs_arg)
72319397407SSherry Moore {
72419397407SSherry Moore 	zfs_handle_t *zhp = NULL;
72519397407SSherry Moore 	zpool_handle_t *zpoolp = NULL;
72619397407SSherry Moore 	FILE *mtabp = NULL;
72719397407SSherry Moore 	struct mnttab mnt;
72819397407SSherry Moore 	char *poolname = NULL;
729753a6d45SSherry Moore 	char physpath[MAXPATHLEN];
73019397407SSherry Moore 	char mntsp[ZPOOL_MAXNAMELEN];
73119397407SSherry Moore 	char bootfs[ZPOOL_MAXNAMELEN];
73219397407SSherry Moore 	int rc = 0;
73319397407SSherry Moore 	size_t mntlen = 0;
73419397407SSherry Moore 	size_t msz;
735753a6d45SSherry Moore 	static char fmt[] = "-B zfs-bootfs=%s,bootpath=\"%s\"";
73619397407SSherry Moore 
73719397407SSherry Moore 	*fpth = arg;
73819397407SSherry Moore 	*is_zfs = 0;
73919397407SSherry Moore 
74019397407SSherry Moore 	bzero(physpath, sizeof (physpath));
74119397407SSherry Moore 	bzero(bootfs, sizeof (bootfs));
74219397407SSherry Moore 
74319397407SSherry Moore 	if ((mtabp = fopen(MNTTAB, "r")) == NULL) {
74419397407SSherry Moore 		return (-1);
74519397407SSherry Moore 	}
74619397407SSherry Moore 
74719397407SSherry Moore 	while (getmntent(mtabp, &mnt) == 0) {
74819397407SSherry Moore 		if (strstr(arg, mnt.mnt_mountp) == arg &&
74919397407SSherry Moore 		    (msz = strlen(mnt.mnt_mountp)) > mntlen) {
75019397407SSherry Moore 			mntlen = msz;
75119397407SSherry Moore 			*is_zfs = strcmp(MNTTYPE_ZFS, mnt.mnt_fstype) == 0;
75219397407SSherry Moore 			(void) strlcpy(mntsp, mnt.mnt_special, sizeof (mntsp));
75319397407SSherry Moore 		}
75419397407SSherry Moore 	}
75519397407SSherry Moore 
75619397407SSherry Moore 	(void) fclose(mtabp);
75719397407SSherry Moore 
75819397407SSherry Moore 	if (mntlen > 1)
75919397407SSherry Moore 		*fpth += mntlen;
76019397407SSherry Moore 
76119397407SSherry Moore 	if (!*is_zfs)
76219397407SSherry Moore 		return (0);
76319397407SSherry Moore 
76419397407SSherry Moore 	if ((g_zfs = libzfs_init()) == NULL)
76519397407SSherry Moore 		return (-1);
76619397407SSherry Moore 
76719397407SSherry Moore 	/* Try to open the dataset */
76819397407SSherry Moore 	if ((zhp = zfs_open(g_zfs, mntsp,
76919397407SSherry Moore 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL) {
770753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("Cannot open %s\n"), mntsp);
77119397407SSherry Moore 		rc = -1;
77219397407SSherry Moore 		goto validate_zfs_err_out;
77319397407SSherry Moore 	}
77419397407SSherry Moore 
77519397407SSherry Moore 	(void) strlcpy(bootfs, mntsp, sizeof (bootfs));
77619397407SSherry Moore 
77719397407SSherry Moore 	if ((poolname = strtok(mntsp, "/")) == NULL) {
77819397407SSherry Moore 		rc = -1;
77919397407SSherry Moore 		goto validate_zfs_err_out;
78019397407SSherry Moore 	}
78119397407SSherry Moore 
78219397407SSherry Moore 	if ((zpoolp = zpool_open(g_zfs, poolname)) == NULL) {
783753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("Cannot open %s\n"), poolname);
78419397407SSherry Moore 		rc = -1;
78519397407SSherry Moore 		goto validate_zfs_err_out;
78619397407SSherry Moore 	}
78719397407SSherry Moore 
788753a6d45SSherry Moore 	if (zpool_get_physpath(zpoolp, physpath, sizeof (physpath)) != 0) {
789753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("Cannot find phys_path\n"));
79019397407SSherry Moore 		rc = -1;
79119397407SSherry Moore 		goto validate_zfs_err_out;
79219397407SSherry Moore 	}
79319397407SSherry Moore 
794753a6d45SSherry Moore 	/*
795753a6d45SSherry Moore 	 * For the mirror physpath would contain the list of all
796753a6d45SSherry Moore 	 * bootable devices, pick up the first one.
797753a6d45SSherry Moore 	 */
798753a6d45SSherry Moore 	(void) strtok(physpath, " ");
799753a6d45SSherry Moore 	if (snprintf(bootfs_arg, BOOTARGS_MAX, fmt, bootfs, physpath) >=
800753a6d45SSherry Moore 	    BOOTARGS_MAX) {
801753a6d45SSherry Moore 		rc = E2BIG;
802753a6d45SSherry Moore 		(void) fprintf(stderr,
803753a6d45SSherry Moore 		    gettext("Boot arguments are too long\n"));
80419397407SSherry Moore 	}
80519397407SSherry Moore 
80619397407SSherry Moore validate_zfs_err_out:
80719397407SSherry Moore 	if (zhp != NULL)
80819397407SSherry Moore 		zfs_close(zhp);
80919397407SSherry Moore 
81019397407SSherry Moore 	if (zpoolp != NULL)
81119397407SSherry Moore 		zpool_close(zpoolp);
81219397407SSherry Moore 
81319397407SSherry Moore 	libzfs_fini(g_zfs);
81419397407SSherry Moore 	return (rc);
81519397407SSherry Moore }
81619397407SSherry Moore 
81719397407SSherry Moore /*
81819397407SSherry Moore  * Validate that the file exists, and is an ELF file.
81919397407SSherry Moore  * Returns 0 on success, -1 on failure.
82019397407SSherry Moore  */
82119397407SSherry Moore static int
8225b89e3f7SSherry Moore validate_unix(char *arg, int *mplen, int *is_zfs, char *bootfs_arg)
82319397407SSherry Moore {
82419397407SSherry Moore 	const char *location;
82519397407SSherry Moore 	int class, format;
82619397407SSherry Moore 	unsigned char ident[EI_NIDENT];
82719397407SSherry Moore 	char physpath[MAXPATHLEN];
82819397407SSherry Moore 	int elffd = -1;
82919397407SSherry Moore 	size_t	sz;
83019397407SSherry Moore 
83119397407SSherry Moore 	if ((sz = resolvepath(arg, physpath, sizeof (physpath) - 1)) ==
83219397407SSherry Moore 	    (size_t)-1) {
83319397407SSherry Moore 		(void) fprintf(stderr,
834753a6d45SSherry Moore 		    gettext("Cannot resolve path for %s: %s\n"),
83519397407SSherry Moore 		    arg, strerror(errno));
83619397407SSherry Moore 		return (-1);
83719397407SSherry Moore 	}
83819397407SSherry Moore 	(void) strlcpy(arg, physpath, sz + 1);
83919397407SSherry Moore 
84019397407SSherry Moore 	if (strlen(arg) > MAXPATHLEN) {
84119397407SSherry Moore 		(void) fprintf(stderr,
842753a6d45SSherry Moore 		    gettext("%s: New kernel name is too long\n"), cmdname);
84319397407SSherry Moore 		return (-1);
84419397407SSherry Moore 	}
84519397407SSherry Moore 
84619397407SSherry Moore 	if (strncmp(basename(arg), "unix", 4) != 0) {
84719397407SSherry Moore 		(void) fprintf(stderr,
848753a6d45SSherry Moore 		    gettext("%s: %s: Kernel name must be unix\n"),
84919397407SSherry Moore 		    cmdname, arg);
85019397407SSherry Moore 		return (-1);
85119397407SSherry Moore 	}
85219397407SSherry Moore 
85319397407SSherry Moore 	if (get_zfs_bootfs_arg(arg, &location, is_zfs, bootfs_arg) != 0)
85419397407SSherry Moore 		goto err_out;
85519397407SSherry Moore 
85619397407SSherry Moore 	*mplen = location - arg;
85719397407SSherry Moore 
8585b89e3f7SSherry Moore 	if (strstr(location, "/boot/platform") == location) {
8595b89e3f7SSherry Moore 		/*
8605b89e3f7SSherry Moore 		 * Rebooting to failsafe.
8615b89e3f7SSherry Moore 		 * Clear bootfs_arg and is_zfs flag.
8625b89e3f7SSherry Moore 		 */
8635b89e3f7SSherry Moore 		bootfs_arg[0] = 0;
8645b89e3f7SSherry Moore 		*is_zfs = 0;
8655b89e3f7SSherry Moore 	} else if (strstr(location, "/platform") != location) {
86619397407SSherry Moore 		(void) fprintf(stderr,
8675b89e3f7SSherry Moore 		    gettext("%s: %s: No /platform in file name\n"),
8685b89e3f7SSherry Moore 		    cmdname, arg);
8695b89e3f7SSherry Moore 		goto err_out;
87019397407SSherry Moore 	}
87119397407SSherry Moore 
87219397407SSherry Moore 	if ((elffd = open64(arg, O_RDONLY)) < 0 ||
87319397407SSherry Moore 	    (pread64(elffd, ident, EI_NIDENT, 0) != EI_NIDENT)) {
87419397407SSherry Moore 		(void) fprintf(stderr, "%s: %s: %s\n",
87519397407SSherry Moore 		    cmdname, arg, strerror(errno));
87619397407SSherry Moore 		goto err_out;
87719397407SSherry Moore 	}
87819397407SSherry Moore 
87919397407SSherry Moore 	class = ident[EI_CLASS];
88019397407SSherry Moore 
88119397407SSherry Moore 	if ((class != ELFCLASS32 && class != ELFCLASS64) ||
882753a6d45SSherry Moore 	    memcmp(&ident[EI_MAG0], ELFMAG, 4) != 0) {
88319397407SSherry Moore 		(void) fprintf(stderr,
884753a6d45SSherry Moore 		    gettext("%s: %s: Not a valid ELF file\n"), cmdname, arg);
88519397407SSherry Moore 		goto err_out;
88619397407SSherry Moore 	}
88719397407SSherry Moore 
88819397407SSherry Moore 	format = ident[EI_DATA];
88919397407SSherry Moore 
89019397407SSherry Moore 	if (format != CUR_ELFDATA) {
891753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("%s: %s: Invalid data format\n"),
89219397407SSherry Moore 		    cmdname, arg);
89319397407SSherry Moore 		goto err_out;
89419397407SSherry Moore 	}
89519397407SSherry Moore 
89619397407SSherry Moore 	return (0);
89719397407SSherry Moore 
89819397407SSherry Moore err_out:
89919397407SSherry Moore 	if (elffd >= 0) {
90019397407SSherry Moore 		(void) close(elffd);
90119397407SSherry Moore 		elffd = -1;
90219397407SSherry Moore 	}
90319397407SSherry Moore 	return (-1);
90419397407SSherry Moore }
90519397407SSherry Moore 
9064e1f1c13SKonstantin Ananyev static int
9074e1f1c13SKonstantin Ananyev halt_exec(const char *path, ...)
9084e1f1c13SKonstantin Ananyev {
9094e1f1c13SKonstantin Ananyev 	pid_t		pid;
9104e1f1c13SKonstantin Ananyev 	int		i;
9114e1f1c13SKonstantin Ananyev 	int		st;
9124e1f1c13SKonstantin Ananyev 	const char	*arg;
9134e1f1c13SKonstantin Ananyev 	va_list	vp;
9144e1f1c13SKonstantin Ananyev 	const char	*argv[256];
9154e1f1c13SKonstantin Ananyev 
9164e1f1c13SKonstantin Ananyev 	if ((pid = fork()) == -1) {
9174e1f1c13SKonstantin Ananyev 		return (errno);
9184e1f1c13SKonstantin Ananyev 	} else if (pid == 0) {
9194e1f1c13SKonstantin Ananyev 		(void) fclose(stdout);
9204e1f1c13SKonstantin Ananyev 		(void) fclose(stderr);
9214e1f1c13SKonstantin Ananyev 
9224e1f1c13SKonstantin Ananyev 		argv[0] = path;
9234e1f1c13SKonstantin Ananyev 		i = 1;
9244e1f1c13SKonstantin Ananyev 
9254e1f1c13SKonstantin Ananyev 		va_start(vp, path);
9264e1f1c13SKonstantin Ananyev 
9274e1f1c13SKonstantin Ananyev 		do {
9284e1f1c13SKonstantin Ananyev 			arg = va_arg(vp, const char *);
9294e1f1c13SKonstantin Ananyev 			argv[i] = arg;
9304e1f1c13SKonstantin Ananyev 		} while (arg != NULL &&
9314e1f1c13SKonstantin Ananyev 		    ++i != sizeof (argv) / sizeof (argv[0]));
9324e1f1c13SKonstantin Ananyev 
9334e1f1c13SKonstantin Ananyev 		va_end(vp);
9344e1f1c13SKonstantin Ananyev 
9354e1f1c13SKonstantin Ananyev 		(void) execve(path, (char * const *)argv, NULL);
936753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("Cannot execute %s: %s\n"),
9374e1f1c13SKonstantin Ananyev 		    path, strerror(errno));
9384e1f1c13SKonstantin Ananyev 		exit(-1);
9394e1f1c13SKonstantin Ananyev 	} else {
9404e1f1c13SKonstantin Ananyev 		if (waitpid(pid, &st, 0) == pid &&
9414e1f1c13SKonstantin Ananyev 		    !WIFSIGNALED(st) && WIFEXITED(st))
9424e1f1c13SKonstantin Ananyev 			st = WEXITSTATUS(st);
9434e1f1c13SKonstantin Ananyev 		else
9444e1f1c13SKonstantin Ananyev 			st = -1;
9454e1f1c13SKonstantin Ananyev 	}
9464e1f1c13SKonstantin Ananyev 	return (st);
9474e1f1c13SKonstantin Ananyev }
9484e1f1c13SKonstantin Ananyev 
9494e1f1c13SKonstantin Ananyev /*
95080cb75f4SWilliam Kucharski  * Mount the specified BE.
95180cb75f4SWilliam Kucharski  *
95280cb75f4SWilliam Kucharski  * Upon success returns zero and copies bename string to mountpoint[]
9534e1f1c13SKonstantin Ananyev  */
95419397407SSherry Moore static int
95519397407SSherry Moore fastboot_bename(const char *bename, char *mountpoint, size_t mpsz)
95619397407SSherry Moore {
95719397407SSherry Moore 	int rc;
95819397407SSherry Moore 
95980cb75f4SWilliam Kucharski 	/*
96080cb75f4SWilliam Kucharski 	 * Attempt to unmount the BE first in case it's already mounted
96180cb75f4SWilliam Kucharski 	 * elsewhere.
96280cb75f4SWilliam Kucharski 	 */
96380cb75f4SWilliam Kucharski 	(void) halt_exec(BEADM_PROG, "umount", bename, NULL);
96419397407SSherry Moore 
96580cb75f4SWilliam Kucharski 	if ((rc = halt_exec(BEADM_PROG, "mount", bename, FASTBOOT_MOUNTPOINT,
9664e1f1c13SKonstantin Ananyev 	    NULL)) != 0)
96780cb75f4SWilliam Kucharski 		(void) fprintf(stderr,
96880cb75f4SWilliam Kucharski 		    gettext("%s: Unable to mount BE \"%s\" at %s\n"),
96980cb75f4SWilliam Kucharski 		    cmdname, bename, FASTBOOT_MOUNTPOINT);
97019397407SSherry Moore 	else
97119397407SSherry Moore 		(void) strlcpy(mountpoint, FASTBOOT_MOUNTPOINT, mpsz);
97219397407SSherry Moore 
97319397407SSherry Moore 	return (rc);
97419397407SSherry Moore }
97519397407SSherry Moore 
97619397407SSherry Moore /*
97719397407SSherry Moore  * Returns 0 on successful parsing of the arguments;
978753a6d45SSherry Moore  * returns EINVAL on parsing failures that should abort the reboot attempt;
979753a6d45SSherry Moore  * returns other error code to fall back to regular reboot.
98019397407SSherry Moore  */
98119397407SSherry Moore static int
982753a6d45SSherry Moore parse_fastboot_args(char *bootargs_buf, size_t buf_size,
9835b89e3f7SSherry Moore     int *is_dryrun, const char *bename)
98419397407SSherry Moore {
98519397407SSherry Moore 	char mountpoint[MAXPATHLEN];
98619397407SSherry Moore 	char bootargs_saved[BOOTARGS_MAX];
98719397407SSherry Moore 	char bootargs_scratch[BOOTARGS_MAX];
98819397407SSherry Moore 	char bootfs_arg[BOOTARGS_MAX];
98919397407SSherry Moore 	char unixfile[BOOTARGS_MAX];
99019397407SSherry Moore 	char *head, *newarg;
99119397407SSherry Moore 	int buflen;		/* length of the bootargs_buf */
99219397407SSherry Moore 	int mplen;		/* length of the mount point */
99319397407SSherry Moore 	int rootlen = 0;	/* length of the root argument */
99419397407SSherry Moore 	int unixlen = 0;	/* length of the unix argument */
99519397407SSherry Moore 	int off = 0;		/* offset into the new boot argument */
99619397407SSherry Moore 	int is_zfs = 0;
99719397407SSherry Moore 	int rc = 0;
99819397407SSherry Moore 
99919397407SSherry Moore 	bzero(mountpoint, sizeof (mountpoint));
100019397407SSherry Moore 
100119397407SSherry Moore 	/*
100219397407SSherry Moore 	 * If argc is not 0, buflen is length of the argument being passed in;
100319397407SSherry Moore 	 * else it is 0 as bootargs_buf has been initialized to all 0's.
100419397407SSherry Moore 	 */
100519397407SSherry Moore 	buflen = strlen(bootargs_buf);
100619397407SSherry Moore 
100719397407SSherry Moore 	/* Save a copy of the original argument */
100819397407SSherry Moore 	bcopy(bootargs_buf, bootargs_saved, buflen);
100919397407SSherry Moore 	bzero(&bootargs_saved[buflen], sizeof (bootargs_saved) - buflen);
101019397407SSherry Moore 
101119397407SSherry Moore 	/* Save another copy to be used by strtok */
101219397407SSherry Moore 	bcopy(bootargs_buf, bootargs_scratch, buflen);
101319397407SSherry Moore 	bzero(&bootargs_scratch[buflen], sizeof (bootargs_scratch) - buflen);
101419397407SSherry Moore 	head = &bootargs_scratch[0];
101519397407SSherry Moore 
101619397407SSherry Moore 	/* Get the first argument */
101719397407SSherry Moore 	newarg = strtok(bootargs_scratch, " ");
101819397407SSherry Moore 
101919397407SSherry Moore 	/*
102019397407SSherry Moore 	 * If this is a dry run request, verify that the drivers can handle
102119397407SSherry Moore 	 * fast reboot.
102219397407SSherry Moore 	 */
102319397407SSherry Moore 	if (newarg && strncasecmp(newarg, "dryrun", strlen("dryrun")) == 0) {
102419397407SSherry Moore 		*is_dryrun = 1;
102519397407SSherry Moore 		(void) system("/usr/sbin/devfsadm");
102619397407SSherry Moore 	}
102719397407SSherry Moore 
102819397407SSherry Moore 	/*
102919397407SSherry Moore 	 * Always perform a dry run to identify all the drivers that
103019397407SSherry Moore 	 * need to implement devo_reset().
103119397407SSherry Moore 	 */
103219397407SSherry Moore 	if (uadmin(A_SHUTDOWN, AD_FASTREBOOT_DRYRUN,
103319397407SSherry Moore 	    (uintptr_t)bootargs_saved) != 0) {
1034753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("%s: Not all drivers "
1035753a6d45SSherry Moore 		    "have implemented quiesce(9E)\n"
1036753a6d45SSherry Moore 		    "\tPlease see /var/adm/messages for drivers that haven't\n"
1037753a6d45SSherry Moore 		    "\timplemented quiesce(9E).\n"), cmdname);
103819397407SSherry Moore 	} else if (*is_dryrun) {
1039753a6d45SSherry Moore 		(void) fprintf(stderr, gettext("%s: All drivers have "
104019397407SSherry Moore 		    "implemented quiesce(9E)\n"), cmdname);
104119397407SSherry Moore 	}
104219397407SSherry Moore 
1043753a6d45SSherry Moore 	/* Return if it is a true dry run. */
104419397407SSherry Moore 	if (*is_dryrun)
104519397407SSherry Moore 		return (rc);
104619397407SSherry Moore 
1047753a6d45SSherry Moore #if defined(__i386)
1048753a6d45SSherry Moore 	/* Read boot args from GRUB menu */
1049753a6d45SSherry Moore 	if ((bootargs_buf[0] == 0 || isdigit(bootargs_buf[0])) &&
1050753a6d45SSherry Moore 	    bename == NULL) {
1051753a6d45SSherry Moore 		/*
1052753a6d45SSherry Moore 		 * If no boot arguments are given, or a GRUB menu entry
1053753a6d45SSherry Moore 		 * number is provided, process the GRUB menu.
1054753a6d45SSherry Moore 		 */
1055753a6d45SSherry Moore 		int entnum;
1056753a6d45SSherry Moore 		if (bootargs_buf[0] == 0)
1057753a6d45SSherry Moore 			entnum = GRUB_ENTRY_DEFAULT;
1058753a6d45SSherry Moore 		else {
1059753a6d45SSherry Moore 			errno = 0;
1060753a6d45SSherry Moore 			entnum = strtoul(bootargs_buf, NULL, 10);
1061753a6d45SSherry Moore 			rc = errno;
1062753a6d45SSherry Moore 		}
1063753a6d45SSherry Moore 
1064753a6d45SSherry Moore 		if (rc == 0 && (rc = grub_get_boot_args(&fbarg, NULL,
1065753a6d45SSherry Moore 		    entnum)) == 0) {
1066753a6d45SSherry Moore 			if (strlcpy(bootargs_buf, fbarg.gba_bootargs,
1067753a6d45SSherry Moore 			    buf_size) >= buf_size) {
1068753a6d45SSherry Moore 				grub_cleanup_boot_args(&fbarg);
1069753a6d45SSherry Moore 				bcopy(bootargs_saved, bootargs_buf, buf_size);
1070753a6d45SSherry Moore 				rc = E2BIG;
1071753a6d45SSherry Moore 			}
1072753a6d45SSherry Moore 		}
1073753a6d45SSherry Moore 		/* Failed to read GRUB menu, fall back to normal reboot */
1074753a6d45SSherry Moore 		if (rc != 0) {
1075753a6d45SSherry Moore 			(void) fprintf(stderr,
1076753a6d45SSherry Moore 			    gettext("%s: Failed to process GRUB menu "
1077753a6d45SSherry Moore 			    "entry for fast reboot.\n\t%s\n"),
1078753a6d45SSherry Moore 			    cmdname, grub_strerror(rc));
1079753a6d45SSherry Moore 			(void) fprintf(stderr,
1080753a6d45SSherry Moore 			    gettext("%s: Falling back to regular reboot.\n"),
1081753a6d45SSherry Moore 			    cmdname);
1082753a6d45SSherry Moore 			return (-1);
1083753a6d45SSherry Moore 		}
1084753a6d45SSherry Moore 		/* No need to process further */
1085753a6d45SSherry Moore 		fbarg_used = &fbarg;
1086753a6d45SSherry Moore 		fbarg_entnum = entnum;
1087753a6d45SSherry Moore 		return (0);
1088753a6d45SSherry Moore 	}
1089753a6d45SSherry Moore #endif	/* __i386 */
1090753a6d45SSherry Moore 
1091753a6d45SSherry Moore 	/* Zero out the boot argument buffer as we will reconstruct it */
1092753a6d45SSherry Moore 	bzero(bootargs_buf, buf_size);
1093753a6d45SSherry Moore 	bzero(bootfs_arg, sizeof (bootfs_arg));
1094753a6d45SSherry Moore 	bzero(unixfile, sizeof (unixfile));
1095753a6d45SSherry Moore 
109619397407SSherry Moore 	if (bename && (rc = fastboot_bename(bename, mountpoint,
109719397407SSherry Moore 	    sizeof (mountpoint))) != 0)
1098753a6d45SSherry Moore 		return (EINVAL);
1099753a6d45SSherry Moore 
110019397407SSherry Moore 
110119397407SSherry Moore 	/*
110219397407SSherry Moore 	 * If BE is not specified, look for disk argument to construct
110319397407SSherry Moore 	 * mountpoint; if BE has been specified, mountpoint has already been
110419397407SSherry Moore 	 * constructed.
110519397407SSherry Moore 	 */
110619397407SSherry Moore 	if (newarg && newarg[0] != '-' && !bename) {
110719397407SSherry Moore 		int tmprc;
110819397407SSherry Moore 
110919397407SSherry Moore 		if ((tmprc = validate_disk(newarg, mountpoint)) == 0) {
111019397407SSherry Moore 			/*
111119397407SSherry Moore 			 * The first argument is a valid root argument.
111219397407SSherry Moore 			 * Get the next argument.
111319397407SSherry Moore 			 */
111419397407SSherry Moore 			newarg = strtok(NULL, " ");
111519397407SSherry Moore 			rootlen = (newarg) ? (newarg - head) : buflen;
111619397407SSherry Moore 			(void) strlcpy(fastboot_mounted, mountpoint,
111719397407SSherry Moore 			    sizeof (fastboot_mounted));
111819397407SSherry Moore 
111919397407SSherry Moore 		} else if (tmprc == -1) {
112019397407SSherry Moore 			/*
112119397407SSherry Moore 			 * Not a disk argument.  Use / as default root.
112219397407SSherry Moore 			 */
112319397407SSherry Moore 			bcopy("/", mountpoint, 1);
112419397407SSherry Moore 			bzero(&mountpoint[1], sizeof (mountpoint) - 1);
112519397407SSherry Moore 		} else {
112619397407SSherry Moore 			/*
112719397407SSherry Moore 			 * Disk argument, but not valid or not root.
112819397407SSherry Moore 			 * Return failure.
112919397407SSherry Moore 			 */
113019397407SSherry Moore 			return (EINVAL);
113119397407SSherry Moore 		}
113219397407SSherry Moore 	}
113319397407SSherry Moore 
113419397407SSherry Moore 	/*
113519397407SSherry Moore 	 * Make mountpoint the first part of unixfile.
113619397407SSherry Moore 	 * If there is not disk argument, and BE has not been specified,
113719397407SSherry Moore 	 * mountpoint could be empty.
113819397407SSherry Moore 	 */
113919397407SSherry Moore 	mplen = strlen(mountpoint);
114019397407SSherry Moore 	bcopy(mountpoint, unixfile, mplen);
114119397407SSherry Moore 
114219397407SSherry Moore 	/*
114319397407SSherry Moore 	 * Look for unix argument
114419397407SSherry Moore 	 */
114519397407SSherry Moore 	if (newarg && newarg[0] != '-') {
114619397407SSherry Moore 		bcopy(newarg, &unixfile[mplen], strlen(newarg));
114719397407SSherry Moore 		newarg = strtok(NULL, " ");
114819397407SSherry Moore 		rootlen = (newarg) ? (newarg - head) : buflen;
114919397407SSherry Moore 	} else if (mplen != 0) {
115019397407SSherry Moore 		/*
115119397407SSherry Moore 		 * No unix argument, but mountpoint is not empty, use
115219397407SSherry Moore 		 * /platform/i86pc/$ISADIR/kernel/unix as default.
115319397407SSherry Moore 		 */
115419397407SSherry Moore 		char isa[20];
115519397407SSherry Moore 
115619397407SSherry Moore 		if (sysinfo(SI_ARCHITECTURE_64, isa, sizeof (isa)) != -1)
115719397407SSherry Moore 			(void) snprintf(&unixfile[mplen],
115819397407SSherry Moore 			    sizeof (unixfile) - mplen,
115919397407SSherry Moore 			    "/platform/i86pc/kernel/%s/unix", isa);
116019397407SSherry Moore 		else if (sysinfo(SI_ARCHITECTURE_32, isa, sizeof (isa)) != -1) {
116119397407SSherry Moore 			(void) snprintf(&unixfile[mplen],
116219397407SSherry Moore 			    sizeof (unixfile) - mplen,
116319397407SSherry Moore 			    "/platform/i86pc/kernel/unix");
116419397407SSherry Moore 		} else {
116519397407SSherry Moore 			(void) fprintf(stderr,
1166753a6d45SSherry Moore 			    gettext("%s: Unknown architecture"), cmdname);
116719397407SSherry Moore 			return (EINVAL);
116819397407SSherry Moore 		}
116919397407SSherry Moore 	}
117019397407SSherry Moore 
117119397407SSherry Moore 	/*
117219397407SSherry Moore 	 * We now have the complete unix argument.  Verify that it exists and
117319397407SSherry Moore 	 * is an ELF file.  Split the argument up into mountpoint and unix
117419397407SSherry Moore 	 * portions again.  This is necessary to handle cases where mountpoint
117519397407SSherry Moore 	 * is specified on the command line as part of the unix argument,
117619397407SSherry Moore 	 * such as this:
117719397407SSherry Moore 	 *	# reboot -f /.alt/platform/i86pc/kernel/amd64/unix
117819397407SSherry Moore 	 */
117919397407SSherry Moore 	unixlen = strlen(unixfile);
118019397407SSherry Moore 	if (unixlen > 0) {
118119397407SSherry Moore 		if (validate_unix(unixfile, &mplen, &is_zfs,
11825b89e3f7SSherry Moore 		    bootfs_arg) != 0) {
118319397407SSherry Moore 			/* Not a valid unix file */
118419397407SSherry Moore 			return (EINVAL);
118519397407SSherry Moore 		} else {
11866bc8bc6aSSherry Moore 			int space = 0;
118719397407SSherry Moore 			/*
118819397407SSherry Moore 			 * Construct boot argument.
118919397407SSherry Moore 			 */
119019397407SSherry Moore 			unixlen = strlen(unixfile);
11916bc8bc6aSSherry Moore 
11926bc8bc6aSSherry Moore 			/*
11936bc8bc6aSSherry Moore 			 * mdep cannot start with space because bootadm
11946bc8bc6aSSherry Moore 			 * creates bogus menu entries if it does.
11956bc8bc6aSSherry Moore 			 */
11966bc8bc6aSSherry Moore 			if (mplen > 0) {
11976bc8bc6aSSherry Moore 				bcopy(unixfile, bootargs_buf, mplen);
11986bc8bc6aSSherry Moore 				(void) strcat(bootargs_buf, " ");
11996bc8bc6aSSherry Moore 				space = 1;
12006bc8bc6aSSherry Moore 			}
12016bc8bc6aSSherry Moore 			bcopy(&unixfile[mplen], &bootargs_buf[mplen + space],
120219397407SSherry Moore 			    unixlen - mplen);
120319397407SSherry Moore 			(void) strcat(bootargs_buf, " ");
12046bc8bc6aSSherry Moore 			off += unixlen + space + 1;
120519397407SSherry Moore 		}
120619397407SSherry Moore 	} else {
120719397407SSherry Moore 		/* Check to see if root is zfs */
120819397407SSherry Moore 		const char	*dp;
120919397407SSherry Moore 		(void) get_zfs_bootfs_arg("/", &dp, &is_zfs, bootfs_arg);
121019397407SSherry Moore 	}
121119397407SSherry Moore 
121219397407SSherry Moore 	if (is_zfs && (buflen != 0 || bename != NULL))	{
121319397407SSherry Moore 		/* LINTED E_SEC_SPRINTF_UNBOUNDED_COPY */
121419397407SSherry Moore 		off += sprintf(bootargs_buf + off, "%s ", bootfs_arg);
121519397407SSherry Moore 	}
121619397407SSherry Moore 
121719397407SSherry Moore 	/*
121819397407SSherry Moore 	 * Copy the rest of the arguments
121919397407SSherry Moore 	 */
122019397407SSherry Moore 	bcopy(&bootargs_saved[rootlen], &bootargs_buf[off], buflen - rootlen);
122119397407SSherry Moore 
122219397407SSherry Moore 	return (rc);
122319397407SSherry Moore }
122419397407SSherry Moore 
1225de0cf919SEnrico Perla - Sun Microsystems #define	MAXARGS		5
1226de0cf919SEnrico Perla - Sun Microsystems 
1227de0cf919SEnrico Perla - Sun Microsystems static void
1228de0cf919SEnrico Perla - Sun Microsystems do_archives_update(int do_fast_reboot)
1229de0cf919SEnrico Perla - Sun Microsystems {
1230de0cf919SEnrico Perla - Sun Microsystems 	int	r, i = 0;
1231de0cf919SEnrico Perla - Sun Microsystems 	pid_t	pid;
1232de0cf919SEnrico Perla - Sun Microsystems 	char	*cmd_argv[MAXARGS];
1233de0cf919SEnrico Perla - Sun Microsystems 
1234de0cf919SEnrico Perla - Sun Microsystems 
1235de0cf919SEnrico Perla - Sun Microsystems 	cmd_argv[i++] = "/sbin/bootadm";
1236de0cf919SEnrico Perla - Sun Microsystems 	cmd_argv[i++] = "-ea";
1237de0cf919SEnrico Perla - Sun Microsystems 	cmd_argv[i++] = "update_all";
1238de0cf919SEnrico Perla - Sun Microsystems 	if (do_fast_reboot)
1239de0cf919SEnrico Perla - Sun Microsystems 		cmd_argv[i++] = "fastboot";
1240de0cf919SEnrico Perla - Sun Microsystems 	cmd_argv[i] = NULL;
1241de0cf919SEnrico Perla - Sun Microsystems 
1242de0cf919SEnrico Perla - Sun Microsystems 	r = posix_spawn(&pid, cmd_argv[0], NULL, NULL, cmd_argv, NULL);
1243de0cf919SEnrico Perla - Sun Microsystems 
1244de0cf919SEnrico Perla - Sun Microsystems 	/* if posix_spawn fails we emit a warning and continue */
1245de0cf919SEnrico Perla - Sun Microsystems 
1246de0cf919SEnrico Perla - Sun Microsystems 	if (r != 0)
1247de0cf919SEnrico Perla - Sun Microsystems 		(void) fprintf(stderr, gettext("%s: WARNING, unable to start "
1248de0cf919SEnrico Perla - Sun Microsystems 		    "boot archive update\n"), cmdname);
1249de0cf919SEnrico Perla - Sun Microsystems 	else
1250de0cf919SEnrico Perla - Sun Microsystems 		while (waitpid(pid, NULL, 0) == -1 && errno == EINTR)
1251de0cf919SEnrico Perla - Sun Microsystems 			;
1252de0cf919SEnrico Perla - Sun Microsystems }
1253de0cf919SEnrico Perla - Sun Microsystems 
12547c478bd9Sstevel@tonic-gate int
12557c478bd9Sstevel@tonic-gate main(int argc, char *argv[])
12567c478bd9Sstevel@tonic-gate {
12577c478bd9Sstevel@tonic-gate 	int qflag = 0, needlog = 1, nosync = 0;
125819397407SSherry Moore 	int fast_reboot = 0;
1259753a6d45SSherry Moore 	int prom_reboot = 0;
12607c478bd9Sstevel@tonic-gate 	uintptr_t mdep = NULL;
12617c478bd9Sstevel@tonic-gate 	int cmd, fcn, c, aval, r;
12627c478bd9Sstevel@tonic-gate 	const char *usage;
12638e07a41fSKonstantin Ananyev 	const char *optstring;
12647c478bd9Sstevel@tonic-gate 	zoneid_t zoneid = getzoneid();
12653f2f09c1Sdp 	int need_check_zones = 0;
12663f2f09c1Sdp 	char bootargs_buf[BOOTARGS_MAX];
12673b860eeeSSherry Moore 	char *bootargs_orig = NULL;
126819397407SSherry Moore 	char *bename = NULL;
12697c478bd9Sstevel@tonic-gate 
12707c478bd9Sstevel@tonic-gate 	const char * const resetting = "/etc/svc/volatile/resetting";
12717c478bd9Sstevel@tonic-gate 
12727c478bd9Sstevel@tonic-gate 	(void) setlocale(LC_ALL, "");
12737c478bd9Sstevel@tonic-gate 	(void) textdomain(TEXT_DOMAIN);
12747c478bd9Sstevel@tonic-gate 
12753f2f09c1Sdp 	cmdname = basename(argv[0]);
12763f2f09c1Sdp 
12777c478bd9Sstevel@tonic-gate 	if (strcmp(cmdname, "halt") == 0) {
12787c478bd9Sstevel@tonic-gate 		(void) audit_halt_setup(argc, argv);
12798e07a41fSKonstantin Ananyev 		optstring = "dlnqy";
12807c478bd9Sstevel@tonic-gate 		usage = gettext("usage: %s [ -dlnqy ]\n");
12817c478bd9Sstevel@tonic-gate 		cmd = A_SHUTDOWN;
12827c478bd9Sstevel@tonic-gate 		fcn = AD_HALT;
12837c478bd9Sstevel@tonic-gate 	} else if (strcmp(cmdname, "poweroff") == 0) {
12847c478bd9Sstevel@tonic-gate 		(void) audit_halt_setup(argc, argv);
12858e07a41fSKonstantin Ananyev 		optstring = "dlnqy";
12867c478bd9Sstevel@tonic-gate 		usage = gettext("usage: %s [ -dlnqy ]\n");
12877c478bd9Sstevel@tonic-gate 		cmd = A_SHUTDOWN;
12887c478bd9Sstevel@tonic-gate 		fcn = AD_POWEROFF;
12897c478bd9Sstevel@tonic-gate 	} else if (strcmp(cmdname, "reboot") == 0) {
12907c478bd9Sstevel@tonic-gate 		(void) audit_reboot_setup();
129119397407SSherry Moore #if defined(__i386)
1292753a6d45SSherry Moore 		optstring = "dlnqpfe:";
1293753a6d45SSherry Moore 		usage = gettext("usage: %s [ -dlnq(p|fe:) ] [ boot args ]\n");
129419397407SSherry Moore #else
1295e557d412SChristopher Kiick 		optstring = "dlnqfp";
1296e557d412SChristopher Kiick 		usage = gettext("usage: %s [ -dlnq(p|f) ] [ boot args ]\n");
129719397407SSherry Moore #endif
12987c478bd9Sstevel@tonic-gate 		cmd = A_SHUTDOWN;
12997c478bd9Sstevel@tonic-gate 		fcn = AD_BOOT;
13007c478bd9Sstevel@tonic-gate 	} else {
13017c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
13027c478bd9Sstevel@tonic-gate 		    gettext("%s: not installed properly\n"), cmdname);
13037c478bd9Sstevel@tonic-gate 		return (1);
13047c478bd9Sstevel@tonic-gate 	}
13057c478bd9Sstevel@tonic-gate 
13068e07a41fSKonstantin Ananyev 	while ((c = getopt(argc, argv, optstring)) != EOF) {
13077c478bd9Sstevel@tonic-gate 		switch (c) {
13087c478bd9Sstevel@tonic-gate 		case 'd':
13097c478bd9Sstevel@tonic-gate 			if (zoneid == GLOBAL_ZONEID)
13107c478bd9Sstevel@tonic-gate 				cmd = A_DUMP;
13117c478bd9Sstevel@tonic-gate 			else {
13127c478bd9Sstevel@tonic-gate 				(void) fprintf(stderr,
13137c478bd9Sstevel@tonic-gate 				    gettext("%s: -d only valid from global"
13147c478bd9Sstevel@tonic-gate 				    " zone\n"), cmdname);
13157c478bd9Sstevel@tonic-gate 				return (1);
13167c478bd9Sstevel@tonic-gate 			}
13177c478bd9Sstevel@tonic-gate 			break;
13187c478bd9Sstevel@tonic-gate 		case 'l':
13197c478bd9Sstevel@tonic-gate 			needlog = 0;
13207c478bd9Sstevel@tonic-gate 			break;
13217c478bd9Sstevel@tonic-gate 		case 'n':
13227c478bd9Sstevel@tonic-gate 			nosync = 1;
13237c478bd9Sstevel@tonic-gate 			break;
13247c478bd9Sstevel@tonic-gate 		case 'q':
13257c478bd9Sstevel@tonic-gate 			qflag = 1;
13267c478bd9Sstevel@tonic-gate 			break;
13277c478bd9Sstevel@tonic-gate 		case 'y':
1328*bc2cf0f5SJoshua M. Clulow 			/*
1329*bc2cf0f5SJoshua M. Clulow 			 * Option ignored for backwards compatibility.
1330*bc2cf0f5SJoshua M. Clulow 			 */
13317c478bd9Sstevel@tonic-gate 			break;
133219397407SSherry Moore 		case 'f':
133319397407SSherry Moore 			fast_reboot = 1;
133419397407SSherry Moore 			break;
1335e557d412SChristopher Kiick 		case 'p':
1336e557d412SChristopher Kiick 			prom_reboot = 1;
1337e557d412SChristopher Kiick 			break;
1338e557d412SChristopher Kiick #if defined(__i386)
133919397407SSherry Moore 		case 'e':
134019397407SSherry Moore 			bename = optarg;
134119397407SSherry Moore 			break;
134219397407SSherry Moore #endif
13437c478bd9Sstevel@tonic-gate 		default:
13447c478bd9Sstevel@tonic-gate 			/*
13457c478bd9Sstevel@tonic-gate 			 * TRANSLATION_NOTE
13467c478bd9Sstevel@tonic-gate 			 * Don't translate the words "halt" or "reboot"
13477c478bd9Sstevel@tonic-gate 			 */
13487c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, usage, cmdname);
13497c478bd9Sstevel@tonic-gate 			return (1);
13507c478bd9Sstevel@tonic-gate 		}
13517c478bd9Sstevel@tonic-gate 	}
13527c478bd9Sstevel@tonic-gate 
13537c478bd9Sstevel@tonic-gate 	argc -= optind;
13547c478bd9Sstevel@tonic-gate 	argv += optind;
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 	if (argc != 0) {
13577c478bd9Sstevel@tonic-gate 		if (fcn != AD_BOOT) {
13587c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, usage, cmdname);
13597c478bd9Sstevel@tonic-gate 			return (1);
13607c478bd9Sstevel@tonic-gate 		}
13617c478bd9Sstevel@tonic-gate 
13627c478bd9Sstevel@tonic-gate 		/* Gather the arguments into bootargs_buf. */
13637c478bd9Sstevel@tonic-gate 		if (gather_args(argv, bootargs_buf, sizeof (bootargs_buf)) !=
13647c478bd9Sstevel@tonic-gate 		    0) {
13657c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
13667c478bd9Sstevel@tonic-gate 			    gettext("%s: Boot arguments too long.\n"), cmdname);
13677c478bd9Sstevel@tonic-gate 			return (1);
13687c478bd9Sstevel@tonic-gate 		}
136919397407SSherry Moore 
13703b860eeeSSherry Moore 		bootargs_orig = strdup(bootargs_buf);
13717c478bd9Sstevel@tonic-gate 		mdep = (uintptr_t)bootargs_buf;
137219397407SSherry Moore 	} else {
137319397407SSherry Moore 		/*
137419397407SSherry Moore 		 * Initialize it to 0 in case of fastboot, the buffer
137519397407SSherry Moore 		 * will be used.
137619397407SSherry Moore 		 */
137719397407SSherry Moore 		bzero(bootargs_buf, sizeof (bootargs_buf));
13787c478bd9Sstevel@tonic-gate 	}
13797c478bd9Sstevel@tonic-gate 
1380753a6d45SSherry Moore 	if (geteuid() != 0) {
13817c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
13827c478bd9Sstevel@tonic-gate 		    gettext("%s: permission denied\n"), cmdname);
13837c478bd9Sstevel@tonic-gate 		goto fail;
13847c478bd9Sstevel@tonic-gate 	}
13857c478bd9Sstevel@tonic-gate 
1386753a6d45SSherry Moore 	if (fast_reboot && prom_reboot) {
1387753a6d45SSherry Moore 		(void) fprintf(stderr,
1388753a6d45SSherry Moore 		    gettext("%s: -p and -f are mutually exclusive\n"),
1389753a6d45SSherry Moore 		    cmdname);
1390753a6d45SSherry Moore 		return (EINVAL);
1391753a6d45SSherry Moore 	}
139219397407SSherry Moore 	/*
1393753a6d45SSherry Moore 	 * Check whether fast reboot is the default operating mode
139419397407SSherry Moore 	 */
1395753a6d45SSherry Moore 	if (fcn == AD_BOOT && !fast_reboot && !prom_reboot &&
1396e557d412SChristopher Kiick 	    zoneid == GLOBAL_ZONEID) {
1397753a6d45SSherry Moore 		fast_reboot = scf_is_fastboot_default();
139819397407SSherry Moore 
1399e557d412SChristopher Kiick 	}
1400e557d412SChristopher Kiick 
140119397407SSherry Moore 	if (bename && !fast_reboot)	{
140219397407SSherry Moore 		(void) fprintf(stderr, gettext("%s: -e only valid with -f\n"),
140319397407SSherry Moore 		    cmdname);
140419397407SSherry Moore 		return (EINVAL);
140519397407SSherry Moore 	}
140619397407SSherry Moore 
1407e557d412SChristopher Kiick #if defined(__sparc)
1408e557d412SChristopher Kiick 	if (fast_reboot) {
1409e557d412SChristopher Kiick 		fast_reboot = 2;	/* need to distinguish each case */
1410e557d412SChristopher Kiick 	}
1411e557d412SChristopher Kiick #endif
1412e557d412SChristopher Kiick 
141319397407SSherry Moore 	/*
141419397407SSherry Moore 	 * If fast reboot, do some sanity check on the argument
141519397407SSherry Moore 	 */
1416e557d412SChristopher Kiick 	if (fast_reboot == 1) {
141719397407SSherry Moore 		int rc;
141819397407SSherry Moore 		int is_dryrun = 0;
141919397407SSherry Moore 
142019397407SSherry Moore 		if (zoneid != GLOBAL_ZONEID)	{
142119397407SSherry Moore 			(void) fprintf(stderr,
1422753a6d45SSherry Moore 			    gettext("%s: Fast reboot only valid from global"
142319397407SSherry Moore 			    " zone\n"), cmdname);
142419397407SSherry Moore 			return (EINVAL);
142519397407SSherry Moore 		}
142619397407SSherry Moore 
1427753a6d45SSherry Moore 		rc = parse_fastboot_args(bootargs_buf, sizeof (bootargs_buf),
14285b89e3f7SSherry Moore 		    &is_dryrun, bename);
142919397407SSherry Moore 
143019397407SSherry Moore 		/*
143119397407SSherry Moore 		 * If dry run, or if arguments are invalid, return.
143219397407SSherry Moore 		 */
143319397407SSherry Moore 		if (is_dryrun)
143419397407SSherry Moore 			return (rc);
1435753a6d45SSherry Moore 		else if (rc == EINVAL)
143619397407SSherry Moore 			goto fail;
1437753a6d45SSherry Moore 		else if (rc != 0)
1438753a6d45SSherry Moore 			fast_reboot = 0;
143919397407SSherry Moore 
144019397407SSherry Moore 		/*
144119397407SSherry Moore 		 * For all the other errors, we continue on in case user
1442753a6d45SSherry Moore 		 * user want to force fast reboot, or fall back to regular
1443753a6d45SSherry Moore 		 * reboot.
144419397407SSherry Moore 		 */
144519397407SSherry Moore 		if (strlen(bootargs_buf) != 0)
144619397407SSherry Moore 			mdep = (uintptr_t)bootargs_buf;
144719397407SSherry Moore 	}
144819397407SSherry Moore 
144919397407SSherry Moore #if 0	/* For debugging */
145019397407SSherry Moore 	if (mdep != NULL)
145119397407SSherry Moore 		(void) fprintf(stderr, "mdep = %s\n", (char *)mdep);
145219397407SSherry Moore #endif
145319397407SSherry Moore 
14547c478bd9Sstevel@tonic-gate 	if (needlog) {
14557c478bd9Sstevel@tonic-gate 		char *user = getlogin();
14567c478bd9Sstevel@tonic-gate 		struct passwd *pw;
1457f040a7a6Ssetje 		char *tty;
14587c478bd9Sstevel@tonic-gate 
14597c478bd9Sstevel@tonic-gate 		openlog(cmdname, 0, LOG_AUTH);
14607c478bd9Sstevel@tonic-gate 		if (user == NULL && (pw = getpwuid(getuid())) != NULL)
14617c478bd9Sstevel@tonic-gate 			user = pw->pw_name;
14627c478bd9Sstevel@tonic-gate 		if (user == NULL)
14637c478bd9Sstevel@tonic-gate 			user = "root";
1464f040a7a6Ssetje 
1465f040a7a6Ssetje 		tty = ttyname(1);
1466f040a7a6Ssetje 
1467f040a7a6Ssetje 		if (tty == NULL)
1468f040a7a6Ssetje 			syslog(LOG_CRIT, "initiated by %s", user);
1469f040a7a6Ssetje 		else
1470f040a7a6Ssetje 			syslog(LOG_CRIT, "initiated by %s on %s", user, tty);
14717c478bd9Sstevel@tonic-gate 	}
14727c478bd9Sstevel@tonic-gate 
14737c478bd9Sstevel@tonic-gate 	/*
14747c478bd9Sstevel@tonic-gate 	 * We must assume success and log it before auditd is terminated.
14757c478bd9Sstevel@tonic-gate 	 */
14767c478bd9Sstevel@tonic-gate 	if (fcn == AD_BOOT)
14777c478bd9Sstevel@tonic-gate 		aval = audit_reboot_success();
14787c478bd9Sstevel@tonic-gate 	else
14797c478bd9Sstevel@tonic-gate 		aval = audit_halt_success();
14807c478bd9Sstevel@tonic-gate 
14817c478bd9Sstevel@tonic-gate 	if (aval == -1) {
14827c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr,
14837c478bd9Sstevel@tonic-gate 		    gettext("%s: can't turn off auditd\n"), cmdname);
14847c478bd9Sstevel@tonic-gate 		if (needlog)
14857c478bd9Sstevel@tonic-gate 			(void) sleep(5); /* Give syslogd time to record this */
14867c478bd9Sstevel@tonic-gate 	}
14877c478bd9Sstevel@tonic-gate 
14887c478bd9Sstevel@tonic-gate 	(void) signal(SIGHUP, SIG_IGN);	/* for remote connections */
14897c478bd9Sstevel@tonic-gate 
149026f665e8Sdstaff 	/*
149126f665e8Sdstaff 	 * We start to fork a bunch of zoneadms to halt any active zones.
149226f665e8Sdstaff 	 * This will proceed with halt in parallel until we call
149326f665e8Sdstaff 	 * check_zone_haltedness later on.
149426f665e8Sdstaff 	 */
149526f665e8Sdstaff 	if (zoneid == GLOBAL_ZONEID && cmd != A_DUMP) {
14963f2f09c1Sdp 		need_check_zones = halt_zones();
149726f665e8Sdstaff 	}
149826f665e8Sdstaff 
1499753a6d45SSherry Moore #if defined(__i386)
1500753a6d45SSherry Moore 	/* set new default entry in the GRUB entry */
1501753a6d45SSherry Moore 	if (fbarg_entnum != GRUB_ENTRY_DEFAULT) {
1502753a6d45SSherry Moore 		char buf[32];
1503753a6d45SSherry Moore 		(void) snprintf(buf, sizeof (buf), "default=%u", fbarg_entnum);
1504753a6d45SSherry Moore 		(void) halt_exec(BOOTADM_PROG, "set-menu", buf, NULL);
1505753a6d45SSherry Moore 	}
1506753a6d45SSherry Moore #endif	/* __i386 */
150748847494SEnrico Perla - Sun Microsystems 
1508753a6d45SSherry Moore 	/* if we're dumping, do the archive update here and don't defer it */
1509de0cf919SEnrico Perla - Sun Microsystems 	if (cmd == A_DUMP && zoneid == GLOBAL_ZONEID && !nosync)
1510de0cf919SEnrico Perla - Sun Microsystems 		do_archives_update(fast_reboot);
15117c478bd9Sstevel@tonic-gate 
15127c478bd9Sstevel@tonic-gate 	/*
15137c478bd9Sstevel@tonic-gate 	 * If we're not forcing a crash dump, mark the system as quiescing for
15147c478bd9Sstevel@tonic-gate 	 * smf(5)'s benefit, and idle the init process.
15157c478bd9Sstevel@tonic-gate 	 */
15167c478bd9Sstevel@tonic-gate 	if (cmd != A_DUMP) {
15173f2f09c1Sdp 		if (direct_init(PCDSTOP) == -1) {
15187c478bd9Sstevel@tonic-gate 			/*
15197c478bd9Sstevel@tonic-gate 			 * TRANSLATION_NOTE
15207c478bd9Sstevel@tonic-gate 			 * Don't translate the word "init"
15217c478bd9Sstevel@tonic-gate 			 */
15227c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
15237c478bd9Sstevel@tonic-gate 			    gettext("%s: can't idle init\n"), cmdname);
15247c478bd9Sstevel@tonic-gate 			goto fail;
15257c478bd9Sstevel@tonic-gate 		}
15267c478bd9Sstevel@tonic-gate 
15277c478bd9Sstevel@tonic-gate 		if (creat(resetting, 0755) == -1)
15287c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr,
15297c478bd9Sstevel@tonic-gate 			    gettext("%s: could not create %s.\n"),
15307c478bd9Sstevel@tonic-gate 			    cmdname, resetting);
15319db7147eSSherry Moore 	}
15329db7147eSSherry Moore 
15339db7147eSSherry Moore 	/*
15349db7147eSSherry Moore 	 * Make sure we don't get stopped by a jobcontrol shell
15359db7147eSSherry Moore 	 * once we start killing everybody.
15369db7147eSSherry Moore 	 */
15379db7147eSSherry Moore 	(void) signal(SIGTSTP, SIG_IGN);
15389db7147eSSherry Moore 	(void) signal(SIGTTIN, SIG_IGN);
15399db7147eSSherry Moore 	(void) signal(SIGTTOU, SIG_IGN);
15409db7147eSSherry Moore 	(void) signal(SIGPIPE, SIG_IGN);
15419db7147eSSherry Moore 	(void) signal(SIGTERM, SIG_IGN);
15429db7147eSSherry Moore 
15439db7147eSSherry Moore 	/*
15449db7147eSSherry Moore 	 * Try to stop gdm so X has a chance to return the screen and
15459db7147eSSherry Moore 	 * keyboard to a sane state.
15469db7147eSSherry Moore 	 */
1547e557d412SChristopher Kiick 	if (fast_reboot == 1 && stop_gdm() != 0) {
15489db7147eSSherry Moore 		(void) fprintf(stderr,
15499db7147eSSherry Moore 		    gettext("%s: Falling back to regular reboot.\n"), cmdname);
15509db7147eSSherry Moore 		fast_reboot = 0;
15513b860eeeSSherry Moore 		mdep = (uintptr_t)bootargs_orig;
15523b860eeeSSherry Moore 	} else if (bootargs_orig) {
15533b860eeeSSherry Moore 		free(bootargs_orig);
15549db7147eSSherry Moore 	}
15557c478bd9Sstevel@tonic-gate 
15569db7147eSSherry Moore 	if (cmd != A_DUMP) {
15577c478bd9Sstevel@tonic-gate 		/*
15587c478bd9Sstevel@tonic-gate 		 * Stop all restarters so they do not try to restart services
15597c478bd9Sstevel@tonic-gate 		 * that are terminated.
15607c478bd9Sstevel@tonic-gate 		 */
15617c478bd9Sstevel@tonic-gate 		stop_restarters();
156226f665e8Sdstaff 
156326f665e8Sdstaff 		/*
156426f665e8Sdstaff 		 * Wait a little while for zones to shutdown.
156526f665e8Sdstaff 		 */
156626f665e8Sdstaff 		if (need_check_zones) {
15673f2f09c1Sdp 			check_zones_haltedness();
156826f665e8Sdstaff 
156926f665e8Sdstaff 			(void) fprintf(stderr,
157026f665e8Sdstaff 			    gettext("%s: Completing system halt.\n"),
157126f665e8Sdstaff 			    cmdname);
157226f665e8Sdstaff 		}
15737c478bd9Sstevel@tonic-gate 	}
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	/*
15767c478bd9Sstevel@tonic-gate 	 * If we're not forcing a crash dump, give everyone 5 seconds to
15777c478bd9Sstevel@tonic-gate 	 * handle a SIGTERM and clean up properly.
15787c478bd9Sstevel@tonic-gate 	 */
15797c478bd9Sstevel@tonic-gate 	if (cmd != A_DUMP) {
158048847494SEnrico Perla - Sun Microsystems 		int	start, end, delta;
158148847494SEnrico Perla - Sun Microsystems 
15827c478bd9Sstevel@tonic-gate 		(void) kill(-1, SIGTERM);
158348847494SEnrico Perla - Sun Microsystems 		start = time(NULL);
158448847494SEnrico Perla - Sun Microsystems 
1585de0cf919SEnrico Perla - Sun Microsystems 		if (zoneid == GLOBAL_ZONEID && !nosync)
1586de0cf919SEnrico Perla - Sun Microsystems 			do_archives_update(fast_reboot);
158748847494SEnrico Perla - Sun Microsystems 
158848847494SEnrico Perla - Sun Microsystems 		end = time(NULL);
158948847494SEnrico Perla - Sun Microsystems 		delta = end - start;
159048847494SEnrico Perla - Sun Microsystems 		if (delta < 5)
159148847494SEnrico Perla - Sun Microsystems 			(void) sleep(5 - delta);
15927c478bd9Sstevel@tonic-gate 	}
15937c478bd9Sstevel@tonic-gate 
15943a0fa635SEnrico Perla - Sun Microsystems 	(void) signal(SIGINT, SIG_IGN);
15953a0fa635SEnrico Perla - Sun Microsystems 
15967c478bd9Sstevel@tonic-gate 	if (!qflag && !nosync) {
15977c478bd9Sstevel@tonic-gate 		struct utmpx wtmpx;
15987c478bd9Sstevel@tonic-gate 
15997c478bd9Sstevel@tonic-gate 		bzero(&wtmpx, sizeof (struct utmpx));
16007c478bd9Sstevel@tonic-gate 		(void) strcpy(wtmpx.ut_line, "~");
16017c478bd9Sstevel@tonic-gate 		(void) time(&wtmpx.ut_tv.tv_sec);
16027c478bd9Sstevel@tonic-gate 
16037c478bd9Sstevel@tonic-gate 		if (cmd == A_DUMP)
16047c478bd9Sstevel@tonic-gate 			(void) strcpy(wtmpx.ut_name, "crash dump");
16057c478bd9Sstevel@tonic-gate 		else
16067c478bd9Sstevel@tonic-gate 			(void) strcpy(wtmpx.ut_name, "shutdown");
16077c478bd9Sstevel@tonic-gate 
16087c478bd9Sstevel@tonic-gate 		(void) updwtmpx(WTMPX_FILE, &wtmpx);
16097c478bd9Sstevel@tonic-gate 		sync();
16107c478bd9Sstevel@tonic-gate 	}
16117c478bd9Sstevel@tonic-gate 
16127c478bd9Sstevel@tonic-gate 	if (cmd == A_DUMP && nosync != 0)
16137c478bd9Sstevel@tonic-gate 		(void) uadmin(A_DUMP, AD_NOSYNC, NULL);
16147c478bd9Sstevel@tonic-gate 
16155b89e3f7SSherry Moore 	if (fast_reboot)
161619397407SSherry Moore 		fcn = AD_FASTREBOOT;
161719397407SSherry Moore 
16183f2f09c1Sdp 	if (uadmin(cmd, fcn, mdep) == -1)
16193f2f09c1Sdp 		(void) fprintf(stderr, "%s: uadmin failed: %s\n",
16203f2f09c1Sdp 		    cmdname, strerror(errno));
16213f2f09c1Sdp 	else
16223f2f09c1Sdp 		(void) fprintf(stderr, "%s: uadmin unexpectedly returned 0\n",
16233f2f09c1Sdp 		    cmdname);
16243f2f09c1Sdp 
16253f2f09c1Sdp 	do {
16267c478bd9Sstevel@tonic-gate 		r = remove(resetting);
16273f2f09c1Sdp 	} while (r != 0 && errno == EINTR);
16283f2f09c1Sdp 
16297c478bd9Sstevel@tonic-gate 	if (r != 0 && errno != ENOENT)
16307c478bd9Sstevel@tonic-gate 		(void) fprintf(stderr, gettext("%s: could not remove %s.\n"),
16317c478bd9Sstevel@tonic-gate 		    cmdname, resetting);
16327c478bd9Sstevel@tonic-gate 
16333f2f09c1Sdp 	if (direct_init(PCRUN) == -1) {
16343f2f09c1Sdp 		/*
16353f2f09c1Sdp 		 * TRANSLATION_NOTE
16363f2f09c1Sdp 		 * Don't translate the word "init"
16373f2f09c1Sdp 		 */
16383f2f09c1Sdp 		(void) fprintf(stderr,
16393f2f09c1Sdp 		    gettext("%s: can't resume init\n"), cmdname);
16403f2f09c1Sdp 	}
16413f2f09c1Sdp 
16427c478bd9Sstevel@tonic-gate 	continue_restarters();
16437c478bd9Sstevel@tonic-gate 
16443f2f09c1Sdp 	if (get_initpid() != -1)
16457c478bd9Sstevel@tonic-gate 		/* tell init to restate current level */
16463f2f09c1Sdp 		(void) kill(get_initpid(), SIGHUP);
16477c478bd9Sstevel@tonic-gate 
16487c478bd9Sstevel@tonic-gate fail:
16497c478bd9Sstevel@tonic-gate 	if (fcn == AD_BOOT)
16507c478bd9Sstevel@tonic-gate 		(void) audit_reboot_fail();
16517c478bd9Sstevel@tonic-gate 	else
16527c478bd9Sstevel@tonic-gate 		(void) audit_halt_fail();
16537c478bd9Sstevel@tonic-gate 
1654e557d412SChristopher Kiick 	if (fast_reboot == 1) {
165519397407SSherry Moore 		if (bename) {
165680cb75f4SWilliam Kucharski 			(void) halt_exec(BEADM_PROG, "umount", bename, NULL);
165719397407SSherry Moore 
165819397407SSherry Moore 		} else if (strlen(fastboot_mounted) != 0) {
165919397407SSherry Moore 			(void) umount(fastboot_mounted);
1660753a6d45SSherry Moore #if defined(__i386)
1661753a6d45SSherry Moore 		} else if (fbarg_used != NULL) {
1662753a6d45SSherry Moore 			grub_cleanup_boot_args(fbarg_used);
1663753a6d45SSherry Moore #endif	/* __i386 */
166419397407SSherry Moore 		}
166519397407SSherry Moore 	}
166619397407SSherry Moore 
16677c478bd9Sstevel@tonic-gate 	return (1);
16687c478bd9Sstevel@tonic-gate }
1669