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