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 GRUBADM_PROG    "/sbin/grubadm"
 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 static int
 947 exec_cmd(char * invoke, char * output)
 948 {
 949         FILE * cmd = popen(invoke, "r");
 950         if (! cmd) 
 951                 return 0;
 952         fgets(output, 512, cmd);
 953         if (! *output) {
 954                 pclose(cmd);
 955                 return 0;
 956         }
 957         output[strlen(output) - 2] = '\0';
 958         pclose(cmd);
 959         return 1;
 960 }
 961 
 962 /*
 963  * Mount the specified BE.
 964  *
 965  * Upon success returns zero and copies bename string to mountpoint[]
 966  */
 967 static int
 968 fastboot_bename(const char *bename, char *mountpoint, size_t mpsz)
 969 {
 970         int rc;
 971 
 972         /*
 973          * Attempt to unmount the BE first in case it's already mounted
 974          * elsewhere.
 975          */
 976         (void) halt_exec(BEADM_PROG, "umount", bename, NULL);
 977 
 978         if ((rc = halt_exec(BEADM_PROG, "mount", bename, FASTBOOT_MOUNTPOINT,
 979             NULL)) != 0)
 980                 (void) fprintf(stderr,
 981                     gettext("%s: Unable to mount BE \"%s\" at %s\n"),
 982                     cmdname, bename, FASTBOOT_MOUNTPOINT);
 983         else
 984                 (void) strlcpy(mountpoint, FASTBOOT_MOUNTPOINT, mpsz);
 985 
 986         return (rc);
 987 }
 988 
 989 /*
 990  * Returns 0 on successful parsing of the arguments;
 991  * returns EINVAL on parsing failures that should abort the reboot attempt;
 992  * returns other error code to fall back to regular reboot.
 993  */
 994 static int
 995 parse_fastboot_args(char *bootargs_buf, size_t buf_size,
 996     int *is_dryrun, const char *bename)
 997 {
 998         char mountpoint[MAXPATHLEN];
 999         char bootargs_saved[BOOTARGS_MAX];
1000         char bootargs_scratch[BOOTARGS_MAX];
1001         char bootfs_arg[BOOTARGS_MAX];
1002         char unixfile[BOOTARGS_MAX];
1003         char *head, *newarg;
1004         int buflen;             /* length of the bootargs_buf */
1005         int mplen;              /* length of the mount point */
1006         int rootlen = 0;        /* length of the root argument */
1007         int unixlen = 0;        /* length of the unix argument */
1008         int off = 0;            /* offset into the new boot argument */
1009         int is_zfs = 0;
1010         int rc = 0;
1011 
1012         bzero(mountpoint, sizeof (mountpoint));
1013 
1014         /*
1015          * If argc is not 0, buflen is length of the argument being passed in;
1016          * else it is 0 as bootargs_buf has been initialized to all 0's.
1017          */
1018         buflen = strlen(bootargs_buf);
1019 
1020         /* Save a copy of the original argument */
1021         bcopy(bootargs_buf, bootargs_saved, buflen);
1022         bzero(&bootargs_saved[buflen], sizeof (bootargs_saved) - buflen);
1023 
1024         /* Save another copy to be used by strtok */
1025         bcopy(bootargs_buf, bootargs_scratch, buflen);
1026         bzero(&bootargs_scratch[buflen], sizeof (bootargs_scratch) - buflen);
1027         head = &bootargs_scratch[0];
1028 
1029         /* Get the first argument */
1030         newarg = strtok(bootargs_scratch, " ");
1031 
1032         /*
1033          * If this is a dry run request, verify that the drivers can handle
1034          * fast reboot.
1035          */
1036         if (newarg && strncasecmp(newarg, "dryrun", strlen("dryrun")) == 0) {
1037                 *is_dryrun = 1;
1038                 (void) system("/usr/sbin/devfsadm");
1039         }
1040 
1041         /*
1042          * Always perform a dry run to identify all the drivers that
1043          * need to implement devo_reset().
1044          */
1045         if (uadmin(A_SHUTDOWN, AD_FASTREBOOT_DRYRUN,
1046             (uintptr_t)bootargs_saved) != 0) {
1047                 (void) fprintf(stderr, gettext("%s: Not all drivers "
1048                     "have implemented quiesce(9E)\n"
1049                     "\tPlease see /var/adm/messages for drivers that haven't\n"
1050                     "\timplemented quiesce(9E).\n"), cmdname);
1051         } else if (*is_dryrun) {
1052                 (void) fprintf(stderr, gettext("%s: All drivers have "
1053                     "implemented quiesce(9E)\n"), cmdname);
1054         }
1055 
1056         /* Return if it is a true dry run. */
1057         if (*is_dryrun)
1058                 return (rc);
1059 
1060 #if defined(__i386)
1061         /* Read boot args from GRUB menu */
1062         if ((bootargs_buf[0] == 0 || isdigit(bootargs_buf[0])) &&
1063             bename == NULL) {
1064                 /*
1065                  * If no boot arguments are given, or a GRUB menu entry
1066                  * number is provided, process the GRUB menu.
1067                  */
1068                 int entnum;
1069                 if (bootargs_buf[0] == 0)
1070                         entnum = GRUB_ENTRY_DEFAULT;
1071                 else {
1072                         errno = 0;
1073                         entnum = strtoul(bootargs_buf, NULL, 10);
1074                         rc = errno;
1075                 }
1076 
1077                 if (rc == 0 && (rc = exec_cmd("/sbin/grubadm --number -1 --get-opts",
1078                                 fbarg.gba_bootargs)) == 0) {
1079                         if (strlcpy(bootargs_buf, fbarg.gba_bootargs,
1080                             buf_size) >= buf_size) {
1081                                 grub_cleanup_boot_args(&fbarg);
1082                                 bcopy(bootargs_saved, bootargs_buf, buf_size);
1083                                 rc = E2BIG;
1084                         }
1085                 }
1086                 /* Failed to read GRUB menu, fall back to normal reboot */
1087                 if (rc != 0) {
1088                         (void) fprintf(stderr,
1089                             gettext("%s: Failed to process GRUB menu "
1090                             "entry for fast reboot.\n\t%s\n"),
1091                             cmdname, grub_strerror(rc));
1092                         (void) fprintf(stderr,
1093                             gettext("%s: Falling back to regular reboot.\n"),
1094                             cmdname);
1095                         return (-1);
1096                 }
1097                 /* No need to process further */
1098                 fbarg_used = &fbarg;
1099                 fbarg_entnum = entnum;
1100                 return (0);
1101         }
1102 #endif  /* __i386 */
1103 
1104         /* Zero out the boot argument buffer as we will reconstruct it */
1105         bzero(bootargs_buf, buf_size);
1106         bzero(bootfs_arg, sizeof (bootfs_arg));
1107         bzero(unixfile, sizeof (unixfile));
1108 
1109         if (bename && (rc = fastboot_bename(bename, mountpoint,
1110             sizeof (mountpoint))) != 0)
1111                 return (EINVAL);
1112 
1113 
1114         /*
1115          * If BE is not specified, look for disk argument to construct
1116          * mountpoint; if BE has been specified, mountpoint has already been
1117          * constructed.
1118          */
1119         if (newarg && newarg[0] != '-' && !bename) {
1120                 int tmprc;
1121 
1122                 if ((tmprc = validate_disk(newarg, mountpoint)) == 0) {
1123                         /*
1124                          * The first argument is a valid root argument.
1125                          * Get the next argument.
1126                          */
1127                         newarg = strtok(NULL, " ");
1128                         rootlen = (newarg) ? (newarg - head) : buflen;
1129                         (void) strlcpy(fastboot_mounted, mountpoint,
1130                             sizeof (fastboot_mounted));
1131 
1132                 } else if (tmprc == -1) {
1133                         /*
1134                          * Not a disk argument.  Use / as default root.
1135                          */
1136                         bcopy("/", mountpoint, 1);
1137                         bzero(&mountpoint[1], sizeof (mountpoint) - 1);
1138                 } else {
1139                         /*
1140                          * Disk argument, but not valid or not root.
1141                          * Return failure.
1142                          */
1143                         return (EINVAL);
1144                 }
1145         }
1146 
1147         /*
1148          * Make mountpoint the first part of unixfile.
1149          * If there is not disk argument, and BE has not been specified,
1150          * mountpoint could be empty.
1151          */
1152         mplen = strlen(mountpoint);
1153         bcopy(mountpoint, unixfile, mplen);
1154 
1155         /*
1156          * Look for unix argument
1157          */
1158         if (newarg && newarg[0] != '-') {
1159                 bcopy(newarg, &unixfile[mplen], strlen(newarg));
1160                 newarg = strtok(NULL, " ");
1161                 rootlen = (newarg) ? (newarg - head) : buflen;
1162         } else if (mplen != 0) {
1163                 /*
1164                  * No unix argument, but mountpoint is not empty, use
1165                  * /platform/i86pc/$ISADIR/kernel/unix as default.
1166                  */
1167                 char isa[20];
1168 
1169                 if (sysinfo(SI_ARCHITECTURE_64, isa, sizeof (isa)) != -1)
1170                         (void) snprintf(&unixfile[mplen],
1171                             sizeof (unixfile) - mplen,
1172                             "/platform/i86pc/kernel/%s/unix", isa);
1173                 else if (sysinfo(SI_ARCHITECTURE_32, isa, sizeof (isa)) != -1) {
1174                         (void) snprintf(&unixfile[mplen],
1175                             sizeof (unixfile) - mplen,
1176                             "/platform/i86pc/kernel/unix");
1177                 } else {
1178                         (void) fprintf(stderr,
1179                             gettext("%s: Unknown architecture"), cmdname);
1180                         return (EINVAL);
1181                 }
1182         }
1183 
1184         /*
1185          * We now have the complete unix argument.  Verify that it exists and
1186          * is an ELF file.  Split the argument up into mountpoint and unix
1187          * portions again.  This is necessary to handle cases where mountpoint
1188          * is specified on the command line as part of the unix argument,
1189          * such as this:
1190          *      # reboot -f /.alt/platform/i86pc/kernel/amd64/unix
1191          */
1192         unixlen = strlen(unixfile);
1193         if (unixlen > 0) {
1194                 if (validate_unix(unixfile, &mplen, &is_zfs,
1195                     bootfs_arg) != 0) {
1196                         /* Not a valid unix file */
1197                         return (EINVAL);
1198                 } else {
1199                         int space = 0;
1200                         /*
1201                          * Construct boot argument.
1202                          */
1203                         unixlen = strlen(unixfile);
1204 
1205                         /*
1206                          * mdep cannot start with space because bootadm
1207                          * creates bogus menu entries if it does.
1208                          */
1209                         if (mplen > 0) {
1210                                 bcopy(unixfile, bootargs_buf, mplen);
1211                                 (void) strcat(bootargs_buf, " ");
1212                                 space = 1;
1213                         }
1214                         bcopy(&unixfile[mplen], &bootargs_buf[mplen + space],
1215                             unixlen - mplen);
1216                         (void) strcat(bootargs_buf, " ");
1217                         off += unixlen + space + 1;
1218                 }
1219         } else {
1220                 /* Check to see if root is zfs */
1221                 const char      *dp;
1222                 (void) get_zfs_bootfs_arg("/", &dp, &is_zfs, bootfs_arg);
1223         }
1224 
1225         if (is_zfs && (buflen != 0 || bename != NULL))  {
1226                 /* LINTED E_SEC_SPRINTF_UNBOUNDED_COPY */
1227                 off += sprintf(bootargs_buf + off, "%s ", bootfs_arg);
1228         }
1229 
1230         /*
1231          * Copy the rest of the arguments
1232          */
1233         bcopy(&bootargs_saved[rootlen], &bootargs_buf[off], buflen - rootlen);
1234 
1235         return (rc);
1236 }
1237 
1238 #define MAXARGS         5
1239 
1240 static void
1241 do_archives_update(int do_fast_reboot)
1242 {
1243         int     r, i = 0;
1244         pid_t   pid;
1245         char    *cmd_argv[MAXARGS];
1246 
1247 
1248         cmd_argv[i++] = "/sbin/bootadm";
1249         cmd_argv[i++] = "-ea";
1250         cmd_argv[i++] = "update_all";
1251         if (do_fast_reboot)
1252                 cmd_argv[i++] = "fastboot";
1253         cmd_argv[i] = NULL;
1254 
1255         r = posix_spawn(&pid, cmd_argv[0], NULL, NULL, cmd_argv, NULL);
1256 
1257         /* if posix_spawn fails we emit a warning and continue */
1258 
1259         if (r != 0)
1260                 (void) fprintf(stderr, gettext("%s: WARNING, unable to start "
1261                     "boot archive update\n"), cmdname);
1262         else
1263                 while (waitpid(pid, NULL, 0) == -1 && errno == EINTR)
1264                         ;
1265 }
1266 
1267 int
1268 main(int argc, char *argv[])
1269 {
1270         char *ttyn = ttyname(STDERR_FILENO);
1271 
1272         int qflag = 0, needlog = 1, nosync = 0;
1273         int fast_reboot = 0;
1274         int prom_reboot = 0;
1275         uintptr_t mdep = NULL;
1276         int cmd, fcn, c, aval, r;
1277         const char *usage;
1278         const char *optstring;
1279         zoneid_t zoneid = getzoneid();
1280         int need_check_zones = 0;
1281         char bootargs_buf[BOOTARGS_MAX];
1282         char *bootargs_orig = NULL;
1283         char *bename = NULL;
1284 
1285         const char * const resetting = "/etc/svc/volatile/resetting";
1286 
1287         (void) setlocale(LC_ALL, "");
1288         (void) textdomain(TEXT_DOMAIN);
1289 
1290         cmdname = basename(argv[0]);
1291 
1292         if (strcmp(cmdname, "halt") == 0) {
1293                 (void) audit_halt_setup(argc, argv);
1294                 optstring = "dlnqy";
1295                 usage = gettext("usage: %s [ -dlnqy ]\n");
1296                 cmd = A_SHUTDOWN;
1297                 fcn = AD_HALT;
1298         } else if (strcmp(cmdname, "poweroff") == 0) {
1299                 (void) audit_halt_setup(argc, argv);
1300                 optstring = "dlnqy";
1301                 usage = gettext("usage: %s [ -dlnqy ]\n");
1302                 cmd = A_SHUTDOWN;
1303                 fcn = AD_POWEROFF;
1304         } else if (strcmp(cmdname, "reboot") == 0) {
1305                 (void) audit_reboot_setup();
1306 #if defined(__i386)
1307                 optstring = "dlnqpfe:";
1308                 usage = gettext("usage: %s [ -dlnq(p|fe:) ] [ boot args ]\n");
1309 #else
1310                 optstring = "dlnqfp";
1311                 usage = gettext("usage: %s [ -dlnq(p|f) ] [ boot args ]\n");
1312 #endif
1313                 cmd = A_SHUTDOWN;
1314                 fcn = AD_BOOT;
1315         } else {
1316                 (void) fprintf(stderr,
1317                     gettext("%s: not installed properly\n"), cmdname);
1318                 return (1);
1319         }
1320 
1321         while ((c = getopt(argc, argv, optstring)) != EOF) {
1322                 switch (c) {
1323                 case 'd':
1324                         if (zoneid == GLOBAL_ZONEID)
1325                                 cmd = A_DUMP;
1326                         else {
1327                                 (void) fprintf(stderr,
1328                                     gettext("%s: -d only valid from global"
1329                                     " zone\n"), cmdname);
1330                                 return (1);
1331                         }
1332                         break;
1333                 case 'l':
1334                         needlog = 0;
1335                         break;
1336                 case 'n':
1337                         nosync = 1;
1338                         break;
1339                 case 'q':
1340                         qflag = 1;
1341                         break;
1342                 case 'y':
1343                         ttyn = NULL;
1344                         break;
1345                 case 'f':
1346                         fast_reboot = 1;
1347                         break;
1348                 case 'p':
1349                         prom_reboot = 1;
1350                         break;
1351 #if defined(__i386)
1352                 case 'e':
1353                         bename = optarg;
1354                         break;
1355 #endif
1356                 default:
1357                         /*
1358                          * TRANSLATION_NOTE
1359                          * Don't translate the words "halt" or "reboot"
1360                          */
1361                         (void) fprintf(stderr, usage, cmdname);
1362                         return (1);
1363                 }
1364         }
1365 
1366         argc -= optind;
1367         argv += optind;
1368 
1369         if (argc != 0) {
1370                 if (fcn != AD_BOOT) {
1371                         (void) fprintf(stderr, usage, cmdname);
1372                         return (1);
1373                 }
1374 
1375                 /* Gather the arguments into bootargs_buf. */
1376                 if (gather_args(argv, bootargs_buf, sizeof (bootargs_buf)) !=
1377                     0) {
1378                         (void) fprintf(stderr,
1379                             gettext("%s: Boot arguments too long.\n"), cmdname);
1380                         return (1);
1381                 }
1382 
1383                 bootargs_orig = strdup(bootargs_buf);
1384                 mdep = (uintptr_t)bootargs_buf;
1385         } else {
1386                 /*
1387                  * Initialize it to 0 in case of fastboot, the buffer
1388                  * will be used.
1389                  */
1390                 bzero(bootargs_buf, sizeof (bootargs_buf));
1391         }
1392 
1393         if (geteuid() != 0) {
1394                 (void) fprintf(stderr,
1395                     gettext("%s: permission denied\n"), cmdname);
1396                 goto fail;
1397         }
1398 
1399         if (fast_reboot && prom_reboot) {
1400                 (void) fprintf(stderr,
1401                     gettext("%s: -p and -f are mutually exclusive\n"),
1402                     cmdname);
1403                 return (EINVAL);
1404         }
1405         /*
1406          * Check whether fast reboot is the default operating mode
1407          */
1408         if (fcn == AD_BOOT && !fast_reboot && !prom_reboot &&
1409             zoneid == GLOBAL_ZONEID) {
1410                 fast_reboot = scf_is_fastboot_default();
1411 
1412         }
1413 
1414         if (bename && !fast_reboot)     {
1415                 (void) fprintf(stderr, gettext("%s: -e only valid with -f\n"),
1416                     cmdname);
1417                 return (EINVAL);
1418         }
1419 
1420 #if defined(__sparc)
1421         if (fast_reboot) {
1422                 fast_reboot = 2;        /* need to distinguish each case */
1423         }
1424 #endif
1425 
1426         /*
1427          * If fast reboot, do some sanity check on the argument
1428          */
1429         if (fast_reboot == 1) {
1430                 int rc;
1431                 int is_dryrun = 0;
1432 
1433                 if (zoneid != GLOBAL_ZONEID)    {
1434                         (void) fprintf(stderr,
1435                             gettext("%s: Fast reboot only valid from global"
1436                             " zone\n"), cmdname);
1437                         return (EINVAL);
1438                 }
1439 
1440                 rc = parse_fastboot_args(bootargs_buf, sizeof (bootargs_buf),
1441                     &is_dryrun, bename);
1442 
1443                 /*
1444                  * If dry run, or if arguments are invalid, return.
1445                  */
1446                 if (is_dryrun)
1447                         return (rc);
1448                 else if (rc == EINVAL)
1449                         goto fail;
1450                 else if (rc != 0)
1451                         fast_reboot = 0;
1452 
1453                 /*
1454                  * For all the other errors, we continue on in case user
1455                  * user want to force fast reboot, or fall back to regular
1456                  * reboot.
1457                  */
1458                 if (strlen(bootargs_buf) != 0)
1459                         mdep = (uintptr_t)bootargs_buf;
1460         }
1461 
1462 #if 0   /* For debugging */
1463         if (mdep != NULL)
1464                 (void) fprintf(stderr, "mdep = %s\n", (char *)mdep);
1465 #endif
1466 
1467         if (fcn != AD_BOOT && ttyn != NULL &&
1468             strncmp(ttyn, "/dev/term/", strlen("/dev/term/")) == 0) {
1469                 /*
1470                  * TRANSLATION_NOTE
1471                  * Don't translate ``halt -y''
1472                  */
1473                 (void) fprintf(stderr,
1474                     gettext("%s: dangerous on a dialup;"), cmdname);
1475                 (void) fprintf(stderr,
1476                     gettext("use ``%s -y'' if you are really sure\n"), cmdname);
1477                 goto fail;
1478         }
1479 
1480         if (needlog) {
1481                 char *user = getlogin();
1482                 struct passwd *pw;
1483                 char *tty;
1484 
1485                 openlog(cmdname, 0, LOG_AUTH);
1486                 if (user == NULL && (pw = getpwuid(getuid())) != NULL)
1487                         user = pw->pw_name;
1488                 if (user == NULL)
1489                         user = "root";
1490 
1491                 tty = ttyname(1);
1492 
1493                 if (tty == NULL)
1494                         syslog(LOG_CRIT, "initiated by %s", user);
1495                 else
1496                         syslog(LOG_CRIT, "initiated by %s on %s", user, tty);
1497         }
1498 
1499         /*
1500          * We must assume success and log it before auditd is terminated.
1501          */
1502         if (fcn == AD_BOOT)
1503                 aval = audit_reboot_success();
1504         else
1505                 aval = audit_halt_success();
1506 
1507         if (aval == -1) {
1508                 (void) fprintf(stderr,
1509                     gettext("%s: can't turn off auditd\n"), cmdname);
1510                 if (needlog)
1511                         (void) sleep(5); /* Give syslogd time to record this */
1512         }
1513 
1514         (void) signal(SIGHUP, SIG_IGN); /* for remote connections */
1515 
1516         /*
1517          * We start to fork a bunch of zoneadms to halt any active zones.
1518          * This will proceed with halt in parallel until we call
1519          * check_zone_haltedness later on.
1520          */
1521         if (zoneid == GLOBAL_ZONEID && cmd != A_DUMP) {
1522                 need_check_zones = halt_zones();
1523         }
1524 
1525 #if defined(__i386)
1526         /* set new default entry in the GRUB entry */
1527         if (fbarg_entnum != GRUB_ENTRY_DEFAULT) {
1528                 char buf[32];
1529                 (void) snprintf(buf, sizeof (buf), "--set-default %u", fbarg_entnum);
1530                 (void) halt_exec(GRUBADM_PROG, " ", buf, NULL);
1531         }
1532 #endif  /* __i386 */
1533 
1534         /* if we're dumping, do the archive update here and don't defer it */
1535         if (cmd == A_DUMP && zoneid == GLOBAL_ZONEID && !nosync)
1536                 do_archives_update(fast_reboot);
1537 
1538         /*
1539          * If we're not forcing a crash dump, mark the system as quiescing for
1540          * smf(5)'s benefit, and idle the init process.
1541          */
1542         if (cmd != A_DUMP) {
1543                 if (direct_init(PCDSTOP) == -1) {
1544                         /*
1545                          * TRANSLATION_NOTE
1546                          * Don't translate the word "init"
1547                          */
1548                         (void) fprintf(stderr,
1549                             gettext("%s: can't idle init\n"), cmdname);
1550                         goto fail;
1551                 }
1552 
1553                 if (creat(resetting, 0755) == -1)
1554                         (void) fprintf(stderr,
1555                             gettext("%s: could not create %s.\n"),
1556                             cmdname, resetting);
1557         }
1558 
1559         /*
1560          * Make sure we don't get stopped by a jobcontrol shell
1561          * once we start killing everybody.
1562          */
1563         (void) signal(SIGTSTP, SIG_IGN);
1564         (void) signal(SIGTTIN, SIG_IGN);
1565         (void) signal(SIGTTOU, SIG_IGN);
1566         (void) signal(SIGPIPE, SIG_IGN);
1567         (void) signal(SIGTERM, SIG_IGN);
1568 
1569         /*
1570          * Try to stop gdm so X has a chance to return the screen and
1571          * keyboard to a sane state.
1572          */
1573         if (fast_reboot == 1 && stop_gdm() != 0) {
1574                 (void) fprintf(stderr,
1575                     gettext("%s: Falling back to regular reboot.\n"), cmdname);
1576                 fast_reboot = 0;
1577                 mdep = (uintptr_t)bootargs_orig;
1578         } else if (bootargs_orig) {
1579                 free(bootargs_orig);
1580         }
1581 
1582         if (cmd != A_DUMP) {
1583                 /*
1584                  * Stop all restarters so they do not try to restart services
1585                  * that are terminated.
1586                  */
1587                 stop_restarters();
1588 
1589                 /*
1590                  * Wait a little while for zones to shutdown.
1591                  */
1592                 if (need_check_zones) {
1593                         check_zones_haltedness();
1594 
1595                         (void) fprintf(stderr,
1596                             gettext("%s: Completing system halt.\n"),
1597                             cmdname);
1598                 }
1599         }
1600 
1601         /*
1602          * If we're not forcing a crash dump, give everyone 5 seconds to
1603          * handle a SIGTERM and clean up properly.
1604          */
1605         if (cmd != A_DUMP) {
1606                 int     start, end, delta;
1607 
1608                 (void) kill(-1, SIGTERM);
1609                 start = time(NULL);
1610 
1611                 if (zoneid == GLOBAL_ZONEID && !nosync)
1612                         do_archives_update(fast_reboot);
1613 
1614                 end = time(NULL);
1615                 delta = end - start;
1616                 if (delta < 5)
1617                         (void) sleep(5 - delta);
1618         }
1619 
1620         (void) signal(SIGINT, SIG_IGN);
1621 
1622         if (!qflag && !nosync) {
1623                 struct utmpx wtmpx;
1624 
1625                 bzero(&wtmpx, sizeof (struct utmpx));
1626                 (void) strcpy(wtmpx.ut_line, "~");
1627                 (void) time(&wtmpx.ut_tv.tv_sec);
1628 
1629                 if (cmd == A_DUMP)
1630                         (void) strcpy(wtmpx.ut_name, "crash dump");
1631                 else
1632                         (void) strcpy(wtmpx.ut_name, "shutdown");
1633 
1634                 (void) updwtmpx(WTMPX_FILE, &wtmpx);
1635                 sync();
1636         }
1637 
1638         if (cmd == A_DUMP && nosync != 0)
1639                 (void) uadmin(A_DUMP, AD_NOSYNC, NULL);
1640 
1641         if (fast_reboot)
1642                 fcn = AD_FASTREBOOT;
1643 
1644         if (uadmin(cmd, fcn, mdep) == -1)
1645                 (void) fprintf(stderr, "%s: uadmin failed: %s\n",
1646                     cmdname, strerror(errno));
1647         else
1648                 (void) fprintf(stderr, "%s: uadmin unexpectedly returned 0\n",
1649                     cmdname);
1650 
1651         do {
1652                 r = remove(resetting);
1653         } while (r != 0 && errno == EINTR);
1654 
1655         if (r != 0 && errno != ENOENT)
1656                 (void) fprintf(stderr, gettext("%s: could not remove %s.\n"),
1657                     cmdname, resetting);
1658 
1659         if (direct_init(PCRUN) == -1) {
1660                 /*
1661                  * TRANSLATION_NOTE
1662                  * Don't translate the word "init"
1663                  */
1664                 (void) fprintf(stderr,
1665                     gettext("%s: can't resume init\n"), cmdname);
1666         }
1667 
1668         continue_restarters();
1669 
1670         if (get_initpid() != -1)
1671                 /* tell init to restate current level */
1672                 (void) kill(get_initpid(), SIGHUP);
1673 
1674 fail:
1675         if (fcn == AD_BOOT)
1676                 (void) audit_reboot_fail();
1677         else
1678                 (void) audit_halt_fail();
1679 
1680         if (fast_reboot == 1) {
1681                 if (bename) {
1682                         (void) halt_exec(BEADM_PROG, "umount", bename, NULL);
1683 
1684                 } else if (strlen(fastboot_mounted) != 0) {
1685                         (void) umount(fastboot_mounted);
1686 #if defined(__i386)
1687                 } else if (fbarg_used != NULL) {
1688                         grub_cleanup_boot_args(fbarg_used);
1689 #endif  /* __i386 */
1690                 }
1691         }
1692 
1693         return (1);
1694 }