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 */ 25bc2cf0f5SJoshua M. Clulow /* 26bc2cf0f5SJoshua M. Clulow * Copyright (c) 2013, Joyent, Inc. All rights reserved. 279adfa60dSMatthew Ahrens * Copyright (c) 2015 by Delphix. All rights reserved. 28*75383e32SAndy Fiddaman * Copyright 2016 Toomas Soome <tsoome@me.com> 29*75383e32SAndy Fiddaman * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 30bc2cf0f5SJoshua M. Clulow */ 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 33753a6d45SSherry Moore /* All Rights Reserved */ 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate /* 367c478bd9Sstevel@tonic-gate * University Copyright- Copyright (c) 1982, 1986, 1988 377c478bd9Sstevel@tonic-gate * The Regents of the University of California 387c478bd9Sstevel@tonic-gate * All Rights Reserved 397c478bd9Sstevel@tonic-gate * 407c478bd9Sstevel@tonic-gate * University Acknowledgment- Portions of this document are derived from 417c478bd9Sstevel@tonic-gate * software developed by the University of California, Berkeley, and its 427c478bd9Sstevel@tonic-gate * contributors. 438e07a41fSKonstantin Ananyev * Portions contributed by Juergen Keil, <jk@tools.de>. 447c478bd9Sstevel@tonic-gate */ 457c478bd9Sstevel@tonic-gate 467c478bd9Sstevel@tonic-gate 477c478bd9Sstevel@tonic-gate /* 487c478bd9Sstevel@tonic-gate * Common code for halt(1M), poweroff(1M), and reboot(1M). We use 497c478bd9Sstevel@tonic-gate * argv[0] to determine which behavior to exhibit. 507c478bd9Sstevel@tonic-gate */ 517c478bd9Sstevel@tonic-gate 5219397407SSherry Moore #include <stdio.h> 533f2f09c1Sdp #include <procfs.h> 547c478bd9Sstevel@tonic-gate #include <sys/types.h> 5519397407SSherry Moore #include <sys/elf.h> 5619397407SSherry Moore #include <sys/systeminfo.h> 5719397407SSherry Moore #include <sys/stat.h> 587c478bd9Sstevel@tonic-gate #include <sys/uadmin.h> 5919397407SSherry Moore #include <sys/mntent.h> 6019397407SSherry Moore #include <sys/mnttab.h> 6119397407SSherry Moore #include <sys/mount.h> 628e07a41fSKonstantin Ananyev #include <sys/fs/ufs_mount.h> 637c478bd9Sstevel@tonic-gate #include <alloca.h> 647c478bd9Sstevel@tonic-gate #include <assert.h> 657c478bd9Sstevel@tonic-gate #include <errno.h> 667c478bd9Sstevel@tonic-gate #include <fcntl.h> 677c478bd9Sstevel@tonic-gate #include <libgen.h> 687c478bd9Sstevel@tonic-gate #include <libscf.h> 69753a6d45SSherry Moore #include <libscf_priv.h> 7019397407SSherry Moore #include <limits.h> 717c478bd9Sstevel@tonic-gate #include <locale.h> 727c478bd9Sstevel@tonic-gate #include <libintl.h> 737c478bd9Sstevel@tonic-gate #include <syslog.h> 747c478bd9Sstevel@tonic-gate #include <signal.h> 757c478bd9Sstevel@tonic-gate #include <strings.h> 767c478bd9Sstevel@tonic-gate #include <unistd.h> 777c478bd9Sstevel@tonic-gate #include <stdlib.h> 787c478bd9Sstevel@tonic-gate #include <stdio.h> 797c478bd9Sstevel@tonic-gate #include <strings.h> 807c478bd9Sstevel@tonic-gate #include <time.h> 814e1f1c13SKonstantin Ananyev #include <wait.h> 824e1f1c13SKonstantin Ananyev #include <ctype.h> 837c478bd9Sstevel@tonic-gate #include <utmpx.h> 847c478bd9Sstevel@tonic-gate #include <pwd.h> 857c478bd9Sstevel@tonic-gate #include <zone.h> 863a0fa635SEnrico Perla - Sun Microsystems #include <spawn.h> 8719397407SSherry Moore 8819397407SSherry Moore #include <libzfs.h> 899abc7a57SToomas Soome #if defined(__x86) 909abc7a57SToomas Soome #include <libbe.h> 91753a6d45SSherry Moore #endif 9219397407SSherry Moore 937c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) 947c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" 957c478bd9Sstevel@tonic-gate #endif 967c478bd9Sstevel@tonic-gate 9719397407SSherry Moore #if defined(__sparc) 9819397407SSherry Moore #define CUR_ELFDATA ELFDATA2MSB 999abc7a57SToomas Soome #elif defined(__x86) 10019397407SSherry Moore #define CUR_ELFDATA ELFDATA2LSB 10119397407SSherry Moore #endif 10219397407SSherry Moore 10319397407SSherry Moore static libzfs_handle_t *g_zfs; 10419397407SSherry Moore 1057c478bd9Sstevel@tonic-gate extern int audit_halt_setup(int, char **); 1067c478bd9Sstevel@tonic-gate extern int audit_halt_success(void); 1077c478bd9Sstevel@tonic-gate extern int audit_halt_fail(void); 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate extern int audit_reboot_setup(void); 1107c478bd9Sstevel@tonic-gate extern int audit_reboot_success(void); 1117c478bd9Sstevel@tonic-gate extern int audit_reboot_fail(void); 1127c478bd9Sstevel@tonic-gate 1133f2f09c1Sdp static char *cmdname; /* basename(argv[0]), the name of the command */ 1143f2f09c1Sdp 1157c478bd9Sstevel@tonic-gate typedef struct ctidlist_struct { 1167c478bd9Sstevel@tonic-gate ctid_t ctid; 1177c478bd9Sstevel@tonic-gate struct ctidlist_struct *next; 1187c478bd9Sstevel@tonic-gate } ctidlist_t; 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate static ctidlist_t *ctidlist = NULL; 1217c478bd9Sstevel@tonic-gate static ctid_t startdct = -1; 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate #define FMRI_STARTD_CONTRACT \ 1247c478bd9Sstevel@tonic-gate "svc:/system/svc/restarter:default/:properties/restarter/contract" 1257c478bd9Sstevel@tonic-gate 12680cb75f4SWilliam Kucharski #define BEADM_PROG "/usr/sbin/beadm" 127753a6d45SSherry Moore #define BOOTADM_PROG "/sbin/bootadm" 12880cb75f4SWilliam Kucharski #define ZONEADM_PROG "/usr/sbin/zoneadm" 12980cb75f4SWilliam Kucharski 13019397407SSherry Moore /* 13119397407SSherry Moore * The length of FASTBOOT_MOUNTPOINT must be less than MAXPATHLEN. 13219397407SSherry Moore */ 13319397407SSherry Moore #define FASTBOOT_MOUNTPOINT "/tmp/.fastboot.root" 13419397407SSherry Moore 135753a6d45SSherry Moore /* 136753a6d45SSherry Moore * Fast Reboot related variables 137753a6d45SSherry Moore */ 13819397407SSherry Moore static char fastboot_mounted[MAXPATHLEN]; 139e557d412SChristopher Kiick 1409abc7a57SToomas Soome #if defined(__x86) 1419abc7a57SToomas Soome static char *fbarg; 1429abc7a57SToomas Soome static char *fbarg_used; 1439abc7a57SToomas Soome static int fbarg_entnum = BE_ENTRY_DEFAULT; 1449abc7a57SToomas Soome #endif /* __x86 */ 14519397407SSherry Moore 14619397407SSherry Moore static int validate_ufs_disk(char *, char *); 14719397407SSherry Moore static int validate_zfs_pool(char *, char *); 14819397407SSherry Moore 1493f2f09c1Sdp static pid_t 1503f2f09c1Sdp get_initpid() 1513f2f09c1Sdp { 1523f2f09c1Sdp static int init_pid = -1; 1533f2f09c1Sdp 1543f2f09c1Sdp if (init_pid == -1) { 1553f2f09c1Sdp if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid, 1563f2f09c1Sdp sizeof (init_pid)) != sizeof (init_pid)) { 1573f2f09c1Sdp assert(errno == ESRCH); 1583f2f09c1Sdp init_pid = -1; 1593f2f09c1Sdp } 1603f2f09c1Sdp } 1613f2f09c1Sdp return (init_pid); 1623f2f09c1Sdp } 1633f2f09c1Sdp 1643f2f09c1Sdp /* 1653f2f09c1Sdp * Quiesce or resume init using /proc. When stopping init, we can't send 1663f2f09c1Sdp * SIGTSTP (since init ignores it) or SIGSTOP (since the kernel won't permit 1673f2f09c1Sdp * it). 1683f2f09c1Sdp */ 1693f2f09c1Sdp static int 1703f2f09c1Sdp direct_init(long command) 1713f2f09c1Sdp { 1723f2f09c1Sdp char ctlfile[MAXPATHLEN]; 1733f2f09c1Sdp pid_t pid; 1743f2f09c1Sdp int ctlfd; 1753f2f09c1Sdp 1763f2f09c1Sdp assert(command == PCDSTOP || command == PCRUN); 1773f2f09c1Sdp if ((pid = get_initpid()) == -1) { 1783f2f09c1Sdp return (-1); 1793f2f09c1Sdp } 1803f2f09c1Sdp 1813f2f09c1Sdp (void) snprintf(ctlfile, sizeof (ctlfile), "/proc/%d/ctl", pid); 1823f2f09c1Sdp if ((ctlfd = open(ctlfile, O_WRONLY)) == -1) 1833f2f09c1Sdp return (-1); 1843f2f09c1Sdp 1853f2f09c1Sdp if (command == PCDSTOP) { 1863f2f09c1Sdp if (write(ctlfd, &command, sizeof (long)) == -1) { 1873f2f09c1Sdp (void) close(ctlfd); 1883f2f09c1Sdp return (-1); 1893f2f09c1Sdp } 1903f2f09c1Sdp } else { /* command == PCRUN */ 1913f2f09c1Sdp long cmds[2]; 1923f2f09c1Sdp cmds[0] = command; 1933f2f09c1Sdp cmds[1] = 0; 1943f2f09c1Sdp if (write(ctlfd, cmds, sizeof (cmds)) == -1) { 1953f2f09c1Sdp (void) close(ctlfd); 1963f2f09c1Sdp return (-1); 1973f2f09c1Sdp } 1983f2f09c1Sdp } 1993f2f09c1Sdp (void) close(ctlfd); 2003f2f09c1Sdp return (0); 2013f2f09c1Sdp } 2023f2f09c1Sdp 2037c478bd9Sstevel@tonic-gate static void 2047c478bd9Sstevel@tonic-gate stop_startd() 2057c478bd9Sstevel@tonic-gate { 2067c478bd9Sstevel@tonic-gate scf_handle_t *h; 2077c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL; 2087c478bd9Sstevel@tonic-gate scf_value_t *val = NULL; 2097c478bd9Sstevel@tonic-gate uint64_t uint64; 2107c478bd9Sstevel@tonic-gate 2113f2f09c1Sdp if ((h = scf_handle_create(SCF_VERSION)) == NULL) 2127c478bd9Sstevel@tonic-gate return; 2137c478bd9Sstevel@tonic-gate 2143f2f09c1Sdp if ((scf_handle_bind(h) != 0) || 2153f2f09c1Sdp ((prop = scf_property_create(h)) == NULL) || 2163f2f09c1Sdp ((val = scf_value_create(h)) == NULL)) 2177c478bd9Sstevel@tonic-gate goto out; 2187c478bd9Sstevel@tonic-gate 2193f2f09c1Sdp if (scf_handle_decode_fmri(h, FMRI_STARTD_CONTRACT, 2203f2f09c1Sdp NULL, NULL, NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0) 2217c478bd9Sstevel@tonic-gate goto out; 2227c478bd9Sstevel@tonic-gate 2233f2f09c1Sdp if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 || 2243f2f09c1Sdp scf_property_get_value(prop, val) != 0 || 2253f2f09c1Sdp scf_value_get_count(val, &uint64) != 0) 2267c478bd9Sstevel@tonic-gate goto out; 2277c478bd9Sstevel@tonic-gate 2283f2f09c1Sdp startdct = (ctid_t)uint64; 2293f2f09c1Sdp (void) sigsend(P_CTID, startdct, SIGSTOP); 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate out: 2323f2f09c1Sdp scf_property_destroy(prop); 2333f2f09c1Sdp scf_value_destroy(val); 2347c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate static void 2387c478bd9Sstevel@tonic-gate continue_startd() 2397c478bd9Sstevel@tonic-gate { 2407c478bd9Sstevel@tonic-gate if (startdct != -1) 2417c478bd9Sstevel@tonic-gate (void) sigsend(P_CTID, startdct, SIGCONT); 2427c478bd9Sstevel@tonic-gate } 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate #define FMRI_RESTARTER_PROP "/:properties/general/restarter" 2457c478bd9Sstevel@tonic-gate #define FMRI_CONTRACT_PROP "/:properties/restarter/contract" 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate static int 2487c478bd9Sstevel@tonic-gate save_ctid(ctid_t ctid) 2497c478bd9Sstevel@tonic-gate { 2507c478bd9Sstevel@tonic-gate ctidlist_t *next; 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate for (next = ctidlist; next != NULL; next = next->next) 2537c478bd9Sstevel@tonic-gate if (next->ctid == ctid) 2547c478bd9Sstevel@tonic-gate return (-1); 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate next = (ctidlist_t *)malloc(sizeof (ctidlist_t)); 2577c478bd9Sstevel@tonic-gate if (next == NULL) 2587c478bd9Sstevel@tonic-gate return (-1); 2597c478bd9Sstevel@tonic-gate 2607c478bd9Sstevel@tonic-gate next->ctid = ctid; 2617c478bd9Sstevel@tonic-gate next->next = ctidlist; 2627c478bd9Sstevel@tonic-gate ctidlist = next; 2637c478bd9Sstevel@tonic-gate return (0); 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate static void 2677c478bd9Sstevel@tonic-gate stop_delegates() 2687c478bd9Sstevel@tonic-gate { 2697c478bd9Sstevel@tonic-gate ctid_t ctid; 2707c478bd9Sstevel@tonic-gate scf_handle_t *h; 2717c478bd9Sstevel@tonic-gate scf_scope_t *sc = NULL; 2727c478bd9Sstevel@tonic-gate scf_service_t *svc = NULL; 2737c478bd9Sstevel@tonic-gate scf_instance_t *inst = NULL; 2747c478bd9Sstevel@tonic-gate scf_snapshot_t *snap = NULL; 2757c478bd9Sstevel@tonic-gate scf_snapshot_t *isnap = NULL; 2767c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL; 2777c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL; 2787c478bd9Sstevel@tonic-gate scf_value_t *val = NULL; 2797c478bd9Sstevel@tonic-gate scf_iter_t *siter = NULL; 2807c478bd9Sstevel@tonic-gate scf_iter_t *iiter = NULL; 2817c478bd9Sstevel@tonic-gate char *fmri; 2827c478bd9Sstevel@tonic-gate ssize_t length; 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate uint64_t uint64; 2857c478bd9Sstevel@tonic-gate ssize_t bytes; 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 2887c478bd9Sstevel@tonic-gate if (length <= 0) 2897c478bd9Sstevel@tonic-gate return; 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate length++; 2927c478bd9Sstevel@tonic-gate fmri = alloca(length * sizeof (char)); 2937c478bd9Sstevel@tonic-gate 2943f2f09c1Sdp if ((h = scf_handle_create(SCF_VERSION)) == NULL) 2957c478bd9Sstevel@tonic-gate return; 2967c478bd9Sstevel@tonic-gate 2973f2f09c1Sdp if (scf_handle_bind(h) != 0) { 2987c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 2997c478bd9Sstevel@tonic-gate return; 3007c478bd9Sstevel@tonic-gate } 3017c478bd9Sstevel@tonic-gate 3023f2f09c1Sdp if ((sc = scf_scope_create(h)) == NULL || 3033f2f09c1Sdp (svc = scf_service_create(h)) == NULL || 3043f2f09c1Sdp (inst = scf_instance_create(h)) == NULL || 3053f2f09c1Sdp (snap = scf_snapshot_create(h)) == NULL || 3063f2f09c1Sdp (pg = scf_pg_create(h)) == NULL || 3073f2f09c1Sdp (prop = scf_property_create(h)) == NULL || 3083f2f09c1Sdp (val = scf_value_create(h)) == NULL || 3093f2f09c1Sdp (siter = scf_iter_create(h)) == NULL || 3103f2f09c1Sdp (iiter = scf_iter_create(h)) == NULL) 3117c478bd9Sstevel@tonic-gate goto out; 3127c478bd9Sstevel@tonic-gate 3133f2f09c1Sdp if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, sc) != 0) 3147c478bd9Sstevel@tonic-gate goto out; 3157c478bd9Sstevel@tonic-gate 3163f2f09c1Sdp if (scf_iter_scope_services(siter, sc) != 0) 3177c478bd9Sstevel@tonic-gate goto out; 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate while (scf_iter_next_service(siter, svc) == 1) { 3207c478bd9Sstevel@tonic-gate 3213f2f09c1Sdp if (scf_iter_service_instances(iiter, svc) != 0) 3227c478bd9Sstevel@tonic-gate continue; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate while (scf_iter_next_instance(iiter, inst) == 1) { 3257c478bd9Sstevel@tonic-gate 3263f2f09c1Sdp if ((scf_instance_get_snapshot(inst, "running", 3273f2f09c1Sdp snap)) != 0) 3283f2f09c1Sdp isnap = NULL; 3293f2f09c1Sdp else 3303f2f09c1Sdp isnap = snap; 3317c478bd9Sstevel@tonic-gate 3323f2f09c1Sdp if (scf_instance_get_pg_composed(inst, isnap, 3333f2f09c1Sdp SCF_PG_GENERAL, pg) != 0) 3347c478bd9Sstevel@tonic-gate continue; 3357c478bd9Sstevel@tonic-gate 3363f2f09c1Sdp if (scf_pg_get_property(pg, SCF_PROPERTY_RESTARTER, 3373f2f09c1Sdp prop) != 0 || 3383f2f09c1Sdp scf_property_get_value(prop, val) != 0) 3397c478bd9Sstevel@tonic-gate continue; 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate bytes = scf_value_get_astring(val, fmri, length); 3427c478bd9Sstevel@tonic-gate if (bytes <= 0 || bytes >= length) 3437c478bd9Sstevel@tonic-gate continue; 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate if (strlcat(fmri, FMRI_CONTRACT_PROP, length) >= 3467c478bd9Sstevel@tonic-gate length) 3477c478bd9Sstevel@tonic-gate continue; 3487c478bd9Sstevel@tonic-gate 3493f2f09c1Sdp if (scf_handle_decode_fmri(h, fmri, NULL, NULL, 3503f2f09c1Sdp NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0) 3517c478bd9Sstevel@tonic-gate continue; 3527c478bd9Sstevel@tonic-gate 3533f2f09c1Sdp if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 || 3543f2f09c1Sdp scf_property_get_value(prop, val) != 0 || 3553f2f09c1Sdp scf_value_get_count(val, &uint64) != 0) 3567c478bd9Sstevel@tonic-gate continue; 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate ctid = (ctid_t)uint64; 3597c478bd9Sstevel@tonic-gate if (save_ctid(ctid) == 0) { 3607c478bd9Sstevel@tonic-gate (void) sigsend(P_CTID, ctid, SIGSTOP); 3617c478bd9Sstevel@tonic-gate } 3627c478bd9Sstevel@tonic-gate } 3637c478bd9Sstevel@tonic-gate } 3647c478bd9Sstevel@tonic-gate out: 3653f2f09c1Sdp scf_scope_destroy(sc); 3663f2f09c1Sdp scf_service_destroy(svc); 3673f2f09c1Sdp scf_instance_destroy(inst); 3683f2f09c1Sdp scf_snapshot_destroy(snap); 3693f2f09c1Sdp scf_pg_destroy(pg); 3703f2f09c1Sdp scf_property_destroy(prop); 3713f2f09c1Sdp scf_value_destroy(val); 3723f2f09c1Sdp scf_iter_destroy(siter); 3733f2f09c1Sdp scf_iter_destroy(iiter); 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate (void) scf_handle_unbind(h); 3767c478bd9Sstevel@tonic-gate scf_handle_destroy(h); 3777c478bd9Sstevel@tonic-gate } 3787c478bd9Sstevel@tonic-gate 3797c478bd9Sstevel@tonic-gate static void 3807c478bd9Sstevel@tonic-gate continue_delegates() 3817c478bd9Sstevel@tonic-gate { 3827c478bd9Sstevel@tonic-gate ctidlist_t *next; 3837c478bd9Sstevel@tonic-gate for (next = ctidlist; next != NULL; next = next->next) 3847c478bd9Sstevel@tonic-gate (void) sigsend(P_CTID, next->ctid, SIGCONT); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate 3879db7147eSSherry Moore #define FMRI_GDM "svc:/application/graphical-login/gdm:default" 3883b860eeeSSherry Moore #define GDM_STOP_TIMEOUT 10 /* Give gdm 10 seconds to shut down */ 3899db7147eSSherry Moore 3909db7147eSSherry Moore /* 3919db7147eSSherry Moore * If gdm is running, try to stop gdm. 3929db7147eSSherry Moore * Returns 0 on success, -1 on failure. 3939db7147eSSherry Moore */ 3949db7147eSSherry Moore static int 3959db7147eSSherry Moore stop_gdm() 3969db7147eSSherry Moore { 3979db7147eSSherry Moore char *gdm_state = NULL; 3989db7147eSSherry Moore int retry = 0; 3999db7147eSSherry Moore 4009db7147eSSherry Moore /* 4019db7147eSSherry Moore * If gdm is running, try to stop gdm. 4029db7147eSSherry Moore */ 4039db7147eSSherry Moore while ((gdm_state = smf_get_state(FMRI_GDM)) != NULL && 4043b860eeeSSherry Moore strcmp(gdm_state, SCF_STATE_STRING_ONLINE) == 0 && 4053b860eeeSSherry Moore retry++ < GDM_STOP_TIMEOUT) { 4063b860eeeSSherry Moore 4073b860eeeSSherry Moore free(gdm_state); 4083b860eeeSSherry Moore 4093b860eeeSSherry Moore /* 4103b860eeeSSherry Moore * Only need to disable once. 4113b860eeeSSherry Moore */ 4123b860eeeSSherry Moore if (retry == 1 && 4133b860eeeSSherry Moore smf_disable_instance(FMRI_GDM, SMF_TEMPORARY) != 0) { 4149db7147eSSherry Moore (void) fprintf(stderr, 4159db7147eSSherry Moore gettext("%s: Failed to stop %s: %s.\n"), 4169db7147eSSherry Moore cmdname, FMRI_GDM, scf_strerror(scf_error())); 4179db7147eSSherry Moore return (-1); 4189db7147eSSherry Moore } 4199db7147eSSherry Moore (void) sleep(1); 4209db7147eSSherry Moore } 4219db7147eSSherry Moore 4223b860eeeSSherry Moore if (retry >= GDM_STOP_TIMEOUT) { 4239db7147eSSherry Moore (void) fprintf(stderr, gettext("%s: Failed to stop %s.\n"), 4249db7147eSSherry Moore cmdname, FMRI_GDM); 4259db7147eSSherry Moore return (-1); 4269db7147eSSherry Moore } 4279db7147eSSherry Moore 4289db7147eSSherry Moore return (0); 4299db7147eSSherry Moore } 4309db7147eSSherry Moore 4319db7147eSSherry Moore 4327c478bd9Sstevel@tonic-gate static void 4337c478bd9Sstevel@tonic-gate stop_restarters() 4347c478bd9Sstevel@tonic-gate { 4357c478bd9Sstevel@tonic-gate stop_startd(); 4367c478bd9Sstevel@tonic-gate stop_delegates(); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate static void 4407c478bd9Sstevel@tonic-gate continue_restarters() 4417c478bd9Sstevel@tonic-gate { 4427c478bd9Sstevel@tonic-gate continue_startd(); 4437c478bd9Sstevel@tonic-gate continue_delegates(); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate /* 4477c478bd9Sstevel@tonic-gate * Copy an array of strings into buf, separated by spaces. Returns 0 on 4487c478bd9Sstevel@tonic-gate * success. 4497c478bd9Sstevel@tonic-gate */ 4507c478bd9Sstevel@tonic-gate static int 4517c478bd9Sstevel@tonic-gate gather_args(char **args, char *buf, size_t buf_sz) 4527c478bd9Sstevel@tonic-gate { 4537c478bd9Sstevel@tonic-gate if (strlcpy(buf, *args, buf_sz) >= buf_sz) 4547c478bd9Sstevel@tonic-gate return (-1); 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate for (++args; *args != NULL; ++args) { 4577c478bd9Sstevel@tonic-gate if (strlcat(buf, " ", buf_sz) >= buf_sz) 4587c478bd9Sstevel@tonic-gate return (-1); 4597c478bd9Sstevel@tonic-gate if (strlcat(buf, *args, buf_sz) >= buf_sz) 4607c478bd9Sstevel@tonic-gate return (-1); 4617c478bd9Sstevel@tonic-gate } 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate return (0); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate 46626f665e8Sdstaff /* 46726f665e8Sdstaff * Halt every zone on the system. We are committed to doing a shutdown 46826f665e8Sdstaff * even if something goes wrong here. If something goes wrong, we just 46926f665e8Sdstaff * continue with the shutdown. Return non-zero if we need to wait for zones to 47026f665e8Sdstaff * halt later on. 47126f665e8Sdstaff */ 47226f665e8Sdstaff static int 4733f2f09c1Sdp halt_zones() 47426f665e8Sdstaff { 47526f665e8Sdstaff pid_t pid; 47626f665e8Sdstaff zoneid_t *zones; 4773f2f09c1Sdp size_t nz = 0, old_nz; 47826f665e8Sdstaff int i; 47926f665e8Sdstaff char zname[ZONENAME_MAX]; 48026f665e8Sdstaff 48126f665e8Sdstaff /* 48226f665e8Sdstaff * Get a list of zones. If the number of zones changes in between the 48326f665e8Sdstaff * two zone_list calls, try again. 48426f665e8Sdstaff */ 48526f665e8Sdstaff 48626f665e8Sdstaff for (;;) { 48726f665e8Sdstaff (void) zone_list(NULL, &nz); 48826f665e8Sdstaff if (nz == 1) 48926f665e8Sdstaff return (0); 49026f665e8Sdstaff old_nz = nz; 49126f665e8Sdstaff zones = calloc(sizeof (zoneid_t), nz); 49226f665e8Sdstaff if (zones == NULL) { 49326f665e8Sdstaff (void) fprintf(stderr, 49426f665e8Sdstaff gettext("%s: Could not halt zones" 4953f2f09c1Sdp " (out of memory).\n"), cmdname); 49626f665e8Sdstaff return (0); 49726f665e8Sdstaff } 49826f665e8Sdstaff 49926f665e8Sdstaff (void) zone_list(zones, &nz); 50026f665e8Sdstaff if (old_nz == nz) 50126f665e8Sdstaff break; 50226f665e8Sdstaff free(zones); 50326f665e8Sdstaff } 50426f665e8Sdstaff 50526f665e8Sdstaff if (nz == 2) { 5063f2f09c1Sdp (void) fprintf(stderr, gettext("%s: Halting 1 zone.\n"), 5073f2f09c1Sdp cmdname); 50826f665e8Sdstaff } else { 5093f2f09c1Sdp (void) fprintf(stderr, gettext("%s: Halting %i zones.\n"), 5103f2f09c1Sdp cmdname, nz - 1); 51126f665e8Sdstaff } 51226f665e8Sdstaff 51326f665e8Sdstaff for (i = 0; i < nz; i++) { 51426f665e8Sdstaff if (zones[i] == GLOBAL_ZONEID) 51526f665e8Sdstaff continue; 51626f665e8Sdstaff if (getzonenamebyid(zones[i], zname, sizeof (zname)) < 0) { 51726f665e8Sdstaff /* 51826f665e8Sdstaff * getzonenamebyid should only fail if we raced with 51926f665e8Sdstaff * another process trying to shut down the zone. 52026f665e8Sdstaff * We assume this happened and ignore the error. 52126f665e8Sdstaff */ 52226f665e8Sdstaff if (errno != EINVAL) { 52326f665e8Sdstaff (void) fprintf(stderr, 52426f665e8Sdstaff gettext("%s: Unexpected error while " 52526f665e8Sdstaff "looking up zone %ul: %s.\n"), 5263f2f09c1Sdp cmdname, zones[i], strerror(errno)); 52726f665e8Sdstaff } 52826f665e8Sdstaff 52926f665e8Sdstaff continue; 53026f665e8Sdstaff } 53126f665e8Sdstaff pid = fork(); 53226f665e8Sdstaff if (pid < 0) { 53326f665e8Sdstaff (void) fprintf(stderr, 53426f665e8Sdstaff gettext("%s: Zone \"%s\" could not be" 53526f665e8Sdstaff " halted (could not fork(): %s).\n"), 5363f2f09c1Sdp cmdname, zname, strerror(errno)); 53726f665e8Sdstaff continue; 53826f665e8Sdstaff } 53926f665e8Sdstaff if (pid == 0) { 54026f665e8Sdstaff (void) execl(ZONEADM_PROG, ZONEADM_PROG, 54126f665e8Sdstaff "-z", zname, "halt", NULL); 54226f665e8Sdstaff (void) fprintf(stderr, 54326f665e8Sdstaff gettext("%s: Zone \"%s\" could not be halted" 54426f665e8Sdstaff " (cannot exec(" ZONEADM_PROG "): %s).\n"), 5453f2f09c1Sdp cmdname, zname, strerror(errno)); 54626f665e8Sdstaff exit(0); 54726f665e8Sdstaff } 54826f665e8Sdstaff } 54926f665e8Sdstaff 55026f665e8Sdstaff return (1); 55126f665e8Sdstaff } 55226f665e8Sdstaff 55326f665e8Sdstaff /* 55426f665e8Sdstaff * This function tries to wait for all non-global zones to go away. 55526f665e8Sdstaff * It will timeout if no progress is made for 5 seconds, or a total of 55626f665e8Sdstaff * 30 seconds elapses. 55726f665e8Sdstaff */ 55826f665e8Sdstaff 55926f665e8Sdstaff static void 5603f2f09c1Sdp check_zones_haltedness() 56126f665e8Sdstaff { 56226f665e8Sdstaff int t = 0, t_prog = 0; 56326f665e8Sdstaff size_t nz = 0, last_nz; 56426f665e8Sdstaff 56526f665e8Sdstaff do { 56626f665e8Sdstaff last_nz = nz; 56726f665e8Sdstaff (void) zone_list(NULL, &nz); 56826f665e8Sdstaff if (nz == 1) 56926f665e8Sdstaff return; 57026f665e8Sdstaff 57126f665e8Sdstaff (void) sleep(1); 57226f665e8Sdstaff 57326f665e8Sdstaff if (last_nz > nz) 57426f665e8Sdstaff t_prog = 0; 57526f665e8Sdstaff 57626f665e8Sdstaff t++; 57726f665e8Sdstaff t_prog++; 57826f665e8Sdstaff 57926f665e8Sdstaff if (t == 10) { 58026f665e8Sdstaff if (nz == 2) { 58126f665e8Sdstaff (void) fprintf(stderr, 58226f665e8Sdstaff gettext("%s: Still waiting for 1 zone to " 58326f665e8Sdstaff "halt. Will wait up to 20 seconds.\n"), 5843f2f09c1Sdp cmdname); 58526f665e8Sdstaff } else { 58626f665e8Sdstaff (void) fprintf(stderr, 58726f665e8Sdstaff gettext("%s: Still waiting for %i zones " 58826f665e8Sdstaff "to halt. Will wait up to 20 seconds.\n"), 5893f2f09c1Sdp cmdname, nz - 1); 59026f665e8Sdstaff } 59126f665e8Sdstaff } 59226f665e8Sdstaff 59326f665e8Sdstaff } while ((t < 30) && (t_prog < 5)); 59426f665e8Sdstaff } 59526f665e8Sdstaff 59619397407SSherry Moore 59719397407SSherry Moore /* 59819397407SSherry Moore * Validate that this is a root disk or dataset 59919397407SSherry Moore * Returns 0 if it is a root disk or dataset; 60019397407SSherry Moore * returns 1 if it is a disk argument or dataset, but not valid or not root; 60119397407SSherry Moore * returns -1 if it is not a valid argument or a disk argument. 60219397407SSherry Moore */ 60319397407SSherry Moore static int 60419397407SSherry Moore validate_disk(char *arg, char *mountpoint) 60519397407SSherry Moore { 60619397407SSherry Moore static char root_dev_path[] = "/dev/dsk"; 60719397407SSherry Moore char kernpath[MAXPATHLEN]; 60819397407SSherry Moore struct stat64 statbuf; 60919397407SSherry Moore int rc = 0; 61019397407SSherry Moore 61119397407SSherry Moore if (strlen(arg) > MAXPATHLEN) { 61219397407SSherry Moore (void) fprintf(stderr, 613753a6d45SSherry Moore gettext("%s: Argument is too long\n"), cmdname); 61419397407SSherry Moore return (-1); 61519397407SSherry Moore } 61619397407SSherry Moore 61719397407SSherry Moore bcopy(FASTBOOT_MOUNTPOINT, mountpoint, sizeof (FASTBOOT_MOUNTPOINT)); 61819397407SSherry Moore 619753a6d45SSherry Moore if (strstr(arg, mountpoint) == NULL) { 620753a6d45SSherry Moore /* 621753a6d45SSherry Moore * Do a force umount just in case some other filesystem has 622753a6d45SSherry Moore * been mounted there. 623753a6d45SSherry Moore */ 624753a6d45SSherry Moore (void) umount2(mountpoint, MS_FORCE); 625753a6d45SSherry Moore } 62619397407SSherry Moore 62719397407SSherry Moore /* Create the directory if it doesn't already exist */ 628753a6d45SSherry Moore if (lstat64(mountpoint, &statbuf) != 0) { 62919397407SSherry Moore if (mkdirp(mountpoint, 0755) != 0) { 63019397407SSherry Moore (void) fprintf(stderr, 631753a6d45SSherry Moore gettext("Failed to create mountpoint %s\n"), 63219397407SSherry Moore mountpoint); 63319397407SSherry Moore return (-1); 63419397407SSherry Moore } 63519397407SSherry Moore } 63619397407SSherry Moore 63719397407SSherry Moore if (strncmp(arg, root_dev_path, strlen(root_dev_path)) == 0) { 63819397407SSherry Moore /* ufs root disk argument */ 63919397407SSherry Moore rc = validate_ufs_disk(arg, mountpoint); 64019397407SSherry Moore } else { 64119397407SSherry Moore /* zfs root pool argument */ 64219397407SSherry Moore rc = validate_zfs_pool(arg, mountpoint); 64319397407SSherry Moore } 64419397407SSherry Moore 64519397407SSherry Moore if (rc != 0) 64619397407SSherry Moore return (rc); 64719397407SSherry Moore 64819397407SSherry Moore (void) snprintf(kernpath, MAXPATHLEN, "%s/platform/i86pc/kernel/unix", 64919397407SSherry Moore mountpoint); 65019397407SSherry Moore 65119397407SSherry Moore if (stat64(kernpath, &statbuf) != 0) { 65219397407SSherry Moore (void) fprintf(stderr, 65319397407SSherry Moore gettext("%s: %s is not a root disk or dataset\n"), 65419397407SSherry Moore cmdname, arg); 65519397407SSherry Moore return (1); 65619397407SSherry Moore } 65719397407SSherry Moore 65819397407SSherry Moore return (0); 65919397407SSherry Moore } 66019397407SSherry Moore 66119397407SSherry Moore 66219397407SSherry Moore static int 66319397407SSherry Moore validate_ufs_disk(char *arg, char *mountpoint) 66419397407SSherry Moore { 6658e07a41fSKonstantin Ananyev struct ufs_args ufs_args = { 0 }; 6668e07a41fSKonstantin Ananyev char mntopts[MNT_LINE_MAX] = MNTOPT_LARGEFILES; 66719397407SSherry Moore 66819397407SSherry Moore /* perform the mount */ 6698e07a41fSKonstantin Ananyev ufs_args.flags = UFSMNT_LARGEFILES; 67019397407SSherry Moore if (mount(arg, mountpoint, MS_DATA|MS_OPTIONSTR, 6718e07a41fSKonstantin Ananyev MNTTYPE_UFS, &ufs_args, sizeof (ufs_args), 6728e07a41fSKonstantin Ananyev mntopts, sizeof (mntopts)) != 0) { 67319397407SSherry Moore perror(cmdname); 67419397407SSherry Moore (void) fprintf(stderr, 675753a6d45SSherry Moore gettext("%s: Failed to mount %s\n"), cmdname, arg); 67619397407SSherry Moore return (-1); 67719397407SSherry Moore } 67819397407SSherry Moore 67919397407SSherry Moore return (0); 68019397407SSherry Moore } 68119397407SSherry Moore 68219397407SSherry Moore static int 68319397407SSherry Moore validate_zfs_pool(char *arg, char *mountpoint) 68419397407SSherry Moore { 68519397407SSherry Moore zfs_handle_t *zhp = NULL; 68619397407SSherry Moore char mntopts[MNT_LINE_MAX] = { '\0' }; 68719397407SSherry Moore int rc = 0; 68819397407SSherry Moore 68919397407SSherry Moore if ((g_zfs = libzfs_init()) == NULL) { 690753a6d45SSherry Moore (void) fprintf(stderr, gettext("Internal error: failed to " 69119397407SSherry Moore "initialize ZFS library\n")); 69219397407SSherry Moore return (-1); 69319397407SSherry Moore } 69419397407SSherry Moore 69519397407SSherry Moore /* Try to open the dataset */ 69619397407SSherry Moore if ((zhp = zfs_open(g_zfs, arg, 69719397407SSherry Moore ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL) 69819397407SSherry Moore return (-1); 69919397407SSherry Moore 70019397407SSherry Moore /* perform the mount */ 701753a6d45SSherry Moore if (mount(zfs_get_name(zhp), mountpoint, MS_DATA|MS_OPTIONSTR|MS_RDONLY, 70219397407SSherry Moore MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) { 70319397407SSherry Moore perror(cmdname); 70419397407SSherry Moore (void) fprintf(stderr, 705753a6d45SSherry Moore gettext("%s: Failed to mount %s\n"), cmdname, arg); 70619397407SSherry Moore rc = -1; 70719397407SSherry Moore } 70819397407SSherry Moore 70919397407SSherry Moore validate_zfs_err_out: 71019397407SSherry Moore if (zhp != NULL) 71119397407SSherry Moore zfs_close(zhp); 71219397407SSherry Moore 71319397407SSherry Moore libzfs_fini(g_zfs); 71419397407SSherry Moore return (rc); 71519397407SSherry Moore } 71619397407SSherry Moore 71719397407SSherry Moore /* 71819397407SSherry Moore * Return 0 if not zfs, or is zfs and have successfully constructed the 71919397407SSherry Moore * boot argument; returns non-zero otherwise. 72019397407SSherry Moore * At successful completion fpth contains pointer where mount point ends. 72119397407SSherry Moore * NOTE: arg is supposed to be the resolved path 72219397407SSherry Moore */ 72319397407SSherry Moore static int 72419397407SSherry Moore get_zfs_bootfs_arg(const char *arg, const char ** fpth, int *is_zfs, 7259adfa60dSMatthew Ahrens char *bootfs_arg) 72619397407SSherry Moore { 72719397407SSherry Moore zfs_handle_t *zhp = NULL; 72819397407SSherry Moore zpool_handle_t *zpoolp = NULL; 72919397407SSherry Moore FILE *mtabp = NULL; 73019397407SSherry Moore struct mnttab mnt; 73119397407SSherry Moore char *poolname = NULL; 732753a6d45SSherry Moore char physpath[MAXPATHLEN]; 7339adfa60dSMatthew Ahrens char mntsp[ZFS_MAX_DATASET_NAME_LEN]; 7349adfa60dSMatthew Ahrens char bootfs[ZFS_MAX_DATASET_NAME_LEN]; 73519397407SSherry Moore int rc = 0; 73619397407SSherry Moore size_t mntlen = 0; 73719397407SSherry Moore size_t msz; 738753a6d45SSherry Moore static char fmt[] = "-B zfs-bootfs=%s,bootpath=\"%s\""; 73919397407SSherry Moore 74019397407SSherry Moore *fpth = arg; 74119397407SSherry Moore *is_zfs = 0; 74219397407SSherry Moore 74319397407SSherry Moore bzero(physpath, sizeof (physpath)); 74419397407SSherry Moore bzero(bootfs, sizeof (bootfs)); 74519397407SSherry Moore 74619397407SSherry Moore if ((mtabp = fopen(MNTTAB, "r")) == NULL) { 74719397407SSherry Moore return (-1); 74819397407SSherry Moore } 74919397407SSherry Moore 75019397407SSherry Moore while (getmntent(mtabp, &mnt) == 0) { 75119397407SSherry Moore if (strstr(arg, mnt.mnt_mountp) == arg && 75219397407SSherry Moore (msz = strlen(mnt.mnt_mountp)) > mntlen) { 75319397407SSherry Moore mntlen = msz; 75419397407SSherry Moore *is_zfs = strcmp(MNTTYPE_ZFS, mnt.mnt_fstype) == 0; 75519397407SSherry Moore (void) strlcpy(mntsp, mnt.mnt_special, sizeof (mntsp)); 75619397407SSherry Moore } 75719397407SSherry Moore } 75819397407SSherry Moore 75919397407SSherry Moore (void) fclose(mtabp); 76019397407SSherry Moore 76119397407SSherry Moore if (mntlen > 1) 76219397407SSherry Moore *fpth += mntlen; 76319397407SSherry Moore 76419397407SSherry Moore if (!*is_zfs) 76519397407SSherry Moore return (0); 76619397407SSherry Moore 76719397407SSherry Moore if ((g_zfs = libzfs_init()) == NULL) 76819397407SSherry Moore return (-1); 76919397407SSherry Moore 77019397407SSherry Moore /* Try to open the dataset */ 77119397407SSherry Moore if ((zhp = zfs_open(g_zfs, mntsp, 77219397407SSherry Moore ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL) { 773753a6d45SSherry Moore (void) fprintf(stderr, gettext("Cannot open %s\n"), mntsp); 77419397407SSherry Moore rc = -1; 77519397407SSherry Moore goto validate_zfs_err_out; 77619397407SSherry Moore } 77719397407SSherry Moore 77819397407SSherry Moore (void) strlcpy(bootfs, mntsp, sizeof (bootfs)); 77919397407SSherry Moore 78019397407SSherry Moore if ((poolname = strtok(mntsp, "/")) == NULL) { 78119397407SSherry Moore rc = -1; 78219397407SSherry Moore goto validate_zfs_err_out; 78319397407SSherry Moore } 78419397407SSherry Moore 78519397407SSherry Moore if ((zpoolp = zpool_open(g_zfs, poolname)) == NULL) { 786753a6d45SSherry Moore (void) fprintf(stderr, gettext("Cannot open %s\n"), poolname); 78719397407SSherry Moore rc = -1; 78819397407SSherry Moore goto validate_zfs_err_out; 78919397407SSherry Moore } 79019397407SSherry Moore 791753a6d45SSherry Moore if (zpool_get_physpath(zpoolp, physpath, sizeof (physpath)) != 0) { 792753a6d45SSherry Moore (void) fprintf(stderr, gettext("Cannot find phys_path\n")); 79319397407SSherry Moore rc = -1; 79419397407SSherry Moore goto validate_zfs_err_out; 79519397407SSherry Moore } 79619397407SSherry Moore 797753a6d45SSherry Moore /* 798753a6d45SSherry Moore * For the mirror physpath would contain the list of all 799753a6d45SSherry Moore * bootable devices, pick up the first one. 800753a6d45SSherry Moore */ 801753a6d45SSherry Moore (void) strtok(physpath, " "); 802753a6d45SSherry Moore if (snprintf(bootfs_arg, BOOTARGS_MAX, fmt, bootfs, physpath) >= 803753a6d45SSherry Moore BOOTARGS_MAX) { 804753a6d45SSherry Moore rc = E2BIG; 805753a6d45SSherry Moore (void) fprintf(stderr, 806753a6d45SSherry Moore gettext("Boot arguments are too long\n")); 80719397407SSherry Moore } 80819397407SSherry Moore 80919397407SSherry Moore validate_zfs_err_out: 81019397407SSherry Moore if (zhp != NULL) 81119397407SSherry Moore zfs_close(zhp); 81219397407SSherry Moore 81319397407SSherry Moore if (zpoolp != NULL) 81419397407SSherry Moore zpool_close(zpoolp); 81519397407SSherry Moore 81619397407SSherry Moore libzfs_fini(g_zfs); 81719397407SSherry Moore return (rc); 81819397407SSherry Moore } 81919397407SSherry Moore 82019397407SSherry Moore /* 82119397407SSherry Moore * Validate that the file exists, and is an ELF file. 82219397407SSherry Moore * Returns 0 on success, -1 on failure. 82319397407SSherry Moore */ 82419397407SSherry Moore static int 8255b89e3f7SSherry Moore validate_unix(char *arg, int *mplen, int *is_zfs, char *bootfs_arg) 82619397407SSherry Moore { 82719397407SSherry Moore const char *location; 82819397407SSherry Moore int class, format; 82919397407SSherry Moore unsigned char ident[EI_NIDENT]; 83019397407SSherry Moore char physpath[MAXPATHLEN]; 83119397407SSherry Moore int elffd = -1; 83219397407SSherry Moore size_t sz; 83319397407SSherry Moore 83419397407SSherry Moore if ((sz = resolvepath(arg, physpath, sizeof (physpath) - 1)) == 83519397407SSherry Moore (size_t)-1) { 83619397407SSherry Moore (void) fprintf(stderr, 837753a6d45SSherry Moore gettext("Cannot resolve path for %s: %s\n"), 83819397407SSherry Moore arg, strerror(errno)); 83919397407SSherry Moore return (-1); 84019397407SSherry Moore } 84119397407SSherry Moore (void) strlcpy(arg, physpath, sz + 1); 84219397407SSherry Moore 84319397407SSherry Moore if (strlen(arg) > MAXPATHLEN) { 84419397407SSherry Moore (void) fprintf(stderr, 845753a6d45SSherry Moore gettext("%s: New kernel name is too long\n"), cmdname); 84619397407SSherry Moore return (-1); 84719397407SSherry Moore } 84819397407SSherry Moore 84919397407SSherry Moore if (strncmp(basename(arg), "unix", 4) != 0) { 85019397407SSherry Moore (void) fprintf(stderr, 851753a6d45SSherry Moore gettext("%s: %s: Kernel name must be unix\n"), 85219397407SSherry Moore cmdname, arg); 85319397407SSherry Moore return (-1); 85419397407SSherry Moore } 85519397407SSherry Moore 85619397407SSherry Moore if (get_zfs_bootfs_arg(arg, &location, is_zfs, bootfs_arg) != 0) 85719397407SSherry Moore goto err_out; 85819397407SSherry Moore 85919397407SSherry Moore *mplen = location - arg; 86019397407SSherry Moore 8615b89e3f7SSherry Moore if (strstr(location, "/boot/platform") == location) { 8625b89e3f7SSherry Moore /* 8635b89e3f7SSherry Moore * Rebooting to failsafe. 8645b89e3f7SSherry Moore * Clear bootfs_arg and is_zfs flag. 8655b89e3f7SSherry Moore */ 8665b89e3f7SSherry Moore bootfs_arg[0] = 0; 8675b89e3f7SSherry Moore *is_zfs = 0; 8685b89e3f7SSherry Moore } else if (strstr(location, "/platform") != location) { 86919397407SSherry Moore (void) fprintf(stderr, 8705b89e3f7SSherry Moore gettext("%s: %s: No /platform in file name\n"), 8715b89e3f7SSherry Moore cmdname, arg); 8725b89e3f7SSherry Moore goto err_out; 87319397407SSherry Moore } 87419397407SSherry Moore 87519397407SSherry Moore if ((elffd = open64(arg, O_RDONLY)) < 0 || 87619397407SSherry Moore (pread64(elffd, ident, EI_NIDENT, 0) != EI_NIDENT)) { 87719397407SSherry Moore (void) fprintf(stderr, "%s: %s: %s\n", 87819397407SSherry Moore cmdname, arg, strerror(errno)); 87919397407SSherry Moore goto err_out; 88019397407SSherry Moore } 88119397407SSherry Moore 88219397407SSherry Moore class = ident[EI_CLASS]; 88319397407SSherry Moore 88419397407SSherry Moore if ((class != ELFCLASS32 && class != ELFCLASS64) || 885753a6d45SSherry Moore memcmp(&ident[EI_MAG0], ELFMAG, 4) != 0) { 88619397407SSherry Moore (void) fprintf(stderr, 887753a6d45SSherry Moore gettext("%s: %s: Not a valid ELF file\n"), cmdname, arg); 88819397407SSherry Moore goto err_out; 88919397407SSherry Moore } 89019397407SSherry Moore 89119397407SSherry Moore format = ident[EI_DATA]; 89219397407SSherry Moore 89319397407SSherry Moore if (format != CUR_ELFDATA) { 894753a6d45SSherry Moore (void) fprintf(stderr, gettext("%s: %s: Invalid data format\n"), 89519397407SSherry Moore cmdname, arg); 89619397407SSherry Moore goto err_out; 89719397407SSherry Moore } 89819397407SSherry Moore 89919397407SSherry Moore return (0); 90019397407SSherry Moore 90119397407SSherry Moore err_out: 90219397407SSherry Moore if (elffd >= 0) { 90319397407SSherry Moore (void) close(elffd); 90419397407SSherry Moore elffd = -1; 90519397407SSherry Moore } 90619397407SSherry Moore return (-1); 90719397407SSherry Moore } 90819397407SSherry Moore 9094e1f1c13SKonstantin Ananyev static int 9104e1f1c13SKonstantin Ananyev halt_exec(const char *path, ...) 9114e1f1c13SKonstantin Ananyev { 9124e1f1c13SKonstantin Ananyev pid_t pid; 9134e1f1c13SKonstantin Ananyev int i; 9144e1f1c13SKonstantin Ananyev int st; 9154e1f1c13SKonstantin Ananyev const char *arg; 9164e1f1c13SKonstantin Ananyev va_list vp; 9174e1f1c13SKonstantin Ananyev const char *argv[256]; 9184e1f1c13SKonstantin Ananyev 9194e1f1c13SKonstantin Ananyev if ((pid = fork()) == -1) { 9204e1f1c13SKonstantin Ananyev return (errno); 9214e1f1c13SKonstantin Ananyev } else if (pid == 0) { 9224e1f1c13SKonstantin Ananyev (void) fclose(stdout); 9234e1f1c13SKonstantin Ananyev (void) fclose(stderr); 9244e1f1c13SKonstantin Ananyev 9254e1f1c13SKonstantin Ananyev argv[0] = path; 9264e1f1c13SKonstantin Ananyev i = 1; 9274e1f1c13SKonstantin Ananyev 9284e1f1c13SKonstantin Ananyev va_start(vp, path); 9294e1f1c13SKonstantin Ananyev 9304e1f1c13SKonstantin Ananyev do { 9314e1f1c13SKonstantin Ananyev arg = va_arg(vp, const char *); 9324e1f1c13SKonstantin Ananyev argv[i] = arg; 9334e1f1c13SKonstantin Ananyev } while (arg != NULL && 9344e1f1c13SKonstantin Ananyev ++i != sizeof (argv) / sizeof (argv[0])); 9354e1f1c13SKonstantin Ananyev 9364e1f1c13SKonstantin Ananyev va_end(vp); 9374e1f1c13SKonstantin Ananyev 9384e1f1c13SKonstantin Ananyev (void) execve(path, (char * const *)argv, NULL); 939753a6d45SSherry Moore (void) fprintf(stderr, gettext("Cannot execute %s: %s\n"), 9404e1f1c13SKonstantin Ananyev path, strerror(errno)); 9414e1f1c13SKonstantin Ananyev exit(-1); 9424e1f1c13SKonstantin Ananyev } else { 9434e1f1c13SKonstantin Ananyev if (waitpid(pid, &st, 0) == pid && 9444e1f1c13SKonstantin Ananyev !WIFSIGNALED(st) && WIFEXITED(st)) 9454e1f1c13SKonstantin Ananyev st = WEXITSTATUS(st); 9464e1f1c13SKonstantin Ananyev else 9474e1f1c13SKonstantin Ananyev st = -1; 9484e1f1c13SKonstantin Ananyev } 9494e1f1c13SKonstantin Ananyev return (st); 9504e1f1c13SKonstantin Ananyev } 9514e1f1c13SKonstantin Ananyev 9524e1f1c13SKonstantin Ananyev /* 95380cb75f4SWilliam Kucharski * Mount the specified BE. 95480cb75f4SWilliam Kucharski * 95580cb75f4SWilliam Kucharski * Upon success returns zero and copies bename string to mountpoint[] 9564e1f1c13SKonstantin Ananyev */ 95719397407SSherry Moore static int 95819397407SSherry Moore fastboot_bename(const char *bename, char *mountpoint, size_t mpsz) 95919397407SSherry Moore { 96019397407SSherry Moore int rc; 96119397407SSherry Moore 96280cb75f4SWilliam Kucharski /* 96380cb75f4SWilliam Kucharski * Attempt to unmount the BE first in case it's already mounted 96480cb75f4SWilliam Kucharski * elsewhere. 96580cb75f4SWilliam Kucharski */ 96680cb75f4SWilliam Kucharski (void) halt_exec(BEADM_PROG, "umount", bename, NULL); 96719397407SSherry Moore 96880cb75f4SWilliam Kucharski if ((rc = halt_exec(BEADM_PROG, "mount", bename, FASTBOOT_MOUNTPOINT, 9694e1f1c13SKonstantin Ananyev NULL)) != 0) 97080cb75f4SWilliam Kucharski (void) fprintf(stderr, 97180cb75f4SWilliam Kucharski gettext("%s: Unable to mount BE \"%s\" at %s\n"), 97280cb75f4SWilliam Kucharski cmdname, bename, FASTBOOT_MOUNTPOINT); 97319397407SSherry Moore else 97419397407SSherry Moore (void) strlcpy(mountpoint, FASTBOOT_MOUNTPOINT, mpsz); 97519397407SSherry Moore 97619397407SSherry Moore return (rc); 97719397407SSherry Moore } 97819397407SSherry Moore 97919397407SSherry Moore /* 98019397407SSherry Moore * Returns 0 on successful parsing of the arguments; 981753a6d45SSherry Moore * returns EINVAL on parsing failures that should abort the reboot attempt; 982753a6d45SSherry Moore * returns other error code to fall back to regular reboot. 98319397407SSherry Moore */ 98419397407SSherry Moore static int 985753a6d45SSherry Moore parse_fastboot_args(char *bootargs_buf, size_t buf_size, 9865b89e3f7SSherry Moore int *is_dryrun, const char *bename) 98719397407SSherry Moore { 98819397407SSherry Moore char mountpoint[MAXPATHLEN]; 98919397407SSherry Moore char bootargs_saved[BOOTARGS_MAX]; 99019397407SSherry Moore char bootargs_scratch[BOOTARGS_MAX]; 99119397407SSherry Moore char bootfs_arg[BOOTARGS_MAX]; 99219397407SSherry Moore char unixfile[BOOTARGS_MAX]; 99319397407SSherry Moore char *head, *newarg; 99419397407SSherry Moore int buflen; /* length of the bootargs_buf */ 99519397407SSherry Moore int mplen; /* length of the mount point */ 99619397407SSherry Moore int rootlen = 0; /* length of the root argument */ 99719397407SSherry Moore int unixlen = 0; /* length of the unix argument */ 99819397407SSherry Moore int off = 0; /* offset into the new boot argument */ 99919397407SSherry Moore int is_zfs = 0; 100019397407SSherry Moore int rc = 0; 100119397407SSherry Moore 100219397407SSherry Moore bzero(mountpoint, sizeof (mountpoint)); 100319397407SSherry Moore 100419397407SSherry Moore /* 100519397407SSherry Moore * If argc is not 0, buflen is length of the argument being passed in; 100619397407SSherry Moore * else it is 0 as bootargs_buf has been initialized to all 0's. 100719397407SSherry Moore */ 100819397407SSherry Moore buflen = strlen(bootargs_buf); 100919397407SSherry Moore 101019397407SSherry Moore /* Save a copy of the original argument */ 101119397407SSherry Moore bcopy(bootargs_buf, bootargs_saved, buflen); 101219397407SSherry Moore bzero(&bootargs_saved[buflen], sizeof (bootargs_saved) - buflen); 101319397407SSherry Moore 101419397407SSherry Moore /* Save another copy to be used by strtok */ 101519397407SSherry Moore bcopy(bootargs_buf, bootargs_scratch, buflen); 101619397407SSherry Moore bzero(&bootargs_scratch[buflen], sizeof (bootargs_scratch) - buflen); 101719397407SSherry Moore head = &bootargs_scratch[0]; 101819397407SSherry Moore 101919397407SSherry Moore /* Get the first argument */ 102019397407SSherry Moore newarg = strtok(bootargs_scratch, " "); 102119397407SSherry Moore 102219397407SSherry Moore /* 102319397407SSherry Moore * If this is a dry run request, verify that the drivers can handle 102419397407SSherry Moore * fast reboot. 102519397407SSherry Moore */ 102619397407SSherry Moore if (newarg && strncasecmp(newarg, "dryrun", strlen("dryrun")) == 0) { 102719397407SSherry Moore *is_dryrun = 1; 102819397407SSherry Moore (void) system("/usr/sbin/devfsadm"); 102919397407SSherry Moore } 103019397407SSherry Moore 103119397407SSherry Moore /* 103219397407SSherry Moore * Always perform a dry run to identify all the drivers that 103319397407SSherry Moore * need to implement devo_reset(). 103419397407SSherry Moore */ 103519397407SSherry Moore if (uadmin(A_SHUTDOWN, AD_FASTREBOOT_DRYRUN, 103619397407SSherry Moore (uintptr_t)bootargs_saved) != 0) { 1037753a6d45SSherry Moore (void) fprintf(stderr, gettext("%s: Not all drivers " 1038753a6d45SSherry Moore "have implemented quiesce(9E)\n" 1039753a6d45SSherry Moore "\tPlease see /var/adm/messages for drivers that haven't\n" 1040753a6d45SSherry Moore "\timplemented quiesce(9E).\n"), cmdname); 104119397407SSherry Moore } else if (*is_dryrun) { 1042753a6d45SSherry Moore (void) fprintf(stderr, gettext("%s: All drivers have " 104319397407SSherry Moore "implemented quiesce(9E)\n"), cmdname); 104419397407SSherry Moore } 104519397407SSherry Moore 1046753a6d45SSherry Moore /* Return if it is a true dry run. */ 104719397407SSherry Moore if (*is_dryrun) 104819397407SSherry Moore return (rc); 104919397407SSherry Moore 10509abc7a57SToomas Soome #if defined(__x86) 10519abc7a57SToomas Soome /* Read boot args from Boot Environment */ 1052753a6d45SSherry Moore if ((bootargs_buf[0] == 0 || isdigit(bootargs_buf[0])) && 1053753a6d45SSherry Moore bename == NULL) { 1054753a6d45SSherry Moore /* 10559abc7a57SToomas Soome * If no boot arguments are given, or a BE entry 10569abc7a57SToomas Soome * number is provided, process the boot arguments from BE. 1057753a6d45SSherry Moore */ 1058753a6d45SSherry Moore int entnum; 1059753a6d45SSherry Moore if (bootargs_buf[0] == 0) 10609abc7a57SToomas Soome entnum = BE_ENTRY_DEFAULT; 1061753a6d45SSherry Moore else { 1062753a6d45SSherry Moore errno = 0; 1063753a6d45SSherry Moore entnum = strtoul(bootargs_buf, NULL, 10); 1064753a6d45SSherry Moore rc = errno; 1065753a6d45SSherry Moore } 1066753a6d45SSherry Moore 10679abc7a57SToomas Soome if (rc == 0 && (rc = be_get_boot_args(&fbarg, entnum)) == 0) { 10689abc7a57SToomas Soome if (strlcpy(bootargs_buf, fbarg, 1069753a6d45SSherry Moore buf_size) >= buf_size) { 10709abc7a57SToomas Soome free(fbarg); 1071753a6d45SSherry Moore bcopy(bootargs_saved, bootargs_buf, buf_size); 1072753a6d45SSherry Moore rc = E2BIG; 1073753a6d45SSherry Moore } 1074753a6d45SSherry Moore } 10759abc7a57SToomas Soome /* Failed to read FB args, fall back to normal reboot */ 1076753a6d45SSherry Moore if (rc != 0) { 1077753a6d45SSherry Moore (void) fprintf(stderr, 10789abc7a57SToomas Soome gettext("%s: Failed to process boot " 10799abc7a57SToomas Soome "arguments from Boot Environment.\n"), cmdname); 1080753a6d45SSherry Moore (void) fprintf(stderr, 1081753a6d45SSherry Moore gettext("%s: Falling back to regular reboot.\n"), 1082753a6d45SSherry Moore cmdname); 1083753a6d45SSherry Moore return (-1); 1084753a6d45SSherry Moore } 1085753a6d45SSherry Moore /* No need to process further */ 10869abc7a57SToomas Soome fbarg_used = fbarg; 1087753a6d45SSherry Moore fbarg_entnum = entnum; 1088753a6d45SSherry Moore return (0); 1089753a6d45SSherry Moore } 10909abc7a57SToomas Soome #endif /* __x86 */ 1091753a6d45SSherry Moore 1092753a6d45SSherry Moore /* Zero out the boot argument buffer as we will reconstruct it */ 1093753a6d45SSherry Moore bzero(bootargs_buf, buf_size); 1094753a6d45SSherry Moore bzero(bootfs_arg, sizeof (bootfs_arg)); 1095753a6d45SSherry Moore bzero(unixfile, sizeof (unixfile)); 1096753a6d45SSherry Moore 109719397407SSherry Moore if (bename && (rc = fastboot_bename(bename, mountpoint, 109819397407SSherry Moore sizeof (mountpoint))) != 0) 1099753a6d45SSherry Moore return (EINVAL); 1100753a6d45SSherry Moore 110119397407SSherry Moore 110219397407SSherry Moore /* 110319397407SSherry Moore * If BE is not specified, look for disk argument to construct 110419397407SSherry Moore * mountpoint; if BE has been specified, mountpoint has already been 110519397407SSherry Moore * constructed. 110619397407SSherry Moore */ 110719397407SSherry Moore if (newarg && newarg[0] != '-' && !bename) { 110819397407SSherry Moore int tmprc; 110919397407SSherry Moore 111019397407SSherry Moore if ((tmprc = validate_disk(newarg, mountpoint)) == 0) { 111119397407SSherry Moore /* 111219397407SSherry Moore * The first argument is a valid root argument. 111319397407SSherry Moore * Get the next argument. 111419397407SSherry Moore */ 111519397407SSherry Moore newarg = strtok(NULL, " "); 111619397407SSherry Moore rootlen = (newarg) ? (newarg - head) : buflen; 111719397407SSherry Moore (void) strlcpy(fastboot_mounted, mountpoint, 111819397407SSherry Moore sizeof (fastboot_mounted)); 111919397407SSherry Moore 112019397407SSherry Moore } else if (tmprc == -1) { 112119397407SSherry Moore /* 112219397407SSherry Moore * Not a disk argument. Use / as default root. 112319397407SSherry Moore */ 112419397407SSherry Moore bcopy("/", mountpoint, 1); 112519397407SSherry Moore bzero(&mountpoint[1], sizeof (mountpoint) - 1); 112619397407SSherry Moore } else { 112719397407SSherry Moore /* 112819397407SSherry Moore * Disk argument, but not valid or not root. 112919397407SSherry Moore * Return failure. 113019397407SSherry Moore */ 113119397407SSherry Moore return (EINVAL); 113219397407SSherry Moore } 113319397407SSherry Moore } 113419397407SSherry Moore 113519397407SSherry Moore /* 113619397407SSherry Moore * Make mountpoint the first part of unixfile. 113719397407SSherry Moore * If there is not disk argument, and BE has not been specified, 113819397407SSherry Moore * mountpoint could be empty. 113919397407SSherry Moore */ 114019397407SSherry Moore mplen = strlen(mountpoint); 114119397407SSherry Moore bcopy(mountpoint, unixfile, mplen); 114219397407SSherry Moore 114319397407SSherry Moore /* 114419397407SSherry Moore * Look for unix argument 114519397407SSherry Moore */ 114619397407SSherry Moore if (newarg && newarg[0] != '-') { 114719397407SSherry Moore bcopy(newarg, &unixfile[mplen], strlen(newarg)); 114819397407SSherry Moore newarg = strtok(NULL, " "); 114919397407SSherry Moore rootlen = (newarg) ? (newarg - head) : buflen; 115019397407SSherry Moore } else if (mplen != 0) { 115119397407SSherry Moore /* 115219397407SSherry Moore * No unix argument, but mountpoint is not empty, use 115319397407SSherry Moore * /platform/i86pc/$ISADIR/kernel/unix as default. 115419397407SSherry Moore */ 115519397407SSherry Moore char isa[20]; 115619397407SSherry Moore 115719397407SSherry Moore if (sysinfo(SI_ARCHITECTURE_64, isa, sizeof (isa)) != -1) 115819397407SSherry Moore (void) snprintf(&unixfile[mplen], 115919397407SSherry Moore sizeof (unixfile) - mplen, 116019397407SSherry Moore "/platform/i86pc/kernel/%s/unix", isa); 116119397407SSherry Moore else if (sysinfo(SI_ARCHITECTURE_32, isa, sizeof (isa)) != -1) { 116219397407SSherry Moore (void) snprintf(&unixfile[mplen], 116319397407SSherry Moore sizeof (unixfile) - mplen, 116419397407SSherry Moore "/platform/i86pc/kernel/unix"); 116519397407SSherry Moore } else { 116619397407SSherry Moore (void) fprintf(stderr, 1167753a6d45SSherry Moore gettext("%s: Unknown architecture"), cmdname); 116819397407SSherry Moore return (EINVAL); 116919397407SSherry Moore } 117019397407SSherry Moore } 117119397407SSherry Moore 117219397407SSherry Moore /* 117319397407SSherry Moore * We now have the complete unix argument. Verify that it exists and 117419397407SSherry Moore * is an ELF file. Split the argument up into mountpoint and unix 117519397407SSherry Moore * portions again. This is necessary to handle cases where mountpoint 117619397407SSherry Moore * is specified on the command line as part of the unix argument, 117719397407SSherry Moore * such as this: 117819397407SSherry Moore * # reboot -f /.alt/platform/i86pc/kernel/amd64/unix 117919397407SSherry Moore */ 118019397407SSherry Moore unixlen = strlen(unixfile); 118119397407SSherry Moore if (unixlen > 0) { 118219397407SSherry Moore if (validate_unix(unixfile, &mplen, &is_zfs, 11835b89e3f7SSherry Moore bootfs_arg) != 0) { 118419397407SSherry Moore /* Not a valid unix file */ 118519397407SSherry Moore return (EINVAL); 118619397407SSherry Moore } else { 11876bc8bc6aSSherry Moore int space = 0; 118819397407SSherry Moore /* 118919397407SSherry Moore * Construct boot argument. 119019397407SSherry Moore */ 119119397407SSherry Moore unixlen = strlen(unixfile); 11926bc8bc6aSSherry Moore 11936bc8bc6aSSherry Moore /* 11946bc8bc6aSSherry Moore * mdep cannot start with space because bootadm 11956bc8bc6aSSherry Moore * creates bogus menu entries if it does. 11966bc8bc6aSSherry Moore */ 11976bc8bc6aSSherry Moore if (mplen > 0) { 11986bc8bc6aSSherry Moore bcopy(unixfile, bootargs_buf, mplen); 11996bc8bc6aSSherry Moore (void) strcat(bootargs_buf, " "); 12006bc8bc6aSSherry Moore space = 1; 12016bc8bc6aSSherry Moore } 12026bc8bc6aSSherry Moore bcopy(&unixfile[mplen], &bootargs_buf[mplen + space], 120319397407SSherry Moore unixlen - mplen); 120419397407SSherry Moore (void) strcat(bootargs_buf, " "); 12056bc8bc6aSSherry Moore off += unixlen + space + 1; 120619397407SSherry Moore } 120719397407SSherry Moore } else { 120819397407SSherry Moore /* Check to see if root is zfs */ 120919397407SSherry Moore const char *dp; 121019397407SSherry Moore (void) get_zfs_bootfs_arg("/", &dp, &is_zfs, bootfs_arg); 121119397407SSherry Moore } 121219397407SSherry Moore 121319397407SSherry Moore if (is_zfs && (buflen != 0 || bename != NULL)) { 12149e573dccSToomas Soome /* do not copy existing zfs boot args */ 12159e573dccSToomas Soome if (strstr(&bootargs_saved[rootlen], "-B") == NULL || 12169e573dccSToomas Soome strstr(&bootargs_saved[rootlen], "zfs-bootfs=") == NULL || 12179e573dccSToomas Soome (strstr(&bootargs_saved[rootlen], "bootpath=") == NULL && 12189e573dccSToomas Soome strstr(&bootargs_saved[rootlen], "diskdevid=") == NULL)) 12199e573dccSToomas Soome /* LINTED E_SEC_SPRINTF_UNBOUNDED_COPY */ 12209e573dccSToomas Soome off += sprintf(bootargs_buf + off, "%s ", bootfs_arg); 122119397407SSherry Moore } 122219397407SSherry Moore 122319397407SSherry Moore /* 122419397407SSherry Moore * Copy the rest of the arguments 122519397407SSherry Moore */ 122619397407SSherry Moore bcopy(&bootargs_saved[rootlen], &bootargs_buf[off], buflen - rootlen); 122719397407SSherry Moore 122819397407SSherry Moore return (rc); 122919397407SSherry Moore } 123019397407SSherry Moore 1231de0cf919SEnrico Perla - Sun Microsystems #define MAXARGS 5 1232de0cf919SEnrico Perla - Sun Microsystems 1233de0cf919SEnrico Perla - Sun Microsystems static void 1234de0cf919SEnrico Perla - Sun Microsystems do_archives_update(int do_fast_reboot) 1235de0cf919SEnrico Perla - Sun Microsystems { 1236de0cf919SEnrico Perla - Sun Microsystems int r, i = 0; 1237de0cf919SEnrico Perla - Sun Microsystems pid_t pid; 1238de0cf919SEnrico Perla - Sun Microsystems char *cmd_argv[MAXARGS]; 1239de0cf919SEnrico Perla - Sun Microsystems 1240de0cf919SEnrico Perla - Sun Microsystems 1241de0cf919SEnrico Perla - Sun Microsystems cmd_argv[i++] = "/sbin/bootadm"; 1242de0cf919SEnrico Perla - Sun Microsystems cmd_argv[i++] = "-ea"; 1243de0cf919SEnrico Perla - Sun Microsystems cmd_argv[i++] = "update_all"; 1244de0cf919SEnrico Perla - Sun Microsystems if (do_fast_reboot) 1245de0cf919SEnrico Perla - Sun Microsystems cmd_argv[i++] = "fastboot"; 1246de0cf919SEnrico Perla - Sun Microsystems cmd_argv[i] = NULL; 1247de0cf919SEnrico Perla - Sun Microsystems 1248de0cf919SEnrico Perla - Sun Microsystems r = posix_spawn(&pid, cmd_argv[0], NULL, NULL, cmd_argv, NULL); 1249de0cf919SEnrico Perla - Sun Microsystems 1250de0cf919SEnrico Perla - Sun Microsystems /* if posix_spawn fails we emit a warning and continue */ 1251de0cf919SEnrico Perla - Sun Microsystems 1252de0cf919SEnrico Perla - Sun Microsystems if (r != 0) 1253de0cf919SEnrico Perla - Sun Microsystems (void) fprintf(stderr, gettext("%s: WARNING, unable to start " 1254de0cf919SEnrico Perla - Sun Microsystems "boot archive update\n"), cmdname); 1255de0cf919SEnrico Perla - Sun Microsystems else 1256de0cf919SEnrico Perla - Sun Microsystems while (waitpid(pid, NULL, 0) == -1 && errno == EINTR) 1257de0cf919SEnrico Perla - Sun Microsystems ; 1258de0cf919SEnrico Perla - Sun Microsystems } 1259de0cf919SEnrico Perla - Sun Microsystems 12607c478bd9Sstevel@tonic-gate int 12617c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 12627c478bd9Sstevel@tonic-gate { 12637c478bd9Sstevel@tonic-gate int qflag = 0, needlog = 1, nosync = 0; 126419397407SSherry Moore int fast_reboot = 0; 1265753a6d45SSherry Moore int prom_reboot = 0; 12667c478bd9Sstevel@tonic-gate uintptr_t mdep = NULL; 12677c478bd9Sstevel@tonic-gate int cmd, fcn, c, aval, r; 12687c478bd9Sstevel@tonic-gate const char *usage; 12698e07a41fSKonstantin Ananyev const char *optstring; 12707c478bd9Sstevel@tonic-gate zoneid_t zoneid = getzoneid(); 12713f2f09c1Sdp int need_check_zones = 0; 12723f2f09c1Sdp char bootargs_buf[BOOTARGS_MAX]; 12733b860eeeSSherry Moore char *bootargs_orig = NULL; 127419397407SSherry Moore char *bename = NULL; 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate const char * const resetting = "/etc/svc/volatile/resetting"; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 12797c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 12807c478bd9Sstevel@tonic-gate 12813f2f09c1Sdp cmdname = basename(argv[0]); 12823f2f09c1Sdp 12837c478bd9Sstevel@tonic-gate if (strcmp(cmdname, "halt") == 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_HALT; 12897c478bd9Sstevel@tonic-gate } else if (strcmp(cmdname, "poweroff") == 0) { 12907c478bd9Sstevel@tonic-gate (void) audit_halt_setup(argc, argv); 12918e07a41fSKonstantin Ananyev optstring = "dlnqy"; 12927c478bd9Sstevel@tonic-gate usage = gettext("usage: %s [ -dlnqy ]\n"); 12937c478bd9Sstevel@tonic-gate cmd = A_SHUTDOWN; 12947c478bd9Sstevel@tonic-gate fcn = AD_POWEROFF; 12957c478bd9Sstevel@tonic-gate } else if (strcmp(cmdname, "reboot") == 0) { 12967c478bd9Sstevel@tonic-gate (void) audit_reboot_setup(); 12979abc7a57SToomas Soome #if defined(__x86) 1298753a6d45SSherry Moore optstring = "dlnqpfe:"; 1299753a6d45SSherry Moore usage = gettext("usage: %s [ -dlnq(p|fe:) ] [ boot args ]\n"); 130019397407SSherry Moore #else 1301e557d412SChristopher Kiick optstring = "dlnqfp"; 1302e557d412SChristopher Kiick usage = gettext("usage: %s [ -dlnq(p|f) ] [ boot args ]\n"); 130319397407SSherry Moore #endif 13047c478bd9Sstevel@tonic-gate cmd = A_SHUTDOWN; 13057c478bd9Sstevel@tonic-gate fcn = AD_BOOT; 13067c478bd9Sstevel@tonic-gate } else { 13077c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13087c478bd9Sstevel@tonic-gate gettext("%s: not installed properly\n"), cmdname); 13097c478bd9Sstevel@tonic-gate return (1); 13107c478bd9Sstevel@tonic-gate } 13117c478bd9Sstevel@tonic-gate 13128e07a41fSKonstantin Ananyev while ((c = getopt(argc, argv, optstring)) != EOF) { 13137c478bd9Sstevel@tonic-gate switch (c) { 13147c478bd9Sstevel@tonic-gate case 'd': 13157c478bd9Sstevel@tonic-gate if (zoneid == GLOBAL_ZONEID) 13167c478bd9Sstevel@tonic-gate cmd = A_DUMP; 13177c478bd9Sstevel@tonic-gate else { 13187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13197c478bd9Sstevel@tonic-gate gettext("%s: -d only valid from global" 13207c478bd9Sstevel@tonic-gate " zone\n"), cmdname); 13217c478bd9Sstevel@tonic-gate return (1); 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate break; 13247c478bd9Sstevel@tonic-gate case 'l': 13257c478bd9Sstevel@tonic-gate needlog = 0; 13267c478bd9Sstevel@tonic-gate break; 13277c478bd9Sstevel@tonic-gate case 'n': 13287c478bd9Sstevel@tonic-gate nosync = 1; 13297c478bd9Sstevel@tonic-gate break; 13307c478bd9Sstevel@tonic-gate case 'q': 13317c478bd9Sstevel@tonic-gate qflag = 1; 13327c478bd9Sstevel@tonic-gate break; 13337c478bd9Sstevel@tonic-gate case 'y': 1334bc2cf0f5SJoshua M. Clulow /* 1335bc2cf0f5SJoshua M. Clulow * Option ignored for backwards compatibility. 1336bc2cf0f5SJoshua M. Clulow */ 13377c478bd9Sstevel@tonic-gate break; 133819397407SSherry Moore case 'f': 133919397407SSherry Moore fast_reboot = 1; 134019397407SSherry Moore break; 1341e557d412SChristopher Kiick case 'p': 1342e557d412SChristopher Kiick prom_reboot = 1; 1343e557d412SChristopher Kiick break; 13449abc7a57SToomas Soome #if defined(__x86) 134519397407SSherry Moore case 'e': 134619397407SSherry Moore bename = optarg; 134719397407SSherry Moore break; 134819397407SSherry Moore #endif 13497c478bd9Sstevel@tonic-gate default: 13507c478bd9Sstevel@tonic-gate /* 13517c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 13527c478bd9Sstevel@tonic-gate * Don't translate the words "halt" or "reboot" 13537c478bd9Sstevel@tonic-gate */ 13547c478bd9Sstevel@tonic-gate (void) fprintf(stderr, usage, cmdname); 13557c478bd9Sstevel@tonic-gate return (1); 13567c478bd9Sstevel@tonic-gate } 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate argc -= optind; 13607c478bd9Sstevel@tonic-gate argv += optind; 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate if (argc != 0) { 13637c478bd9Sstevel@tonic-gate if (fcn != AD_BOOT) { 13647c478bd9Sstevel@tonic-gate (void) fprintf(stderr, usage, cmdname); 13657c478bd9Sstevel@tonic-gate return (1); 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* Gather the arguments into bootargs_buf. */ 13697c478bd9Sstevel@tonic-gate if (gather_args(argv, bootargs_buf, sizeof (bootargs_buf)) != 13707c478bd9Sstevel@tonic-gate 0) { 13717c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13727c478bd9Sstevel@tonic-gate gettext("%s: Boot arguments too long.\n"), cmdname); 13737c478bd9Sstevel@tonic-gate return (1); 13747c478bd9Sstevel@tonic-gate } 137519397407SSherry Moore 13763b860eeeSSherry Moore bootargs_orig = strdup(bootargs_buf); 13777c478bd9Sstevel@tonic-gate mdep = (uintptr_t)bootargs_buf; 137819397407SSherry Moore } else { 137919397407SSherry Moore /* 138019397407SSherry Moore * Initialize it to 0 in case of fastboot, the buffer 138119397407SSherry Moore * will be used. 138219397407SSherry Moore */ 138319397407SSherry Moore bzero(bootargs_buf, sizeof (bootargs_buf)); 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate 1386753a6d45SSherry Moore if (geteuid() != 0) { 13877c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13887c478bd9Sstevel@tonic-gate gettext("%s: permission denied\n"), cmdname); 13897c478bd9Sstevel@tonic-gate goto fail; 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate 1392753a6d45SSherry Moore if (fast_reboot && prom_reboot) { 1393753a6d45SSherry Moore (void) fprintf(stderr, 1394753a6d45SSherry Moore gettext("%s: -p and -f are mutually exclusive\n"), 1395753a6d45SSherry Moore cmdname); 1396753a6d45SSherry Moore return (EINVAL); 1397753a6d45SSherry Moore } 139819397407SSherry Moore /* 1399753a6d45SSherry Moore * Check whether fast reboot is the default operating mode 140019397407SSherry Moore */ 1401753a6d45SSherry Moore if (fcn == AD_BOOT && !fast_reboot && !prom_reboot && 1402e557d412SChristopher Kiick zoneid == GLOBAL_ZONEID) { 1403753a6d45SSherry Moore fast_reboot = scf_is_fastboot_default(); 140419397407SSherry Moore 1405e557d412SChristopher Kiick } 1406e557d412SChristopher Kiick 140719397407SSherry Moore if (bename && !fast_reboot) { 140819397407SSherry Moore (void) fprintf(stderr, gettext("%s: -e only valid with -f\n"), 140919397407SSherry Moore cmdname); 141019397407SSherry Moore return (EINVAL); 141119397407SSherry Moore } 141219397407SSherry Moore 1413e557d412SChristopher Kiick #if defined(__sparc) 1414e557d412SChristopher Kiick if (fast_reboot) { 1415e557d412SChristopher Kiick fast_reboot = 2; /* need to distinguish each case */ 1416e557d412SChristopher Kiick } 1417e557d412SChristopher Kiick #endif 1418e557d412SChristopher Kiick 141919397407SSherry Moore /* 142019397407SSherry Moore * If fast reboot, do some sanity check on the argument 142119397407SSherry Moore */ 1422e557d412SChristopher Kiick if (fast_reboot == 1) { 142319397407SSherry Moore int rc; 142419397407SSherry Moore int is_dryrun = 0; 142519397407SSherry Moore 142619397407SSherry Moore if (zoneid != GLOBAL_ZONEID) { 142719397407SSherry Moore (void) fprintf(stderr, 1428753a6d45SSherry Moore gettext("%s: Fast reboot only valid from global" 142919397407SSherry Moore " zone\n"), cmdname); 143019397407SSherry Moore return (EINVAL); 143119397407SSherry Moore } 143219397407SSherry Moore 1433753a6d45SSherry Moore rc = parse_fastboot_args(bootargs_buf, sizeof (bootargs_buf), 14345b89e3f7SSherry Moore &is_dryrun, bename); 143519397407SSherry Moore 143619397407SSherry Moore /* 143719397407SSherry Moore * If dry run, or if arguments are invalid, return. 143819397407SSherry Moore */ 143919397407SSherry Moore if (is_dryrun) 144019397407SSherry Moore return (rc); 1441753a6d45SSherry Moore else if (rc == EINVAL) 144219397407SSherry Moore goto fail; 1443753a6d45SSherry Moore else if (rc != 0) 1444753a6d45SSherry Moore fast_reboot = 0; 144519397407SSherry Moore 144619397407SSherry Moore /* 144719397407SSherry Moore * For all the other errors, we continue on in case user 1448753a6d45SSherry Moore * user want to force fast reboot, or fall back to regular 1449753a6d45SSherry Moore * reboot. 145019397407SSherry Moore */ 145119397407SSherry Moore if (strlen(bootargs_buf) != 0) 145219397407SSherry Moore mdep = (uintptr_t)bootargs_buf; 145319397407SSherry Moore } 145419397407SSherry Moore 145519397407SSherry Moore #if 0 /* For debugging */ 145619397407SSherry Moore if (mdep != NULL) 145719397407SSherry Moore (void) fprintf(stderr, "mdep = %s\n", (char *)mdep); 145819397407SSherry Moore #endif 145919397407SSherry Moore 14607c478bd9Sstevel@tonic-gate if (needlog) { 14617c478bd9Sstevel@tonic-gate char *user = getlogin(); 14627c478bd9Sstevel@tonic-gate struct passwd *pw; 1463f040a7a6Ssetje char *tty; 14647c478bd9Sstevel@tonic-gate 14657c478bd9Sstevel@tonic-gate openlog(cmdname, 0, LOG_AUTH); 14667c478bd9Sstevel@tonic-gate if (user == NULL && (pw = getpwuid(getuid())) != NULL) 14677c478bd9Sstevel@tonic-gate user = pw->pw_name; 14687c478bd9Sstevel@tonic-gate if (user == NULL) 14697c478bd9Sstevel@tonic-gate user = "root"; 1470f040a7a6Ssetje 1471f040a7a6Ssetje tty = ttyname(1); 1472f040a7a6Ssetje 1473f040a7a6Ssetje if (tty == NULL) 1474f040a7a6Ssetje syslog(LOG_CRIT, "initiated by %s", user); 1475f040a7a6Ssetje else 1476f040a7a6Ssetje syslog(LOG_CRIT, "initiated by %s on %s", user, tty); 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate /* 14807c478bd9Sstevel@tonic-gate * We must assume success and log it before auditd is terminated. 14817c478bd9Sstevel@tonic-gate */ 14827c478bd9Sstevel@tonic-gate if (fcn == AD_BOOT) 14837c478bd9Sstevel@tonic-gate aval = audit_reboot_success(); 14847c478bd9Sstevel@tonic-gate else 14857c478bd9Sstevel@tonic-gate aval = audit_halt_success(); 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate if (aval == -1) { 14887c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14897c478bd9Sstevel@tonic-gate gettext("%s: can't turn off auditd\n"), cmdname); 14907c478bd9Sstevel@tonic-gate if (needlog) 14917c478bd9Sstevel@tonic-gate (void) sleep(5); /* Give syslogd time to record this */ 14927c478bd9Sstevel@tonic-gate } 14937c478bd9Sstevel@tonic-gate 14947c478bd9Sstevel@tonic-gate (void) signal(SIGHUP, SIG_IGN); /* for remote connections */ 14957c478bd9Sstevel@tonic-gate 149626f665e8Sdstaff /* 149726f665e8Sdstaff * We start to fork a bunch of zoneadms to halt any active zones. 149826f665e8Sdstaff * This will proceed with halt in parallel until we call 149926f665e8Sdstaff * check_zone_haltedness later on. 150026f665e8Sdstaff */ 150126f665e8Sdstaff if (zoneid == GLOBAL_ZONEID && cmd != A_DUMP) { 15023f2f09c1Sdp need_check_zones = halt_zones(); 150326f665e8Sdstaff } 150426f665e8Sdstaff 15059abc7a57SToomas Soome #if defined(__x86) 1506753a6d45SSherry Moore /* set new default entry in the GRUB entry */ 15079abc7a57SToomas Soome if (fbarg_entnum != BE_ENTRY_DEFAULT) { 1508753a6d45SSherry Moore char buf[32]; 1509753a6d45SSherry Moore (void) snprintf(buf, sizeof (buf), "default=%u", fbarg_entnum); 1510753a6d45SSherry Moore (void) halt_exec(BOOTADM_PROG, "set-menu", buf, NULL); 1511753a6d45SSherry Moore } 15129abc7a57SToomas Soome #endif /* __x86 */ 151348847494SEnrico Perla - Sun Microsystems 1514753a6d45SSherry Moore /* if we're dumping, do the archive update here and don't defer it */ 1515de0cf919SEnrico Perla - Sun Microsystems if (cmd == A_DUMP && zoneid == GLOBAL_ZONEID && !nosync) 1516de0cf919SEnrico Perla - Sun Microsystems do_archives_update(fast_reboot); 15177c478bd9Sstevel@tonic-gate 15187c478bd9Sstevel@tonic-gate /* 15197c478bd9Sstevel@tonic-gate * If we're not forcing a crash dump, mark the system as quiescing for 15207c478bd9Sstevel@tonic-gate * smf(5)'s benefit, and idle the init process. 15217c478bd9Sstevel@tonic-gate */ 15227c478bd9Sstevel@tonic-gate if (cmd != A_DUMP) { 15233f2f09c1Sdp if (direct_init(PCDSTOP) == -1) { 15247c478bd9Sstevel@tonic-gate /* 15257c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 15267c478bd9Sstevel@tonic-gate * Don't translate the word "init" 15277c478bd9Sstevel@tonic-gate */ 15287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 15297c478bd9Sstevel@tonic-gate gettext("%s: can't idle init\n"), cmdname); 15307c478bd9Sstevel@tonic-gate goto fail; 15317c478bd9Sstevel@tonic-gate } 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate if (creat(resetting, 0755) == -1) 15347c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 15357c478bd9Sstevel@tonic-gate gettext("%s: could not create %s.\n"), 15367c478bd9Sstevel@tonic-gate cmdname, resetting); 15379db7147eSSherry Moore } 15389db7147eSSherry Moore 15399db7147eSSherry Moore /* 15409db7147eSSherry Moore * Make sure we don't get stopped by a jobcontrol shell 15419db7147eSSherry Moore * once we start killing everybody. 15429db7147eSSherry Moore */ 15439db7147eSSherry Moore (void) signal(SIGTSTP, SIG_IGN); 15449db7147eSSherry Moore (void) signal(SIGTTIN, SIG_IGN); 15459db7147eSSherry Moore (void) signal(SIGTTOU, SIG_IGN); 15469db7147eSSherry Moore (void) signal(SIGPIPE, SIG_IGN); 15479db7147eSSherry Moore (void) signal(SIGTERM, SIG_IGN); 15489db7147eSSherry Moore 15499db7147eSSherry Moore /* 15509db7147eSSherry Moore * Try to stop gdm so X has a chance to return the screen and 15519db7147eSSherry Moore * keyboard to a sane state. 15529db7147eSSherry Moore */ 1553e557d412SChristopher Kiick if (fast_reboot == 1 && stop_gdm() != 0) { 15549db7147eSSherry Moore (void) fprintf(stderr, 15559db7147eSSherry Moore gettext("%s: Falling back to regular reboot.\n"), cmdname); 15569db7147eSSherry Moore fast_reboot = 0; 15573b860eeeSSherry Moore mdep = (uintptr_t)bootargs_orig; 15583b860eeeSSherry Moore } else if (bootargs_orig) { 15593b860eeeSSherry Moore free(bootargs_orig); 15609db7147eSSherry Moore } 15617c478bd9Sstevel@tonic-gate 15629db7147eSSherry Moore if (cmd != A_DUMP) { 15637c478bd9Sstevel@tonic-gate /* 15647c478bd9Sstevel@tonic-gate * Stop all restarters so they do not try to restart services 15657c478bd9Sstevel@tonic-gate * that are terminated. 15667c478bd9Sstevel@tonic-gate */ 15677c478bd9Sstevel@tonic-gate stop_restarters(); 156826f665e8Sdstaff 156926f665e8Sdstaff /* 157026f665e8Sdstaff * Wait a little while for zones to shutdown. 157126f665e8Sdstaff */ 157226f665e8Sdstaff if (need_check_zones) { 15733f2f09c1Sdp check_zones_haltedness(); 157426f665e8Sdstaff 157526f665e8Sdstaff (void) fprintf(stderr, 157626f665e8Sdstaff gettext("%s: Completing system halt.\n"), 157726f665e8Sdstaff cmdname); 157826f665e8Sdstaff } 15797c478bd9Sstevel@tonic-gate } 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate /* 15827c478bd9Sstevel@tonic-gate * If we're not forcing a crash dump, give everyone 5 seconds to 15837c478bd9Sstevel@tonic-gate * handle a SIGTERM and clean up properly. 15847c478bd9Sstevel@tonic-gate */ 15857c478bd9Sstevel@tonic-gate if (cmd != A_DUMP) { 1586de0cf919SEnrico Perla - Sun Microsystems if (zoneid == GLOBAL_ZONEID && !nosync) 1587de0cf919SEnrico Perla - Sun Microsystems do_archives_update(fast_reboot); 1588*75383e32SAndy Fiddaman (void) kill(-1, SIGTERM); 1589*75383e32SAndy Fiddaman (void) sleep(5); 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate 15923a0fa635SEnrico Perla - Sun Microsystems (void) signal(SIGINT, SIG_IGN); 15933a0fa635SEnrico Perla - Sun Microsystems 15947c478bd9Sstevel@tonic-gate if (!qflag && !nosync) { 15957c478bd9Sstevel@tonic-gate struct utmpx wtmpx; 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate bzero(&wtmpx, sizeof (struct utmpx)); 15987c478bd9Sstevel@tonic-gate (void) strcpy(wtmpx.ut_line, "~"); 15997c478bd9Sstevel@tonic-gate (void) time(&wtmpx.ut_tv.tv_sec); 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate if (cmd == A_DUMP) 16027c478bd9Sstevel@tonic-gate (void) strcpy(wtmpx.ut_name, "crash dump"); 16037c478bd9Sstevel@tonic-gate else 16047c478bd9Sstevel@tonic-gate (void) strcpy(wtmpx.ut_name, "shutdown"); 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate (void) updwtmpx(WTMPX_FILE, &wtmpx); 16077c478bd9Sstevel@tonic-gate sync(); 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate if (cmd == A_DUMP && nosync != 0) 16117c478bd9Sstevel@tonic-gate (void) uadmin(A_DUMP, AD_NOSYNC, NULL); 16127c478bd9Sstevel@tonic-gate 16135b89e3f7SSherry Moore if (fast_reboot) 161419397407SSherry Moore fcn = AD_FASTREBOOT; 161519397407SSherry Moore 16163f2f09c1Sdp if (uadmin(cmd, fcn, mdep) == -1) 16173f2f09c1Sdp (void) fprintf(stderr, "%s: uadmin failed: %s\n", 16183f2f09c1Sdp cmdname, strerror(errno)); 16193f2f09c1Sdp else 16203f2f09c1Sdp (void) fprintf(stderr, "%s: uadmin unexpectedly returned 0\n", 16213f2f09c1Sdp cmdname); 16223f2f09c1Sdp 16233f2f09c1Sdp do { 16247c478bd9Sstevel@tonic-gate r = remove(resetting); 16253f2f09c1Sdp } while (r != 0 && errno == EINTR); 16263f2f09c1Sdp 16277c478bd9Sstevel@tonic-gate if (r != 0 && errno != ENOENT) 16287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s: could not remove %s.\n"), 16297c478bd9Sstevel@tonic-gate cmdname, resetting); 16307c478bd9Sstevel@tonic-gate 16313f2f09c1Sdp if (direct_init(PCRUN) == -1) { 16323f2f09c1Sdp /* 16333f2f09c1Sdp * TRANSLATION_NOTE 16343f2f09c1Sdp * Don't translate the word "init" 16353f2f09c1Sdp */ 16363f2f09c1Sdp (void) fprintf(stderr, 16373f2f09c1Sdp gettext("%s: can't resume init\n"), cmdname); 16383f2f09c1Sdp } 16393f2f09c1Sdp 16407c478bd9Sstevel@tonic-gate continue_restarters(); 16417c478bd9Sstevel@tonic-gate 16423f2f09c1Sdp if (get_initpid() != -1) 16437c478bd9Sstevel@tonic-gate /* tell init to restate current level */ 16443f2f09c1Sdp (void) kill(get_initpid(), SIGHUP); 16457c478bd9Sstevel@tonic-gate 16467c478bd9Sstevel@tonic-gate fail: 16477c478bd9Sstevel@tonic-gate if (fcn == AD_BOOT) 16487c478bd9Sstevel@tonic-gate (void) audit_reboot_fail(); 16497c478bd9Sstevel@tonic-gate else 16507c478bd9Sstevel@tonic-gate (void) audit_halt_fail(); 16517c478bd9Sstevel@tonic-gate 1652e557d412SChristopher Kiick if (fast_reboot == 1) { 165319397407SSherry Moore if (bename) { 165480cb75f4SWilliam Kucharski (void) halt_exec(BEADM_PROG, "umount", bename, NULL); 165519397407SSherry Moore 165619397407SSherry Moore } else if (strlen(fastboot_mounted) != 0) { 165719397407SSherry Moore (void) umount(fastboot_mounted); 16589abc7a57SToomas Soome #if defined(__x86) 16599abc7a57SToomas Soome } else { 16609abc7a57SToomas Soome free(fbarg_used); 16619abc7a57SToomas Soome #endif /* __x86 */ 166219397407SSherry Moore } 166319397407SSherry Moore } 166419397407SSherry Moore 16657c478bd9Sstevel@tonic-gate return (1); 16667c478bd9Sstevel@tonic-gate } 1667