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