1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25 /*
26 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
27 * Copyright (c) 2015 by Delphix. All rights reserved.
28 */
29
30 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
31 /* All Rights Reserved */
32
33 /*
34 * University Copyright- Copyright (c) 1982, 1986, 1988
35 * The Regents of the University of California
36 * All Rights Reserved
37 *
38 * University Acknowledgment- Portions of this document are derived from
39 * software developed by the University of California, Berkeley, and its
40 * contributors.
41 * Portions contributed by Juergen Keil, <jk@tools.de>.
42 */
43
44
45 /*
46 * Common code for halt(1M), poweroff(1M), and reboot(1M). We use
47 * argv[0] to determine which behavior to exhibit.
48 */
49
50 #include <stdio.h>
51 #include <procfs.h>
52 #include <sys/types.h>
53 #include <sys/elf.h>
54 #include <sys/systeminfo.h>
55 #include <sys/stat.h>
56 #include <sys/uadmin.h>
57 #include <sys/mntent.h>
58 #include <sys/mnttab.h>
59 #include <sys/mount.h>
60 #include <sys/fs/ufs_mount.h>
61 #include <alloca.h>
62 #include <assert.h>
63 #include <errno.h>
64 #include <fcntl.h>
65 #include <libgen.h>
66 #include <libscf.h>
67 #include <libscf_priv.h>
68 #include <limits.h>
69 #include <locale.h>
70 #include <libintl.h>
71 #include <syslog.h>
72 #include <signal.h>
73 #include <strings.h>
74 #include <unistd.h>
75 #include <stdlib.h>
76 #include <stdio.h>
77 #include <strings.h>
78 #include <time.h>
79 #include <wait.h>
80 #include <ctype.h>
81 #include <utmpx.h>
82 #include <pwd.h>
83 #include <zone.h>
84 #include <spawn.h>
85
86 #include <libzfs.h>
87 #if defined(__i386)
88 #include <libgrubmgmt.h>
89 #endif
90
91 #if !defined(TEXT_DOMAIN)
92 #define TEXT_DOMAIN "SYS_TEST"
93 #endif
94
95 #if defined(__sparc)
96 #define CUR_ELFDATA ELFDATA2MSB
97 #elif defined(__i386)
98 #define CUR_ELFDATA ELFDATA2LSB
99 #endif
100
101 static libzfs_handle_t *g_zfs;
102
103 extern int audit_halt_setup(int, char **);
104 extern int audit_halt_success(void);
105 extern int audit_halt_fail(void);
106
107 extern int audit_reboot_setup(void);
108 extern int audit_reboot_success(void);
109 extern int audit_reboot_fail(void);
110
111 static char *cmdname; /* basename(argv[0]), the name of the command */
112
113 typedef struct ctidlist_struct {
114 ctid_t ctid;
115 struct ctidlist_struct *next;
116 } ctidlist_t;
117
118 static ctidlist_t *ctidlist = NULL;
119 static ctid_t startdct = -1;
120
121 #define FMRI_STARTD_CONTRACT \
122 "svc:/system/svc/restarter:default/:properties/restarter/contract"
123
124 #define BEADM_PROG "/usr/sbin/beadm"
125 #define BOOTADM_PROG "/sbin/bootadm"
126 #define ZONEADM_PROG "/usr/sbin/zoneadm"
127
128 /*
129 * The length of FASTBOOT_MOUNTPOINT must be less than MAXPATHLEN.
130 */
131 #define FASTBOOT_MOUNTPOINT "/tmp/.fastboot.root"
132
133 /*
134 * Fast Reboot related variables
135 */
136 static char fastboot_mounted[MAXPATHLEN];
137
138 #if defined(__i386)
139 static grub_boot_args_t fbarg;
140 static grub_boot_args_t *fbarg_used;
141 static int fbarg_entnum = GRUB_ENTRY_DEFAULT;
142 #endif /* __i386 */
143
144 static int validate_ufs_disk(char *, char *);
145 static int validate_zfs_pool(char *, char *);
146
147 static pid_t
get_initpid()148 get_initpid()
149 {
150 static int init_pid = -1;
151
152 if (init_pid == -1) {
153 if (zone_getattr(getzoneid(), ZONE_ATTR_INITPID, &init_pid,
154 sizeof (init_pid)) != sizeof (init_pid)) {
155 assert(errno == ESRCH);
156 init_pid = -1;
157 }
158 }
159 return (init_pid);
160 }
161
162 /*
163 * Quiesce or resume init using /proc. When stopping init, we can't send
164 * SIGTSTP (since init ignores it) or SIGSTOP (since the kernel won't permit
165 * it).
166 */
167 static int
direct_init(long command)168 direct_init(long command)
169 {
170 char ctlfile[MAXPATHLEN];
171 pid_t pid;
172 int ctlfd;
173
174 assert(command == PCDSTOP || command == PCRUN);
175 if ((pid = get_initpid()) == -1) {
176 return (-1);
177 }
178
179 (void) snprintf(ctlfile, sizeof (ctlfile), "/proc/%d/ctl", pid);
180 if ((ctlfd = open(ctlfile, O_WRONLY)) == -1)
181 return (-1);
182
183 if (command == PCDSTOP) {
184 if (write(ctlfd, &command, sizeof (long)) == -1) {
185 (void) close(ctlfd);
186 return (-1);
187 }
188 } else { /* command == PCRUN */
189 long cmds[2];
190 cmds[0] = command;
191 cmds[1] = 0;
192 if (write(ctlfd, cmds, sizeof (cmds)) == -1) {
193 (void) close(ctlfd);
194 return (-1);
195 }
196 }
197 (void) close(ctlfd);
198 return (0);
199 }
200
201 static void
stop_startd()202 stop_startd()
203 {
204 scf_handle_t *h;
205 scf_property_t *prop = NULL;
206 scf_value_t *val = NULL;
207 uint64_t uint64;
208
209 if ((h = scf_handle_create(SCF_VERSION)) == NULL)
210 return;
211
212 if ((scf_handle_bind(h) != 0) ||
213 ((prop = scf_property_create(h)) == NULL) ||
214 ((val = scf_value_create(h)) == NULL))
215 goto out;
216
217 if (scf_handle_decode_fmri(h, FMRI_STARTD_CONTRACT,
218 NULL, NULL, NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0)
219 goto out;
220
221 if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 ||
222 scf_property_get_value(prop, val) != 0 ||
223 scf_value_get_count(val, &uint64) != 0)
224 goto out;
225
226 startdct = (ctid_t)uint64;
227 (void) sigsend(P_CTID, startdct, SIGSTOP);
228
229 out:
230 scf_property_destroy(prop);
231 scf_value_destroy(val);
232 scf_handle_destroy(h);
233 }
234
235 static void
continue_startd()236 continue_startd()
237 {
238 if (startdct != -1)
239 (void) sigsend(P_CTID, startdct, SIGCONT);
240 }
241
242 #define FMRI_RESTARTER_PROP "/:properties/general/restarter"
243 #define FMRI_CONTRACT_PROP "/:properties/restarter/contract"
244
245 static int
save_ctid(ctid_t ctid)246 save_ctid(ctid_t ctid)
247 {
248 ctidlist_t *next;
249
250 for (next = ctidlist; next != NULL; next = next->next)
251 if (next->ctid == ctid)
252 return (-1);
253
254 next = (ctidlist_t *)malloc(sizeof (ctidlist_t));
255 if (next == NULL)
256 return (-1);
257
258 next->ctid = ctid;
259 next->next = ctidlist;
260 ctidlist = next;
261 return (0);
262 }
263
264 static void
stop_delegates()265 stop_delegates()
266 {
267 ctid_t ctid;
268 scf_handle_t *h;
269 scf_scope_t *sc = NULL;
270 scf_service_t *svc = NULL;
271 scf_instance_t *inst = NULL;
272 scf_snapshot_t *snap = NULL;
273 scf_snapshot_t *isnap = NULL;
274 scf_propertygroup_t *pg = NULL;
275 scf_property_t *prop = NULL;
276 scf_value_t *val = NULL;
277 scf_iter_t *siter = NULL;
278 scf_iter_t *iiter = NULL;
279 char *fmri;
280 ssize_t length;
281
282 uint64_t uint64;
283 ssize_t bytes;
284
285 length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
286 if (length <= 0)
287 return;
288
289 length++;
290 fmri = alloca(length * sizeof (char));
291
292 if ((h = scf_handle_create(SCF_VERSION)) == NULL)
293 return;
294
295 if (scf_handle_bind(h) != 0) {
296 scf_handle_destroy(h);
297 return;
298 }
299
300 if ((sc = scf_scope_create(h)) == NULL ||
301 (svc = scf_service_create(h)) == NULL ||
302 (inst = scf_instance_create(h)) == NULL ||
303 (snap = scf_snapshot_create(h)) == NULL ||
304 (pg = scf_pg_create(h)) == NULL ||
305 (prop = scf_property_create(h)) == NULL ||
306 (val = scf_value_create(h)) == NULL ||
307 (siter = scf_iter_create(h)) == NULL ||
308 (iiter = scf_iter_create(h)) == NULL)
309 goto out;
310
311 if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, sc) != 0)
312 goto out;
313
314 if (scf_iter_scope_services(siter, sc) != 0)
315 goto out;
316
317 while (scf_iter_next_service(siter, svc) == 1) {
318
319 if (scf_iter_service_instances(iiter, svc) != 0)
320 continue;
321
322 while (scf_iter_next_instance(iiter, inst) == 1) {
323
324 if ((scf_instance_get_snapshot(inst, "running",
325 snap)) != 0)
326 isnap = NULL;
327 else
328 isnap = snap;
329
330 if (scf_instance_get_pg_composed(inst, isnap,
331 SCF_PG_GENERAL, pg) != 0)
332 continue;
333
334 if (scf_pg_get_property(pg, SCF_PROPERTY_RESTARTER,
335 prop) != 0 ||
336 scf_property_get_value(prop, val) != 0)
337 continue;
338
339 bytes = scf_value_get_astring(val, fmri, length);
340 if (bytes <= 0 || bytes >= length)
341 continue;
342
343 if (strlcat(fmri, FMRI_CONTRACT_PROP, length) >=
344 length)
345 continue;
346
347 if (scf_handle_decode_fmri(h, fmri, NULL, NULL,
348 NULL, NULL, prop, SCF_DECODE_FMRI_EXACT) != 0)
349 continue;
350
351 if (scf_property_is_type(prop, SCF_TYPE_COUNT) != 0 ||
352 scf_property_get_value(prop, val) != 0 ||
353 scf_value_get_count(val, &uint64) != 0)
354 continue;
355
356 ctid = (ctid_t)uint64;
357 if (save_ctid(ctid) == 0) {
358 (void) sigsend(P_CTID, ctid, SIGSTOP);
359 }
360 }
361 }
362 out:
363 scf_scope_destroy(sc);
364 scf_service_destroy(svc);
365 scf_instance_destroy(inst);
366 scf_snapshot_destroy(snap);
367 scf_pg_destroy(pg);
368 scf_property_destroy(prop);
369 scf_value_destroy(val);
370 scf_iter_destroy(siter);
371 scf_iter_destroy(iiter);
372
373 (void) scf_handle_unbind(h);
374 scf_handle_destroy(h);
375 }
376
377 static void
continue_delegates()378 continue_delegates()
379 {
380 ctidlist_t *next;
381 for (next = ctidlist; next != NULL; next = next->next)
382 (void) sigsend(P_CTID, next->ctid, SIGCONT);
383 }
384
385 #define FMRI_GDM "svc:/application/graphical-login/gdm:default"
386 #define GDM_STOP_TIMEOUT 10 /* Give gdm 10 seconds to shut down */
387
388 /*
389 * If gdm is running, try to stop gdm.
390 * Returns 0 on success, -1 on failure.
391 */
392 static int
stop_gdm()393 stop_gdm()
394 {
395 char *gdm_state = NULL;
396 int retry = 0;
397
398 /*
399 * If gdm is running, try to stop gdm.
400 */
401 while ((gdm_state = smf_get_state(FMRI_GDM)) != NULL &&
402 strcmp(gdm_state, SCF_STATE_STRING_ONLINE) == 0 &&
403 retry++ < GDM_STOP_TIMEOUT) {
404
405 free(gdm_state);
406
407 /*
408 * Only need to disable once.
409 */
410 if (retry == 1 &&
411 smf_disable_instance(FMRI_GDM, SMF_TEMPORARY) != 0) {
412 (void) fprintf(stderr,
413 gettext("%s: Failed to stop %s: %s.\n"),
414 cmdname, FMRI_GDM, scf_strerror(scf_error()));
415 return (-1);
416 }
417 (void) sleep(1);
418 }
419
420 if (retry >= GDM_STOP_TIMEOUT) {
421 (void) fprintf(stderr, gettext("%s: Failed to stop %s.\n"),
422 cmdname, FMRI_GDM);
423 return (-1);
424 }
425
426 return (0);
427 }
428
429
430 static void
stop_restarters()431 stop_restarters()
432 {
433 stop_startd();
434 stop_delegates();
435 }
436
437 static void
continue_restarters()438 continue_restarters()
439 {
440 continue_startd();
441 continue_delegates();
442 }
443
444 /*
445 * Copy an array of strings into buf, separated by spaces. Returns 0 on
446 * success.
447 */
448 static int
gather_args(char ** args,char * buf,size_t buf_sz)449 gather_args(char **args, char *buf, size_t buf_sz)
450 {
451 if (strlcpy(buf, *args, buf_sz) >= buf_sz)
452 return (-1);
453
454 for (++args; *args != NULL; ++args) {
455 if (strlcat(buf, " ", buf_sz) >= buf_sz)
456 return (-1);
457 if (strlcat(buf, *args, buf_sz) >= buf_sz)
458 return (-1);
459 }
460
461 return (0);
462 }
463
464 /*
465 * Halt every zone on the system. We are committed to doing a shutdown
466 * even if something goes wrong here. If something goes wrong, we just
467 * continue with the shutdown. Return non-zero if we need to wait for zones to
468 * halt later on.
469 */
470 static int
halt_zones()471 halt_zones()
472 {
473 pid_t pid;
474 zoneid_t *zones;
475 size_t nz = 0, old_nz;
476 int i;
477 char zname[ZONENAME_MAX];
478
479 /*
480 * Get a list of zones. If the number of zones changes in between the
481 * two zone_list calls, try again.
482 */
483
484 for (;;) {
485 (void) zone_list(NULL, &nz);
486 if (nz == 1)
487 return (0);
488 old_nz = nz;
489 zones = calloc(sizeof (zoneid_t), nz);
490 if (zones == NULL) {
491 (void) fprintf(stderr,
492 gettext("%s: Could not halt zones"
493 " (out of memory).\n"), cmdname);
494 return (0);
495 }
496
497 (void) zone_list(zones, &nz);
498 if (old_nz == nz)
499 break;
500 free(zones);
501 }
502
503 if (nz == 2) {
504 (void) fprintf(stderr, gettext("%s: Halting 1 zone.\n"),
505 cmdname);
506 } else {
507 (void) fprintf(stderr, gettext("%s: Halting %i zones.\n"),
508 cmdname, nz - 1);
509 }
510
511 for (i = 0; i < nz; i++) {
512 if (zones[i] == GLOBAL_ZONEID)
513 continue;
514 if (getzonenamebyid(zones[i], zname, sizeof (zname)) < 0) {
515 /*
516 * getzonenamebyid should only fail if we raced with
517 * another process trying to shut down the zone.
518 * We assume this happened and ignore the error.
519 */
520 if (errno != EINVAL) {
521 (void) fprintf(stderr,
522 gettext("%s: Unexpected error while "
523 "looking up zone %ul: %s.\n"),
524 cmdname, zones[i], strerror(errno));
525 }
526
527 continue;
528 }
529 pid = fork();
530 if (pid < 0) {
531 (void) fprintf(stderr,
532 gettext("%s: Zone \"%s\" could not be"
533 " halted (could not fork(): %s).\n"),
534 cmdname, zname, strerror(errno));
535 continue;
536 }
537 if (pid == 0) {
538 (void) execl(ZONEADM_PROG, ZONEADM_PROG,
539 "-z", zname, "halt", NULL);
540 (void) fprintf(stderr,
541 gettext("%s: Zone \"%s\" could not be halted"
542 " (cannot exec(" ZONEADM_PROG "): %s).\n"),
543 cmdname, zname, strerror(errno));
544 exit(0);
545 }
546 }
547
548 return (1);
549 }
550
551 /*
552 * This function tries to wait for all non-global zones to go away.
553 * It will timeout if no progress is made for 5 seconds, or a total of
554 * 30 seconds elapses.
555 */
556
557 static void
check_zones_haltedness()558 check_zones_haltedness()
559 {
560 int t = 0, t_prog = 0;
561 size_t nz = 0, last_nz;
562
563 do {
564 last_nz = nz;
565 (void) zone_list(NULL, &nz);
566 if (nz == 1)
567 return;
568
569 (void) sleep(1);
570
571 if (last_nz > nz)
572 t_prog = 0;
573
574 t++;
575 t_prog++;
576
577 if (t == 10) {
578 if (nz == 2) {
579 (void) fprintf(stderr,
580 gettext("%s: Still waiting for 1 zone to "
581 "halt. Will wait up to 20 seconds.\n"),
582 cmdname);
583 } else {
584 (void) fprintf(stderr,
585 gettext("%s: Still waiting for %i zones "
586 "to halt. Will wait up to 20 seconds.\n"),
587 cmdname, nz - 1);
588 }
589 }
590
591 } while ((t < 30) && (t_prog < 5));
592 }
593
594
595 /*
596 * Validate that this is a root disk or dataset
597 * Returns 0 if it is a root disk or dataset;
598 * returns 1 if it is a disk argument or dataset, but not valid or not root;
599 * returns -1 if it is not a valid argument or a disk argument.
600 */
601 static int
validate_disk(char * arg,char * mountpoint)602 validate_disk(char *arg, char *mountpoint)
603 {
604 static char root_dev_path[] = "/dev/dsk";
605 char kernpath[MAXPATHLEN];
606 struct stat64 statbuf;
607 int rc = 0;
608
609 if (strlen(arg) > MAXPATHLEN) {
610 (void) fprintf(stderr,
611 gettext("%s: Argument is too long\n"), cmdname);
612 return (-1);
613 }
614
615 bcopy(FASTBOOT_MOUNTPOINT, mountpoint, sizeof (FASTBOOT_MOUNTPOINT));
616
617 if (strstr(arg, mountpoint) == NULL) {
618 /*
619 * Do a force umount just in case some other filesystem has
620 * been mounted there.
621 */
622 (void) umount2(mountpoint, MS_FORCE);
623 }
624
625 /* Create the directory if it doesn't already exist */
626 if (lstat64(mountpoint, &statbuf) != 0) {
627 if (mkdirp(mountpoint, 0755) != 0) {
628 (void) fprintf(stderr,
629 gettext("Failed to create mountpoint %s\n"),
630 mountpoint);
631 return (-1);
632 }
633 }
634
635 if (strncmp(arg, root_dev_path, strlen(root_dev_path)) == 0) {
636 /* ufs root disk argument */
637 rc = validate_ufs_disk(arg, mountpoint);
638 } else {
639 /* zfs root pool argument */
640 rc = validate_zfs_pool(arg, mountpoint);
641 }
642
643 if (rc != 0)
644 return (rc);
645
646 (void) snprintf(kernpath, MAXPATHLEN, "%s/platform/i86pc/kernel/unix",
647 mountpoint);
648
649 if (stat64(kernpath, &statbuf) != 0) {
650 (void) fprintf(stderr,
651 gettext("%s: %s is not a root disk or dataset\n"),
652 cmdname, arg);
653 return (1);
654 }
655
656 return (0);
657 }
658
659
660 static int
validate_ufs_disk(char * arg,char * mountpoint)661 validate_ufs_disk(char *arg, char *mountpoint)
662 {
663 struct ufs_args ufs_args = { 0 };
664 char mntopts[MNT_LINE_MAX] = MNTOPT_LARGEFILES;
665
666 /* perform the mount */
667 ufs_args.flags = UFSMNT_LARGEFILES;
668 if (mount(arg, mountpoint, MS_DATA|MS_OPTIONSTR,
669 MNTTYPE_UFS, &ufs_args, sizeof (ufs_args),
670 mntopts, sizeof (mntopts)) != 0) {
671 perror(cmdname);
672 (void) fprintf(stderr,
673 gettext("%s: Failed to mount %s\n"), cmdname, arg);
674 return (-1);
675 }
676
677 return (0);
678 }
679
680 static int
validate_zfs_pool(char * arg,char * mountpoint)681 validate_zfs_pool(char *arg, char *mountpoint)
682 {
683 zfs_handle_t *zhp = NULL;
684 char mntopts[MNT_LINE_MAX] = { '\0' };
685 int rc = 0;
686
687 if ((g_zfs = libzfs_init()) == NULL) {
688 (void) fprintf(stderr, gettext("Internal error: failed to "
689 "initialize ZFS library\n"));
690 return (-1);
691 }
692
693 /* Try to open the dataset */
694 if ((zhp = zfs_open(g_zfs, arg,
695 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL)
696 return (-1);
697
698 /* perform the mount */
699 if (mount(zfs_get_name(zhp), mountpoint, MS_DATA|MS_OPTIONSTR|MS_RDONLY,
700 MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {
701 perror(cmdname);
702 (void) fprintf(stderr,
703 gettext("%s: Failed to mount %s\n"), cmdname, arg);
704 rc = -1;
705 }
706
707 validate_zfs_err_out:
708 if (zhp != NULL)
709 zfs_close(zhp);
710
711 libzfs_fini(g_zfs);
712 return (rc);
713 }
714
715 /*
716 * Return 0 if not zfs, or is zfs and have successfully constructed the
717 * boot argument; returns non-zero otherwise.
718 * At successful completion fpth contains pointer where mount point ends.
719 * NOTE: arg is supposed to be the resolved path
720 */
721 static int
get_zfs_bootfs_arg(const char * arg,const char ** fpth,int * is_zfs,char * bootfs_arg)722 get_zfs_bootfs_arg(const char *arg, const char ** fpth, int *is_zfs,
723 char *bootfs_arg)
724 {
725 zfs_handle_t *zhp = NULL;
726 zpool_handle_t *zpoolp = NULL;
727 FILE *mtabp = NULL;
728 struct mnttab mnt;
729 char *poolname = NULL;
730 char physpath[MAXPATHLEN];
731 char mntsp[ZFS_MAX_DATASET_NAME_LEN];
732 char bootfs[ZFS_MAX_DATASET_NAME_LEN];
733 int rc = 0;
734 size_t mntlen = 0;
735 size_t msz;
736 static char fmt[] = "-B zfs-bootfs=%s,bootpath=\"%s\"";
737
738 *fpth = arg;
739 *is_zfs = 0;
740
741 bzero(physpath, sizeof (physpath));
742 bzero(bootfs, sizeof (bootfs));
743
744 if ((mtabp = fopen(MNTTAB, "r")) == NULL) {
745 return (-1);
746 }
747
748 while (getmntent(mtabp, &mnt) == 0) {
749 if (strstr(arg, mnt.mnt_mountp) == arg &&
750 (msz = strlen(mnt.mnt_mountp)) > mntlen) {
751 mntlen = msz;
752 *is_zfs = strcmp(MNTTYPE_ZFS, mnt.mnt_fstype) == 0;
753 (void) strlcpy(mntsp, mnt.mnt_special, sizeof (mntsp));
754 }
755 }
756
757 (void) fclose(mtabp);
758
759 if (mntlen > 1)
760 *fpth += mntlen;
761
762 if (!*is_zfs)
763 return (0);
764
765 if ((g_zfs = libzfs_init()) == NULL)
766 return (-1);
767
768 /* Try to open the dataset */
769 if ((zhp = zfs_open(g_zfs, mntsp,
770 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_DATASET)) == NULL) {
771 (void) fprintf(stderr, gettext("Cannot open %s\n"), mntsp);
772 rc = -1;
773 goto validate_zfs_err_out;
774 }
775
776 (void) strlcpy(bootfs, mntsp, sizeof (bootfs));
777
778 if ((poolname = strtok(mntsp, "/")) == NULL) {
779 rc = -1;
780 goto validate_zfs_err_out;
781 }
782
783 if ((zpoolp = zpool_open(g_zfs, poolname)) == NULL) {
784 (void) fprintf(stderr, gettext("Cannot open %s\n"), poolname);
785 rc = -1;
786 goto validate_zfs_err_out;
787 }
788
789 if (zpool_get_physpath(zpoolp, physpath, sizeof (physpath)) != 0) {
790 (void) fprintf(stderr, gettext("Cannot find phys_path\n"));
791 rc = -1;
792 goto validate_zfs_err_out;
793 }
794
795 /*
796 * For the mirror physpath would contain the list of all
797 * bootable devices, pick up the first one.
798 */
799 (void) strtok(physpath, " ");
800 if (snprintf(bootfs_arg, BOOTARGS_MAX, fmt, bootfs, physpath) >=
801 BOOTARGS_MAX) {
802 rc = E2BIG;
803 (void) fprintf(stderr,
804 gettext("Boot arguments are too long\n"));
805 }
806
807 validate_zfs_err_out:
808 if (zhp != NULL)
809 zfs_close(zhp);
810
811 if (zpoolp != NULL)
812 zpool_close(zpoolp);
813
814 libzfs_fini(g_zfs);
815 return (rc);
816 }
817
818 /*
819 * Validate that the file exists, and is an ELF file.
820 * Returns 0 on success, -1 on failure.
821 */
822 static int
validate_unix(char * arg,int * mplen,int * is_zfs,char * bootfs_arg)823 validate_unix(char *arg, int *mplen, int *is_zfs, char *bootfs_arg)
824 {
825 const char *location;
826 int class, format;
827 unsigned char ident[EI_NIDENT];
828 char physpath[MAXPATHLEN];
829 int elffd = -1;
830 size_t sz;
831
832 if ((sz = resolvepath(arg, physpath, sizeof (physpath) - 1)) ==
833 (size_t)-1) {
834 (void) fprintf(stderr,
835 gettext("Cannot resolve path for %s: %s\n"),
836 arg, strerror(errno));
837 return (-1);
838 }
839 (void) strlcpy(arg, physpath, sz + 1);
840
841 if (strlen(arg) > MAXPATHLEN) {
842 (void) fprintf(stderr,
843 gettext("%s: New kernel name is too long\n"), cmdname);
844 return (-1);
845 }
846
847 if (strncmp(basename(arg), "unix", 4) != 0) {
848 (void) fprintf(stderr,
849 gettext("%s: %s: Kernel name must be unix\n"),
850 cmdname, arg);
851 return (-1);
852 }
853
854 if (get_zfs_bootfs_arg(arg, &location, is_zfs, bootfs_arg) != 0)
855 goto err_out;
856
857 *mplen = location - arg;
858
859 if (strstr(location, "/boot/platform") == location) {
860 /*
861 * Rebooting to failsafe.
862 * Clear bootfs_arg and is_zfs flag.
863 */
864 bootfs_arg[0] = 0;
865 *is_zfs = 0;
866 } else if (strstr(location, "/platform") != location) {
867 (void) fprintf(stderr,
868 gettext("%s: %s: No /platform in file name\n"),
869 cmdname, arg);
870 goto err_out;
871 }
872
873 if ((elffd = open64(arg, O_RDONLY)) < 0 ||
874 (pread64(elffd, ident, EI_NIDENT, 0) != EI_NIDENT)) {
875 (void) fprintf(stderr, "%s: %s: %s\n",
876 cmdname, arg, strerror(errno));
877 goto err_out;
878 }
879
880 class = ident[EI_CLASS];
881
882 if ((class != ELFCLASS32 && class != ELFCLASS64) ||
883 memcmp(&ident[EI_MAG0], ELFMAG, 4) != 0) {
884 (void) fprintf(stderr,
885 gettext("%s: %s: Not a valid ELF file\n"), cmdname, arg);
886 goto err_out;
887 }
888
889 format = ident[EI_DATA];
890
891 if (format != CUR_ELFDATA) {
892 (void) fprintf(stderr, gettext("%s: %s: Invalid data format\n"),
893 cmdname, arg);
894 goto err_out;
895 }
896
897 return (0);
898
899 err_out:
900 if (elffd >= 0) {
901 (void) close(elffd);
902 elffd = -1;
903 }
904 return (-1);
905 }
906
907 static int
halt_exec(const char * path,...)908 halt_exec(const char *path, ...)
909 {
910 pid_t pid;
911 int i;
912 int st;
913 const char *arg;
914 va_list vp;
915 const char *argv[256];
916
917 if ((pid = fork()) == -1) {
918 return (errno);
919 } else if (pid == 0) {
920 (void) fclose(stdout);
921 (void) fclose(stderr);
922
923 argv[0] = path;
924 i = 1;
925
926 va_start(vp, path);
927
928 do {
929 arg = va_arg(vp, const char *);
930 argv[i] = arg;
931 } while (arg != NULL &&
932 ++i != sizeof (argv) / sizeof (argv[0]));
933
934 va_end(vp);
935
936 (void) execve(path, (char * const *)argv, NULL);
937 (void) fprintf(stderr, gettext("Cannot execute %s: %s\n"),
938 path, strerror(errno));
939 exit(-1);
940 } else {
941 if (waitpid(pid, &st, 0) == pid &&
942 !WIFSIGNALED(st) && WIFEXITED(st))
943 st = WEXITSTATUS(st);
944 else
945 st = -1;
946 }
947 return (st);
948 }
949
950 /*
951 * Mount the specified BE.
952 *
953 * Upon success returns zero and copies bename string to mountpoint[]
954 */
955 static int
fastboot_bename(const char * bename,char * mountpoint,size_t mpsz)956 fastboot_bename(const char *bename, char *mountpoint, size_t mpsz)
957 {
958 int rc;
959
960 /*
961 * Attempt to unmount the BE first in case it's already mounted
962 * elsewhere.
963 */
964 (void) halt_exec(BEADM_PROG, "umount", bename, NULL);
965
966 if ((rc = halt_exec(BEADM_PROG, "mount", bename, FASTBOOT_MOUNTPOINT,
967 NULL)) != 0)
968 (void) fprintf(stderr,
969 gettext("%s: Unable to mount BE \"%s\" at %s\n"),
970 cmdname, bename, FASTBOOT_MOUNTPOINT);
971 else
972 (void) strlcpy(mountpoint, FASTBOOT_MOUNTPOINT, mpsz);
973
974 return (rc);
975 }
976
977 /*
978 * Returns 0 on successful parsing of the arguments;
979 * returns EINVAL on parsing failures that should abort the reboot attempt;
980 * returns other error code to fall back to regular reboot.
981 */
982 static int
parse_fastboot_args(char * bootargs_buf,size_t buf_size,int * is_dryrun,const char * bename)983 parse_fastboot_args(char *bootargs_buf, size_t buf_size,
984 int *is_dryrun, const char *bename)
985 {
986 char mountpoint[MAXPATHLEN];
987 char bootargs_saved[BOOTARGS_MAX];
988 char bootargs_scratch[BOOTARGS_MAX];
989 char bootfs_arg[BOOTARGS_MAX];
990 char unixfile[BOOTARGS_MAX];
991 char *head, *newarg;
992 int buflen; /* length of the bootargs_buf */
993 int mplen; /* length of the mount point */
994 int rootlen = 0; /* length of the root argument */
995 int unixlen = 0; /* length of the unix argument */
996 int off = 0; /* offset into the new boot argument */
997 int is_zfs = 0;
998 int rc = 0;
999
1000 bzero(mountpoint, sizeof (mountpoint));
1001
1002 /*
1003 * If argc is not 0, buflen is length of the argument being passed in;
1004 * else it is 0 as bootargs_buf has been initialized to all 0's.
1005 */
1006 buflen = strlen(bootargs_buf);
1007
1008 /* Save a copy of the original argument */
1009 bcopy(bootargs_buf, bootargs_saved, buflen);
1010 bzero(&bootargs_saved[buflen], sizeof (bootargs_saved) - buflen);
1011
1012 /* Save another copy to be used by strtok */
1013 bcopy(bootargs_buf, bootargs_scratch, buflen);
1014 bzero(&bootargs_scratch[buflen], sizeof (bootargs_scratch) - buflen);
1015 head = &bootargs_scratch[0];
1016
1017 /* Get the first argument */
1018 newarg = strtok(bootargs_scratch, " ");
1019
1020 /*
1021 * If this is a dry run request, verify that the drivers can handle
1022 * fast reboot.
1023 */
1024 if (newarg && strncasecmp(newarg, "dryrun", strlen("dryrun")) == 0) {
1025 *is_dryrun = 1;
1026 (void) system("/usr/sbin/devfsadm");
1027 }
1028
1029 /*
1030 * Always perform a dry run to identify all the drivers that
1031 * need to implement devo_reset().
1032 */
1033 if (uadmin(A_SHUTDOWN, AD_FASTREBOOT_DRYRUN,
1034 (uintptr_t)bootargs_saved) != 0) {
1035 (void) fprintf(stderr, gettext("%s: Not all drivers "
1036 "have implemented quiesce(9E)\n"
1037 "\tPlease see /var/adm/messages for drivers that haven't\n"
1038 "\timplemented quiesce(9E).\n"), cmdname);
1039 } else if (*is_dryrun) {
1040 (void) fprintf(stderr, gettext("%s: All drivers have "
1041 "implemented quiesce(9E)\n"), cmdname);
1042 }
1043
1044 /* Return if it is a true dry run. */
1045 if (*is_dryrun)
1046 return (rc);
1047
1048 #if defined(__i386)
1049 /* Read boot args from GRUB menu */
1050 if ((bootargs_buf[0] == 0 || isdigit(bootargs_buf[0])) &&
1051 bename == NULL) {
1052 /*
1053 * If no boot arguments are given, or a GRUB menu entry
1054 * number is provided, process the GRUB menu.
1055 */
1056 int entnum;
1057 if (bootargs_buf[0] == 0)
1058 entnum = GRUB_ENTRY_DEFAULT;
1059 else {
1060 errno = 0;
1061 entnum = strtoul(bootargs_buf, NULL, 10);
1062 rc = errno;
1063 }
1064
1065 if (rc == 0 && (rc = grub_get_boot_args(&fbarg, NULL,
1066 entnum)) == 0) {
1067 if (strlcpy(bootargs_buf, fbarg.gba_bootargs,
1068 buf_size) >= buf_size) {
1069 grub_cleanup_boot_args(&fbarg);
1070 bcopy(bootargs_saved, bootargs_buf, buf_size);
1071 rc = E2BIG;
1072 }
1073 }
1074 /* Failed to read GRUB menu, fall back to normal reboot */
1075 if (rc != 0) {
1076 (void) fprintf(stderr,
1077 gettext("%s: Failed to process GRUB menu "
1078 "entry for fast reboot.\n\t%s\n"),
1079 cmdname, grub_strerror(rc));
1080 (void) fprintf(stderr,
1081 gettext("%s: Falling back to regular reboot.\n"),
1082 cmdname);
1083 return (-1);
1084 }
1085 /* No need to process further */
1086 fbarg_used = &fbarg;
1087 fbarg_entnum = entnum;
1088 return (0);
1089 }
1090 #endif /* __i386 */
1091
1092 /* Zero out the boot argument buffer as we will reconstruct it */
1093 bzero(bootargs_buf, buf_size);
1094 bzero(bootfs_arg, sizeof (bootfs_arg));
1095 bzero(unixfile, sizeof (unixfile));
1096
1097 if (bename && (rc = fastboot_bename(bename, mountpoint,
1098 sizeof (mountpoint))) != 0)
1099 return (EINVAL);
1100
1101
1102 /*
1103 * If BE is not specified, look for disk argument to construct
1104 * mountpoint; if BE has been specified, mountpoint has already been
1105 * constructed.
1106 */
1107 if (newarg && newarg[0] != '-' && !bename) {
1108 int tmprc;
1109
1110 if ((tmprc = validate_disk(newarg, mountpoint)) == 0) {
1111 /*
1112 * The first argument is a valid root argument.
1113 * Get the next argument.
1114 */
1115 newarg = strtok(NULL, " ");
1116 rootlen = (newarg) ? (newarg - head) : buflen;
1117 (void) strlcpy(fastboot_mounted, mountpoint,
1118 sizeof (fastboot_mounted));
1119
1120 } else if (tmprc == -1) {
1121 /*
1122 * Not a disk argument. Use / as default root.
1123 */
1124 bcopy("/", mountpoint, 1);
1125 bzero(&mountpoint[1], sizeof (mountpoint) - 1);
1126 } else {
1127 /*
1128 * Disk argument, but not valid or not root.
1129 * Return failure.
1130 */
1131 return (EINVAL);
1132 }
1133 }
1134
1135 /*
1136 * Make mountpoint the first part of unixfile.
1137 * If there is not disk argument, and BE has not been specified,
1138 * mountpoint could be empty.
1139 */
1140 mplen = strlen(mountpoint);
1141 bcopy(mountpoint, unixfile, mplen);
1142
1143 /*
1144 * Look for unix argument
1145 */
1146 if (newarg && newarg[0] != '-') {
1147 bcopy(newarg, &unixfile[mplen], strlen(newarg));
1148 newarg = strtok(NULL, " ");
1149 rootlen = (newarg) ? (newarg - head) : buflen;
1150 } else if (mplen != 0) {
1151 /*
1152 * No unix argument, but mountpoint is not empty, use
1153 * /platform/i86pc/$ISADIR/kernel/unix as default.
1154 */
1155 char isa[20];
1156
1157 if (sysinfo(SI_ARCHITECTURE_64, isa, sizeof (isa)) != -1)
1158 (void) snprintf(&unixfile[mplen],
1159 sizeof (unixfile) - mplen,
1160 "/platform/i86pc/kernel/%s/unix", isa);
1161 else if (sysinfo(SI_ARCHITECTURE_32, isa, sizeof (isa)) != -1) {
1162 (void) snprintf(&unixfile[mplen],
1163 sizeof (unixfile) - mplen,
1164 "/platform/i86pc/kernel/unix");
1165 } else {
1166 (void) fprintf(stderr,
1167 gettext("%s: Unknown architecture"), cmdname);
1168 return (EINVAL);
1169 }
1170 }
1171
1172 /*
1173 * We now have the complete unix argument. Verify that it exists and
1174 * is an ELF file. Split the argument up into mountpoint and unix
1175 * portions again. This is necessary to handle cases where mountpoint
1176 * is specified on the command line as part of the unix argument,
1177 * such as this:
1178 * # reboot -f /.alt/platform/i86pc/kernel/amd64/unix
1179 */
1180 unixlen = strlen(unixfile);
1181 if (unixlen > 0) {
1182 if (validate_unix(unixfile, &mplen, &is_zfs,
1183 bootfs_arg) != 0) {
1184 /* Not a valid unix file */
1185 return (EINVAL);
1186 } else {
1187 int space = 0;
1188 /*
1189 * Construct boot argument.
1190 */
1191 unixlen = strlen(unixfile);
1192
1193 /*
1194 * mdep cannot start with space because bootadm
1195 * creates bogus menu entries if it does.
1196 */
1197 if (mplen > 0) {
1198 bcopy(unixfile, bootargs_buf, mplen);
1199 (void) strcat(bootargs_buf, " ");
1200 space = 1;
1201 }
1202 bcopy(&unixfile[mplen], &bootargs_buf[mplen + space],
1203 unixlen - mplen);
1204 (void) strcat(bootargs_buf, " ");
1205 off += unixlen + space + 1;
1206 }
1207 } else {
1208 /* Check to see if root is zfs */
1209 const char *dp;
1210 (void) get_zfs_bootfs_arg("/", &dp, &is_zfs, bootfs_arg);
1211 }
1212
1213 if (is_zfs && (buflen != 0 || bename != NULL)) {
1214 /* do not copy existing zfs boot args */
1215 if (strstr(&bootargs_saved[rootlen], "-B") == NULL ||
1216 strstr(&bootargs_saved[rootlen], "zfs-bootfs=") == NULL ||
1217 (strstr(&bootargs_saved[rootlen], "bootpath=") == NULL &&
1218 strstr(&bootargs_saved[rootlen], "diskdevid=") == NULL))
1219 /* LINTED E_SEC_SPRINTF_UNBOUNDED_COPY */
1220 off += sprintf(bootargs_buf + off, "%s ", bootfs_arg);
1221 }
1222
1223 /*
1224 * Copy the rest of the arguments
1225 */
1226 bcopy(&bootargs_saved[rootlen], &bootargs_buf[off], buflen - rootlen);
1227
1228 return (rc);
1229 }
1230
1231 #define MAXARGS 5
1232
1233 static void
do_archives_update(int do_fast_reboot)1234 do_archives_update(int do_fast_reboot)
1235 {
1236 int r, i = 0;
1237 pid_t pid;
1238 char *cmd_argv[MAXARGS];
1239
1240
1241 cmd_argv[i++] = "/sbin/bootadm";
1242 cmd_argv[i++] = "-ea";
1243 cmd_argv[i++] = "update_all";
1244 if (do_fast_reboot)
1245 cmd_argv[i++] = "fastboot";
1246 cmd_argv[i] = NULL;
1247
1248 r = posix_spawn(&pid, cmd_argv[0], NULL, NULL, cmd_argv, NULL);
1249
1250 /* if posix_spawn fails we emit a warning and continue */
1251
1252 if (r != 0)
1253 (void) fprintf(stderr, gettext("%s: WARNING, unable to start "
1254 "boot archive update\n"), cmdname);
1255 else
1256 while (waitpid(pid, NULL, 0) == -1 && errno == EINTR)
1257 ;
1258 }
1259
1260 int
main(int argc,char * argv[])1261 main(int argc, char *argv[])
1262 {
1263 int qflag = 0, needlog = 1, nosync = 0;
1264 int fast_reboot = 0;
1265 int prom_reboot = 0;
1266 uintptr_t mdep = NULL;
1267 int cmd, fcn, c, aval, r;
1268 const char *usage;
1269 const char *optstring;
1270 zoneid_t zoneid = getzoneid();
1271 int need_check_zones = 0;
1272 char bootargs_buf[BOOTARGS_MAX];
1273 char *bootargs_orig = NULL;
1274 char *bename = NULL;
1275
1276 const char * const resetting = "/etc/svc/volatile/resetting";
1277
1278 (void) setlocale(LC_ALL, "");
1279 (void) textdomain(TEXT_DOMAIN);
1280
1281 cmdname = basename(argv[0]);
1282
1283 if (strcmp(cmdname, "halt") == 0) {
1284 (void) audit_halt_setup(argc, argv);
1285 optstring = "dlnqy";
1286 usage = gettext("usage: %s [ -dlnqy ]\n");
1287 cmd = A_SHUTDOWN;
1288 fcn = AD_HALT;
1289 } else if (strcmp(cmdname, "poweroff") == 0) {
1290 (void) audit_halt_setup(argc, argv);
1291 optstring = "dlnqy";
1292 usage = gettext("usage: %s [ -dlnqy ]\n");
1293 cmd = A_SHUTDOWN;
1294 fcn = AD_POWEROFF;
1295 } else if (strcmp(cmdname, "reboot") == 0) {
1296 (void) audit_reboot_setup();
1297 #if defined(__i386)
1298 optstring = "dlnqpfe:";
1299 usage = gettext("usage: %s [ -dlnq(p|fe:) ] [ boot args ]\n");
1300 #else
1301 optstring = "dlnqfp";
1302 usage = gettext("usage: %s [ -dlnq(p|f) ] [ boot args ]\n");
1303 #endif
1304 cmd = A_SHUTDOWN;
1305 fcn = AD_BOOT;
1306 } else {
1307 (void) fprintf(stderr,
1308 gettext("%s: not installed properly\n"), cmdname);
1309 return (1);
1310 }
1311
1312 while ((c = getopt(argc, argv, optstring)) != EOF) {
1313 switch (c) {
1314 case 'd':
1315 if (zoneid == GLOBAL_ZONEID)
1316 cmd = A_DUMP;
1317 else {
1318 (void) fprintf(stderr,
1319 gettext("%s: -d only valid from global"
1320 " zone\n"), cmdname);
1321 return (1);
1322 }
1323 break;
1324 case 'l':
1325 needlog = 0;
1326 break;
1327 case 'n':
1328 nosync = 1;
1329 break;
1330 case 'q':
1331 qflag = 1;
1332 break;
1333 case 'y':
1334 /*
1335 * Option ignored for backwards compatibility.
1336 */
1337 break;
1338 case 'f':
1339 fast_reboot = 1;
1340 break;
1341 case 'p':
1342 prom_reboot = 1;
1343 break;
1344 #if defined(__i386)
1345 case 'e':
1346 bename = optarg;
1347 break;
1348 #endif
1349 default:
1350 /*
1351 * TRANSLATION_NOTE
1352 * Don't translate the words "halt" or "reboot"
1353 */
1354 (void) fprintf(stderr, usage, cmdname);
1355 return (1);
1356 }
1357 }
1358
1359 argc -= optind;
1360 argv += optind;
1361
1362 if (argc != 0) {
1363 if (fcn != AD_BOOT) {
1364 (void) fprintf(stderr, usage, cmdname);
1365 return (1);
1366 }
1367
1368 /* Gather the arguments into bootargs_buf. */
1369 if (gather_args(argv, bootargs_buf, sizeof (bootargs_buf)) !=
1370 0) {
1371 (void) fprintf(stderr,
1372 gettext("%s: Boot arguments too long.\n"), cmdname);
1373 return (1);
1374 }
1375
1376 bootargs_orig = strdup(bootargs_buf);
1377 mdep = (uintptr_t)bootargs_buf;
1378 } else {
1379 /*
1380 * Initialize it to 0 in case of fastboot, the buffer
1381 * will be used.
1382 */
1383 bzero(bootargs_buf, sizeof (bootargs_buf));
1384 }
1385
1386 if (geteuid() != 0) {
1387 (void) fprintf(stderr,
1388 gettext("%s: permission denied\n"), cmdname);
1389 goto fail;
1390 }
1391
1392 if (fast_reboot && prom_reboot) {
1393 (void) fprintf(stderr,
1394 gettext("%s: -p and -f are mutually exclusive\n"),
1395 cmdname);
1396 return (EINVAL);
1397 }
1398 /*
1399 * Check whether fast reboot is the default operating mode
1400 */
1401 if (fcn == AD_BOOT && !fast_reboot && !prom_reboot &&
1402 zoneid == GLOBAL_ZONEID) {
1403 fast_reboot = scf_is_fastboot_default();
1404
1405 }
1406
1407 if (bename && !fast_reboot) {
1408 (void) fprintf(stderr, gettext("%s: -e only valid with -f\n"),
1409 cmdname);
1410 return (EINVAL);
1411 }
1412
1413 #if defined(__sparc)
1414 if (fast_reboot) {
1415 fast_reboot = 2; /* need to distinguish each case */
1416 }
1417 #endif
1418
1419 /*
1420 * If fast reboot, do some sanity check on the argument
1421 */
1422 if (fast_reboot == 1) {
1423 int rc;
1424 int is_dryrun = 0;
1425
1426 if (zoneid != GLOBAL_ZONEID) {
1427 (void) fprintf(stderr,
1428 gettext("%s: Fast reboot only valid from global"
1429 " zone\n"), cmdname);
1430 return (EINVAL);
1431 }
1432
1433 rc = parse_fastboot_args(bootargs_buf, sizeof (bootargs_buf),
1434 &is_dryrun, bename);
1435
1436 /*
1437 * If dry run, or if arguments are invalid, return.
1438 */
1439 if (is_dryrun)
1440 return (rc);
1441 else if (rc == EINVAL)
1442 goto fail;
1443 else if (rc != 0)
1444 fast_reboot = 0;
1445
1446 /*
1447 * For all the other errors, we continue on in case user
1448 * user want to force fast reboot, or fall back to regular
1449 * reboot.
1450 */
1451 if (strlen(bootargs_buf) != 0)
1452 mdep = (uintptr_t)bootargs_buf;
1453 }
1454
1455 #if 0 /* For debugging */
1456 if (mdep != NULL)
1457 (void) fprintf(stderr, "mdep = %s\n", (char *)mdep);
1458 #endif
1459
1460 if (needlog) {
1461 char *user = getlogin();
1462 struct passwd *pw;
1463 char *tty;
1464
1465 openlog(cmdname, 0, LOG_AUTH);
1466 if (user == NULL && (pw = getpwuid(getuid())) != NULL)
1467 user = pw->pw_name;
1468 if (user == NULL)
1469 user = "root";
1470
1471 tty = ttyname(1);
1472
1473 if (tty == NULL)
1474 syslog(LOG_CRIT, "initiated by %s", user);
1475 else
1476 syslog(LOG_CRIT, "initiated by %s on %s", user, tty);
1477 }
1478
1479 /*
1480 * We must assume success and log it before auditd is terminated.
1481 */
1482 if (fcn == AD_BOOT)
1483 aval = audit_reboot_success();
1484 else
1485 aval = audit_halt_success();
1486
1487 if (aval == -1) {
1488 (void) fprintf(stderr,
1489 gettext("%s: can't turn off auditd\n"), cmdname);
1490 if (needlog)
1491 (void) sleep(5); /* Give syslogd time to record this */
1492 }
1493
1494 (void) signal(SIGHUP, SIG_IGN); /* for remote connections */
1495
1496 /*
1497 * We start to fork a bunch of zoneadms to halt any active zones.
1498 * This will proceed with halt in parallel until we call
1499 * check_zone_haltedness later on.
1500 */
1501 if (zoneid == GLOBAL_ZONEID && cmd != A_DUMP) {
1502 need_check_zones = halt_zones();
1503 }
1504
1505 #if defined(__i386)
1506 /* set new default entry in the GRUB entry */
1507 if (fbarg_entnum != GRUB_ENTRY_DEFAULT) {
1508 char buf[32];
1509 (void) snprintf(buf, sizeof (buf), "default=%u", fbarg_entnum);
1510 (void) halt_exec(BOOTADM_PROG, "set-menu", buf, NULL);
1511 }
1512 #endif /* __i386 */
1513
1514 /* if we're dumping, do the archive update here and don't defer it */
1515 if (cmd == A_DUMP && zoneid == GLOBAL_ZONEID && !nosync)
1516 do_archives_update(fast_reboot);
1517
1518 /*
1519 * If we're not forcing a crash dump, mark the system as quiescing for
1520 * smf(5)'s benefit, and idle the init process.
1521 */
1522 if (cmd != A_DUMP) {
1523 if (direct_init(PCDSTOP) == -1) {
1524 /*
1525 * TRANSLATION_NOTE
1526 * Don't translate the word "init"
1527 */
1528 (void) fprintf(stderr,
1529 gettext("%s: can't idle init\n"), cmdname);
1530 goto fail;
1531 }
1532
1533 if (creat(resetting, 0755) == -1)
1534 (void) fprintf(stderr,
1535 gettext("%s: could not create %s.\n"),
1536 cmdname, resetting);
1537 }
1538
1539 /*
1540 * Make sure we don't get stopped by a jobcontrol shell
1541 * once we start killing everybody.
1542 */
1543 (void) signal(SIGTSTP, SIG_IGN);
1544 (void) signal(SIGTTIN, SIG_IGN);
1545 (void) signal(SIGTTOU, SIG_IGN);
1546 (void) signal(SIGPIPE, SIG_IGN);
1547 (void) signal(SIGTERM, SIG_IGN);
1548
1549 /*
1550 * Try to stop gdm so X has a chance to return the screen and
1551 * keyboard to a sane state.
1552 */
1553 if (fast_reboot == 1 && stop_gdm() != 0) {
1554 (void) fprintf(stderr,
1555 gettext("%s: Falling back to regular reboot.\n"), cmdname);
1556 fast_reboot = 0;
1557 mdep = (uintptr_t)bootargs_orig;
1558 } else if (bootargs_orig) {
1559 free(bootargs_orig);
1560 }
1561
1562 if (cmd != A_DUMP) {
1563 /*
1564 * Stop all restarters so they do not try to restart services
1565 * that are terminated.
1566 */
1567 stop_restarters();
1568
1569 /*
1570 * Wait a little while for zones to shutdown.
1571 */
1572 if (need_check_zones) {
1573 check_zones_haltedness();
1574
1575 (void) fprintf(stderr,
1576 gettext("%s: Completing system halt.\n"),
1577 cmdname);
1578 }
1579 }
1580
1581 /*
1582 * If we're not forcing a crash dump, give everyone 5 seconds to
1583 * handle a SIGTERM and clean up properly.
1584 */
1585 if (cmd != A_DUMP) {
1586 int start, end, delta;
1587
1588 (void) kill(-1, SIGTERM);
1589 start = time(NULL);
1590
1591 if (zoneid == GLOBAL_ZONEID && !nosync)
1592 do_archives_update(fast_reboot);
1593
1594 end = time(NULL);
1595 delta = end - start;
1596 if (delta < 5)
1597 (void) sleep(5 - delta);
1598 }
1599
1600 (void) signal(SIGINT, SIG_IGN);
1601
1602 if (!qflag && !nosync) {
1603 struct utmpx wtmpx;
1604
1605 bzero(&wtmpx, sizeof (struct utmpx));
1606 (void) strcpy(wtmpx.ut_line, "~");
1607 (void) time(&wtmpx.ut_tv.tv_sec);
1608
1609 if (cmd == A_DUMP)
1610 (void) strcpy(wtmpx.ut_name, "crash dump");
1611 else
1612 (void) strcpy(wtmpx.ut_name, "shutdown");
1613
1614 (void) updwtmpx(WTMPX_FILE, &wtmpx);
1615 sync();
1616 }
1617
1618 if (cmd == A_DUMP && nosync != 0)
1619 (void) uadmin(A_DUMP, AD_NOSYNC, NULL);
1620
1621 if (fast_reboot)
1622 fcn = AD_FASTREBOOT;
1623
1624 if (uadmin(cmd, fcn, mdep) == -1)
1625 (void) fprintf(stderr, "%s: uadmin failed: %s\n",
1626 cmdname, strerror(errno));
1627 else
1628 (void) fprintf(stderr, "%s: uadmin unexpectedly returned 0\n",
1629 cmdname);
1630
1631 do {
1632 r = remove(resetting);
1633 } while (r != 0 && errno == EINTR);
1634
1635 if (r != 0 && errno != ENOENT)
1636 (void) fprintf(stderr, gettext("%s: could not remove %s.\n"),
1637 cmdname, resetting);
1638
1639 if (direct_init(PCRUN) == -1) {
1640 /*
1641 * TRANSLATION_NOTE
1642 * Don't translate the word "init"
1643 */
1644 (void) fprintf(stderr,
1645 gettext("%s: can't resume init\n"), cmdname);
1646 }
1647
1648 continue_restarters();
1649
1650 if (get_initpid() != -1)
1651 /* tell init to restate current level */
1652 (void) kill(get_initpid(), SIGHUP);
1653
1654 fail:
1655 if (fcn == AD_BOOT)
1656 (void) audit_reboot_fail();
1657 else
1658 (void) audit_halt_fail();
1659
1660 if (fast_reboot == 1) {
1661 if (bename) {
1662 (void) halt_exec(BEADM_PROG, "umount", bename, NULL);
1663
1664 } else if (strlen(fastboot_mounted) != 0) {
1665 (void) umount(fastboot_mounted);
1666 #if defined(__i386)
1667 } else if (fbarg_used != NULL) {
1668 grub_cleanup_boot_args(fbarg_used);
1669 #endif /* __i386 */
1670 }
1671 }
1672
1673 return (1);
1674 }
1675