usr/src/cmd/boot/bootadm/bootadm_loader.c

   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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright 2012 Milan Jurik. All rights reserved.
  24  */
  25
  26 /*
  27  * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
  28  * Copyright 2016 Toomas Soome <tsoome@me.com>
  29  */
  30
  31 /*
  32  * Loader menu management.
  33  */
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <wchar.h>
  39 #include <errno.h>
  40 #include <limits.h>
  41 #include <alloca.h>
  42 #include <unistd.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45 #include <sys/queue.h>
  46 #include <libbe.h>
  47 #include <ficl.h>
  48 #include <ficlplatform/emu.h>
  49
  50 #include "bootadm.h"
  51
  52 extern int bam_rootlen;
  53 extern int bam_alt_root;
  54 extern char *rootbuf;
  55 extern char *bam_root;
  56
  57 #define BOOT_DIR        "/boot"
  58 #define CONF_DIR        BOOT_DIR "/conf.d"
  59 #define MENU            BOOT_DIR "/menu.lst"
  60 #define TRANSIENT       BOOT_DIR "/transient.conf"
  61 #define XEN_CONFIG      CONF_DIR "/xen"
  62
  63 struct menu_entry {
  64         int entry;
  65         char *title;
  66         char *bootfs;
  67         STAILQ_ENTRY(menu_entry) next;
  68 };
  69 STAILQ_HEAD(menu_lst, menu_entry);
  70
  71 static error_t set_option(struct menu_lst *, char *, char *);
  72 static error_t list_entry(struct menu_lst *, char *, char *);
  73 static error_t update_entry(struct menu_lst *, char *, char *);
  74 static error_t update_temp(struct menu_lst *, char *, char *);
  75 static error_t list_setting(struct menu_lst *menu, char *, char *);
  76 static error_t disable_hyper(struct menu_lst *, char *, char *);
  77 static error_t enable_hyper(struct menu_lst *, char *, char *);
  78
  79 /* Menu related sub commands */
  80 static subcmd_defn_t menu_subcmds[] = {
  81         { "set_option", OPT_ABSENT, set_option, 0 },            /* PUB */
  82         { "list_entry", OPT_OPTIONAL, list_entry, 1 },          /* PUB */
  83         { "update_entry", OPT_REQ, update_entry, 0 },           /* menu */
  84         { "update_temp", OPT_OPTIONAL, update_temp, 0 },        /* reboot */
  85         { "list_setting", OPT_OPTIONAL, list_setting, 1 },      /* menu */
  86         { "disable_hypervisor", OPT_ABSENT, disable_hyper, 0 }, /* menu */
  87         { "enable_hypervisor", OPT_ABSENT, enable_hyper, 0 },   /* menu */
  88         { NULL, 0, NULL, 0 }                            /* must be last */
  89 };
  90
  91 #define NUM_COLS        (4)
  92 struct col_info {
  93         const char *col_name;
  94         size_t width;
  95 };
  96
  97 /*
  98  * all columns output format
  99  */
 100 struct hdr_info {
 101         struct col_info cols[NUM_COLS];
 102 };
 103
 104 static void
 105 print_hdr(struct hdr_info *hdr_info)
 106 {
 107         boolean_t first = B_TRUE;
 108         size_t i;
 109
 110         for (i = 0; i < NUM_COLS; i++) {
 111                 struct col_info *col_info = &hdr_info->cols[i];
 112                 const char *name = col_info->col_name;
 113                 size_t width = col_info->width;
 114
 115                 if (name == NULL)
 116                         continue;
 117
 118                 if (first) {
 119                         (void) printf("%-*s", width, name);
 120                         first = B_FALSE;
 121                 } else
 122                         (void) printf(" %-*s", width, name);
 123         }
 124         (void) putchar('\n');
 125 }
 126
 127 static void
 128 init_hdr_cols(struct hdr_info *hdr)
 129 {
 130         struct col_info *col = hdr->cols;
 131         size_t i;
 132
 133         col[0].col_name = _("Index");
 134         col[1].col_name = _("Default");
 135         col[2].col_name = _("Dataset");
 136         col[3].col_name = _("Menu");
 137         col[4].col_name = NULL;
 138
 139         for (i = 0; i < NUM_COLS; i++) {
 140                 const char *name = col[i].col_name;
 141                 col[i].width = 0;
 142
 143                 if (name != NULL) {
 144                         wchar_t wname[128];
 145                         size_t sz = mbstowcs(wname, name, sizeof (wname) /
 146                             sizeof (wchar_t));
 147                         if (sz > 0) {
 148                                 int wcsw = wcswidth(wname, sz);
 149                                 if (wcsw > 0)
 150                                         col[i].width = wcsw;
 151                                 else
 152                                         col[i].width = sz;
 153                         } else {
 154                                 col[i].width = strlen(name);
 155                         }
 156                 }
 157         }
 158 }
 159
 160 static void
 161 count_widths(struct hdr_info *hdr, struct menu_lst *menu)
 162 {
 163         size_t len[NUM_COLS];
 164         struct menu_entry *entry;
 165         int i;
 166
 167         for (i = 0; i < NUM_COLS; i++)
 168                 len[i] = hdr->cols[i].width + 1;
 169
 170         STAILQ_FOREACH(entry, menu, next) {
 171                 size_t bootfs_len = strlen(entry->bootfs);
 172                 if (bootfs_len > len[2])
 173                         len[2] = bootfs_len + 1;
 174         }
 175
 176         for (i = 0; i < NUM_COLS; i++)
 177                 hdr->cols[i].width = len[i];
 178 }
 179
 180 static void
 181 print_menu_nodes(boolean_t parsable, struct hdr_info *hdr,
 182     struct menu_lst *menu)
 183 {
 184         struct menu_entry  *entry;
 185         int i = -1;
 186         int rv;
 187         be_node_list_t *be_nodes, *be_node;
 188
 189         rv = be_list(NULL, &be_nodes);
 190         if (rv != BE_SUCCESS)
 191                 return;
 192
 193         STAILQ_FOREACH(entry, menu, next) {
 194                 i++;
 195                 for (be_node = be_nodes; be_node;
 196                     be_node = be_node->be_next_node)
 197                         if (strcmp(be_node->be_root_ds, entry->bootfs) == 0)
 198                                 break;
 199
 200                 if (parsable)
 201                         (void) printf("%d;%s;%s;%s\n", i,
 202                             be_node->be_active_on_boot == B_TRUE? "*" : "-",
 203                             entry->bootfs, entry->title);
 204                 else
 205                         (void) printf("%-*d %-*s %-*s %-*s\n",
 206                             hdr->cols[0].width, i,
 207                             hdr->cols[1].width,
 208                             be_node->be_active_on_boot == B_TRUE? "*" : "-",
 209                             hdr->cols[2].width, entry->bootfs,
 210                             hdr->cols[3].width, entry->title);
 211         }
 212         be_free_list(be_nodes);
 213 }
 214
 215 static void
 216 print_nodes(boolean_t parsable, struct menu_lst *menu)
 217 {
 218         struct hdr_info hdr;
 219
 220         if (!parsable) {
 221                 init_hdr_cols(&hdr);
 222                 count_widths(&hdr, menu);
 223                 print_hdr(&hdr);
 224         }
 225
 226         print_menu_nodes(parsable, &hdr, menu);
 227 }
 228
 229 error_t
 230 menu_read(struct menu_lst *menu, char *menu_path)
 231 {
 232         FILE *fp;
 233         struct menu_entry *mp;
 234         char buf[PATH_MAX];
 235         char *title;
 236         char *bootfs;
 237         char *ptr;
 238         int i = 0;
 239         int ret = BAM_SUCCESS;
 240
 241         fp = fopen(menu_path, "r");
 242         if (fp == NULL)
 243                 return (BAM_ERROR);
 244
 245         /*
 246          * menu.lst entry is on two lines, one for title, one for bootfs
 247          * so we process both lines in succession.
 248          */
 249         do {
 250                 if (fgets(buf, PATH_MAX, fp) == NULL) {
 251                         if (!feof(fp))
 252                                 ret = BAM_ERROR;
 253                         (void) fclose(fp);
 254                         return (ret);
 255                 }
 256                 ptr = strchr(buf, '\n');
 257                 if (ptr != NULL)
 258                         *ptr = '\0';
 259
 260                 ptr = strchr(buf, ' ');
 261                 if (ptr == NULL) {
 262                         (void) fclose(fp);
 263                         return (BAM_ERROR);
 264                 }
 265                 *ptr++ = '\0';
 266                 if (strcmp(buf, "title") != 0) {
 267                         (void) fclose(fp);
 268                         return (BAM_ERROR);
 269                 }
 270                 if ((title = strdup(ptr)) == NULL) {
 271                         (void) fclose(fp);
 272                         return (BAM_ERROR);
 273                 }
 274
 275                 if (fgets(buf, PATH_MAX, fp) == NULL) {
 276                         free(title);
 277                         (void) fclose(fp);
 278                         return (BAM_ERROR);
 279                 }
 280
 281                 ptr = strchr(buf, '\n');
 282                 if (ptr != NULL)
 283                         *ptr = '\0';
 284
 285                 ptr = strchr(buf, ' ');
 286                 if (ptr == NULL) {
 287                         free(title);
 288                         (void) fclose(fp);
 289                         return (BAM_ERROR);
 290                 }
 291                 *ptr++ = '\0';
 292                 if (strcmp(buf, "bootfs") != 0) {
 293                         free(title);
 294                         (void) fclose(fp);
 295                         return (BAM_ERROR);
 296                 }
 297                 if ((bootfs = strdup(ptr)) == NULL) {
 298                         free(title);
 299                         (void) fclose(fp);
 300                         return (BAM_ERROR);
 301                 }
 302                 if ((mp = malloc(sizeof (struct menu_entry))) == NULL) {
 303                         free(title);
 304                         free(bootfs);
 305                         (void) fclose(fp);
 306                         return (BAM_ERROR);
 307                 }
 308                 mp->entry = i++;
 309                 mp->title = title;
 310                 mp->bootfs = bootfs;
 311                 STAILQ_INSERT_TAIL(menu, mp, next);
 312         } while (feof(fp) == 0);
 313
 314         (void) fclose(fp);
 315         return (ret);
 316 }
 317
 318 void
 319 menu_free(struct menu_lst *menu)
 320 {
 321         struct menu_entry *entry;
 322         STAILQ_FOREACH(entry, menu, next) {
 323                 STAILQ_REMOVE_HEAD(menu, next);
 324                 free(entry->title);
 325                 free(entry->bootfs);
 326                 free(entry);
 327         }
 328 }
 329
 330 error_t
 331 bam_loader_menu(char *subcmd, char *opt, int largc, char *largv[])
 332 {
 333         error_t         ret;
 334         char            menu_path[PATH_MAX];
 335         char            clean_menu_root[PATH_MAX];
 336         char            menu_root[PATH_MAX];
 337         struct stat     sb;
 338         error_t         (*f)(struct menu_lst *, char *, char *);
 339         char            *special;
 340         char            *pool = NULL;
 341         zfs_mnted_t     zmnted;
 342         char            *zmntpt;
 343         char            *osdev;
 344         char            *osroot;
 345         const char      *fcn = "bam_loader_menu()";
 346         struct menu_lst menu = {0};
 347
 348         STAILQ_INIT(&menu);
 349
 350         /*
 351          * Check arguments
 352          */
 353         ret = check_subcmd_and_options(subcmd, opt, menu_subcmds, &f);
 354         if (ret == BAM_ERROR) {
 355                 return (BAM_ERROR);
 356         }
 357
 358         assert(bam_root);
 359
 360         (void) strlcpy(menu_root, bam_root, sizeof (menu_root));
 361         osdev = osroot = NULL;
 362
 363         if (strcmp(subcmd, "update_entry") == 0) {
 364                 assert(opt);
 365
 366                 osdev = strtok(opt, ",");
 367                 assert(osdev);
 368                 osroot = strtok(NULL, ",");
 369                 if (osroot) {
 370                         /* fixup bam_root so that it points at osroot */
 371                         if (realpath(osroot, rootbuf) == NULL) {
 372                                 bam_error(_("cannot resolve path %s: %s\n"),
 373                                     osroot, strerror(errno));
 374                                 return (BAM_ERROR);
 375                         }
 376                         bam_alt_root = 1;
 377                         bam_root  = rootbuf;
 378                         bam_rootlen = strlen(rootbuf);
 379                 }
 380         }
 381
 382         if (stat(menu_root, &sb) == -1) {
 383                 bam_error(_("cannot find menu\n"));
 384                 return (BAM_ERROR);
 385         }
 386
 387         if (!is_zfs(menu_root)) {
 388                 bam_error(_("only ZFS root is supported\n"));
 389                 return (BAM_ERROR);
 390         }
 391
 392         assert(strcmp(menu_root, bam_root) == 0);
 393         special = get_special(menu_root);
 394         INJECT_ERROR1("Z_MENU_GET_SPECIAL", special = NULL);
 395         if (special == NULL) {
 396                 bam_error(_("cant find special file for mount-point %s\n"),
 397                     menu_root);
 398                 return (BAM_ERROR);
 399         }
 400         pool = strtok(special, "/");
 401         INJECT_ERROR1("Z_MENU_GET_POOL", pool = NULL);
 402         if (pool == NULL) {
 403                 free(special);
 404                 bam_error(_("cant find pool for mount-point %s\n"), menu_root);
 405                 return (BAM_ERROR);
 406         }
 407         BAM_DPRINTF(("%s: derived pool=%s from special\n", fcn, pool));
 408
 409         zmntpt = mount_top_dataset(pool, &zmnted);
 410         INJECT_ERROR1("Z_MENU_MOUNT_TOP_DATASET", zmntpt = NULL);
 411         if (zmntpt == NULL) {
 412                 bam_error(_("cannot mount pool dataset for pool: %s\n"), pool);
 413                 free(special);
 414                 return (BAM_ERROR);
 415         }
 416         BAM_DPRINTF(("%s: top dataset mountpoint=%s\n", fcn, zmntpt));
 417
 418         (void) strlcpy(menu_root, zmntpt, sizeof (menu_root));
 419         BAM_DPRINTF(("%s: zfs menu_root=%s\n", fcn, menu_root));
 420
 421         elide_trailing_slash(menu_root, clean_menu_root,
 422             sizeof (clean_menu_root));
 423
 424         BAM_DPRINTF(("%s: cleaned menu root is <%s>\n", fcn, clean_menu_root));
 425
 426         (void) strlcpy(menu_path, clean_menu_root, sizeof (menu_path));
 427         (void) strlcat(menu_path, MENU, sizeof (menu_path));
 428
 429         BAM_DPRINTF(("%s: menu path is: %s\n", fcn, menu_path));
 430
 431         /*
 432          * update_entry is special case, its used by installer
 433          * and needs to create menu.lst file for loader
 434          */
 435         if (menu_read(&menu, menu_path) == BAM_ERROR &&
 436             strcmp(subcmd, "update_entry") != 0) {
 437                 bam_error(_("cannot find menu file: %s\n"), menu_path);
 438                 if (special != NULL)
 439                         free(special);
 440                 return (BAM_ERROR);
 441         }
 442
 443         /*
 444          * If listing the menu, display the menu location
 445          */
 446         if (strcmp(subcmd, "list_entry") == 0)
 447                 bam_print(_("the location for the active menu is: %s\n"),
 448                     menu_path);
 449
 450         /*
 451          * We already checked the following case in
 452          * check_subcmd_and_suboptions() above. Complete the
 453          * final step now.
 454          */
 455         if (strcmp(subcmd, "set_option") == 0) {
 456                 assert(largc == 1 && largv[0] && largv[1] == NULL);
 457                 opt = largv[0];
 458         } else if ((strcmp(subcmd, "enable_hypervisor") != 0) &&
 459             (strcmp(subcmd, "list_setting") != 0)) {
 460                 assert(largc == 0 && largv == NULL);
 461         }
 462
 463         /*
 464          * Once the sub-cmd handler has run
 465          * only the line field is guaranteed to have valid values
 466          */
 467         if (strcmp(subcmd, "update_entry") == 0) {
 468                 ret = f(&menu, menu_root, osdev);
 469         } else if (strcmp(subcmd, "upgrade") == 0) {
 470                 ret = f(&menu, bam_root, menu_root);
 471         } else if (strcmp(subcmd, "list_entry") == 0) {
 472                 ret = f(&menu, menu_path, opt);
 473         } else if (strcmp(subcmd, "list_setting") == 0) {
 474                 ret = f(&menu, ((largc > 0) ? largv[0] : ""),
 475                     ((largc > 1) ? largv[1] : ""));
 476         } else if (strcmp(subcmd, "disable_hypervisor") == 0) {
 477                 if (is_sparc()) {
 478                         bam_error(_("%s operation unsupported on SPARC "
 479                             "machines\n"), subcmd);
 480                         ret = BAM_ERROR;
 481                 } else {
 482                         ret = f(&menu, bam_root, NULL);
 483                 }
 484         } else if (strcmp(subcmd, "enable_hypervisor") == 0) {
 485                 if (is_sparc()) {
 486                         bam_error(_("%s operation unsupported on SPARC "
 487                             "machines\n"), subcmd);
 488                         ret = BAM_ERROR;
 489                 } else {
 490                         char *extra_args = NULL;
 491
 492                         /*
 493                          * Compress all arguments passed in the largv[] array
 494                          * into one string that can then be appended to the
 495                          * end of the kernel$ string the routine to enable the
 496                          * hypervisor will build.
 497                          *
 498                          * This allows the caller to supply arbitrary unparsed
 499                          * arguments, such as dom0 memory settings or APIC
 500                          * options.
 501                          *
 502                          * This concatenation will be done without ANY syntax
 503                          * checking whatsoever, so it's the responsibility of
 504                          * the caller to make sure the arguments are valid and
 505                          * do not duplicate arguments the conversion routines
 506                          * may create.
 507                          */
 508                         if (largc > 0) {
 509                                 int extra_len, i;
 510
 511                                 for (extra_len = 0, i = 0; i < largc; i++)
 512                                         extra_len += strlen(largv[i]);
 513
 514                                 /*
 515                                  * Allocate space for argument strings,
 516                                  * intervening spaces and terminating NULL.
 517                                  */
 518                                 extra_args = alloca(extra_len + largc);
 519
 520                                 (void) strcpy(extra_args, largv[0]);
 521
 522                                 for (i = 1; i < largc; i++) {
 523                                         (void) strcat(extra_args, " ");
 524                                         (void) strcat(extra_args, largv[i]);
 525                                 }
 526                         }
 527
 528                         ret = f(&menu, bam_root, extra_args);
 529                 }
 530         } else
 531                 ret = f(&menu, NULL, opt);
 532
 533         if (ret == BAM_WRITE) {
 534                 BAM_DPRINTF(("%s: writing menu to clean-menu-root: <%s>\n",
 535                     fcn, clean_menu_root));
 536                 /* ret = menu_write(clean_menu_root, menu); */
 537         }
 538
 539         INJECT_ERROR1("POOL_SET", pool = "/pooldata");
 540         assert((is_zfs(menu_root)) ^ (pool == NULL));
 541         if (pool) {
 542                 (void) umount_top_dataset(pool, zmnted, zmntpt);
 543                 free(special);
 544         }
 545
 546         menu_free(&menu);
 547         return (ret);
 548 }
 549
 550 /*
 551  * To suppress output from ficl. We do not want to see messages
 552  * from interpreting loader config.
 553  */
 554
 555 /*ARGSUSED*/
 556 static void
 557 ficlTextOutSilent(ficlCallback *cb, char *text)
 558 {
 559 }
 560
 561 /*ARGSUSED*/
 562 static error_t
 563 set_option(struct menu_lst *menu, char *dummy, char *opt)
 564 {
 565         char path[PATH_MAX];
 566         char *val;
 567         char *rest;
 568         int optval;
 569         struct menu_entry *entry;
 570         nvlist_t *be_attrs;
 571         FILE *fp;
 572         int rv, ret = BAM_SUCCESS;
 573
 574         assert(menu);
 575         assert(opt);
 576         assert(dummy == NULL);
 577
 578         val = strchr(opt, '=');
 579         if (val != NULL) {
 580                 *val++ = '\0';
 581         }
 582
 583         if (strcmp(opt, "default") == 0) {
 584                 errno = 0;
 585                 optval = strtol(val, &rest, 10);
 586                 if (errno != 0 || *rest != '\0') {
 587                         bam_error(_("invalid boot entry number: %s\n"), val);
 588                         return (BAM_ERROR);
 589                 }
 590                 STAILQ_FOREACH(entry, menu, next) {
 591                         if (entry->entry == optval)
 592                                 break;
 593                 }
 594                 if (entry == NULL) {
 595                         bam_error(_("invalid boot entry number: %s\n"), val);
 596                         return (BAM_ERROR);
 597                 }
 598                 if (nvlist_alloc(&be_attrs, NV_UNIQUE_NAME, 0) != 0) {
 599                         bam_error(_("out of memory\n"));
 600                         return (BAM_ERROR);
 601                 }
 602                 if (nvlist_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME,
 603                     entry->title) != 0) {
 604                         bam_error(_("out of memory\n"));
 605                         nvlist_free(be_attrs);
 606                         return (BAM_ERROR);
 607                 }
 608                 ret = be_activate(be_attrs);
 609                 nvlist_free(be_attrs);
 610                 if (ret != 0)
 611                         ret = BAM_ERROR;
 612                 return (ret);
 613         } else if (strcmp(opt, "timeout") == 0) {
 614                 errno = 0;
 615                 optval = strtol(val, &rest, 10);
 616                 if (errno != 0 || *rest != '\0') {
 617                         bam_error(_("invalid timeout: %s\n"), val);
 618                         return (BAM_ERROR);
 619                 }
 620
 621                 (void) snprintf(path, PATH_MAX, "%s" CONF_DIR "/timeout",
 622                     bam_root);
 623
 624                 fp = fopen(path, "w");
 625                 if (fp == NULL) {
 626                         bam_error(_("failed to open file: %s: %s\n"),
 627                             path, strerror(errno));
 628                         return (BAM_ERROR);
 629                 }
 630                 /*
 631                  * timeout=-1 is to disable auto boot in illumos, but
 632                  * loader needs "NO" to disable auto boot.
 633                  */
 634                 if (optval == -1)
 635                         rv = fprintf(fp, "autoboot_delay=\"NO\"\n");
 636                 else
 637                         rv = fprintf(fp, "autoboot_delay=\"%d\"\n", optval);
 638
 639                 if (rv < 0) {
 640                         bam_error(_("write to file failed: %s: %s\n"),
 641                             path, strerror(errno));
 642                         (void) fclose(fp);
 643                         ret = BAM_ERROR;
 644                 } else
 645                         rv = fclose(fp);
 646
 647                 if (rv < 0) {
 648                         bam_error(_("failed to close file: %s: %s\n"),
 649                             path, strerror(errno));
 650                         ret = BAM_ERROR;
 651                 }
 652                 if (ret == BAM_ERROR)
 653                         (void) unlink(path);
 654
 655                 return (BAM_SUCCESS);
 656         }
 657
 658         bam_error(_("invalid option: %s\n"), opt);
 659         return (BAM_ERROR);
 660 }
 661
 662 static int
 663 bam_mount_be(struct menu_entry *entry, char **dir)
 664 {
 665         nvlist_t *be_attrs = NULL;
 666         const char *tmpdir = getenv("TMPDIR");
 667         const char *tmpname = "bam.XXXXXX";
 668         be_node_list_t *be_node, *be_nodes = NULL;
 669         int ret;
 670
 671         *dir = NULL;
 672         if (tmpdir == NULL)
 673                 tmpdir = "/tmp";
 674
 675         ret = asprintf(dir, "%s/%s", tmpdir, tmpname);
 676         if (ret < 0) {
 677                 return (BE_ERR_NOMEM);
 678         }
 679         *dir = mkdtemp(*dir);
 680
 681         if (nvlist_alloc(&be_attrs, NV_UNIQUE_NAME, 0) != 0) {
 682                 ret = BE_ERR_NOMEM;
 683                 goto out;
 684         }
 685
 686         ret = be_list(NULL, &be_nodes);
 687         if (ret != BE_SUCCESS) {
 688                 goto out;
 689         }
 690
 691         for (be_node = be_nodes; be_node;
 692             be_node = be_node->be_next_node)
 693                 if (strcmp(be_node->be_root_ds, entry->bootfs) == 0)
 694                         break;
 695
 696         if (nvlist_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME,
 697             be_node->be_node_name) != 0) {
 698                 ret = BE_ERR_NOMEM;
 699                 goto out;
 700         }
 701
 702         if (nvlist_add_string(be_attrs, BE_ATTR_MOUNTPOINT, *dir) != 0) {
 703                 ret = BE_ERR_NOMEM;
 704                 goto out;
 705         }
 706
 707         ret = be_mount(be_attrs);
 708         if (ret == BE_ERR_MOUNTED) {
 709                 /*
 710                  * if BE is mounted, dir does not point to correct directory
 711                  */
 712                 (void) rmdir(*dir);
 713                 free(*dir);
 714                 *dir = NULL;
 715         }
 716 out:
 717         if (be_nodes != NULL)
 718                 be_free_list(be_nodes);
 719         nvlist_free(be_attrs);
 720         return (ret);
 721 }
 722
 723 static int
 724 bam_umount_be(char *dir)
 725 {
 726         nvlist_t *be_attrs;
 727         int ret;
 728
 729         if (dir == NULL)                /* nothing to do */
 730                 return (BE_SUCCESS);
 731
 732         if (nvlist_alloc(&be_attrs, NV_UNIQUE_NAME, 0) != 0)
 733                 return (BE_ERR_NOMEM);
 734
 735         if (nvlist_add_string(be_attrs, BE_ATTR_ORIG_BE_NAME, dir) != 0) {
 736                 ret = BE_ERR_NOMEM;
 737                 goto out;
 738         }
 739
 740         ret = be_unmount(be_attrs);
 741 out:
 742         nvlist_free(be_attrs);
 743         return (ret);
 744 }
 745
 746 /*
 747  * display details of menu entry or single property
 748  */
 749 static error_t
 750 list_menu_entry(struct menu_entry *entry, char *setting)
 751 {
 752         int ret = BAM_SUCCESS;
 753         char *ptr, *dir;
 754         char buf[MAX_INPUT];
 755         ficlVm *vm;
 756         int mounted;
 757
 758         mounted = bam_mount_be(entry, &dir);
 759         if (mounted != BE_SUCCESS && mounted != BE_ERR_MOUNTED) {
 760                 if (dir != NULL) {
 761                         (void) rmdir(dir);
 762                         free(dir);
 763                 }
 764                 bam_error(_("%s is not mounted\n"), entry->title);
 765                 return (BAM_ERROR);
 766         }
 767
 768         vm = bf_init("", ficlTextOutSilent);
 769         if (vm == NULL) {
 770                 bam_error(_("error setting up forth interpreter\n"));
 771                 ret = BAM_ERROR;
 772                 goto done;
 773         }
 774
 775         /* should only get FICL_VM_STATUS_OUT_OF_TEXT */
 776         (void) snprintf(buf, MAX_INPUT, "set currdev=zfs:%s:",
 777             entry->bootfs);
 778         ret = ficlVmEvaluate(vm, buf);
 779         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
 780                 bam_error(_("error interpreting boot config\n"));
 781                 ret = BAM_ERROR;
 782                 goto done;
 783         }
 784         (void) snprintf(buf, MAX_INPUT, "include /boot/forth/loader.4th");
 785         ret = ficlVmEvaluate(vm, buf);
 786         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
 787                 bam_error(_("error interpreting boot config\n"));
 788                 ret = BAM_ERROR;
 789                 goto done;
 790         }
 791         (void) snprintf(buf, MAX_INPUT, "start");
 792         ret = ficlVmEvaluate(vm, buf);
 793         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
 794                 bam_error(_("error interpreting boot config\n"));
 795                 ret = BAM_ERROR;
 796                 goto done;
 797         }
 798         (void) snprintf(buf, MAX_INPUT, "boot");
 799         ret = ficlVmEvaluate(vm, buf);
 800         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
 801                 bam_error(_("error interpreting boot config\n"));
 802                 ret = BAM_ERROR;
 803                 goto done;
 804         }
 805
 806         ret = BAM_SUCCESS;
 807         if (*setting == '\0')
 808                 (void) printf("\nTitle:       %s\n", entry->title);
 809         else if (strcasecmp(setting, "title") == 0) {
 810                 (void) printf("%s\n", entry->title);
 811                 goto done;
 812         }
 813
 814         ptr = getenv("autoboot_delay");
 815         if (ptr != NULL) {
 816                 char *timeout = "-1";
 817
 818                 if (strcasecmp(ptr, "NO") != 0)
 819                         timeout = ptr;
 820
 821                 if (*setting == '\0')
 822                         (void) printf("Timeout:     %s\n", timeout);
 823                 else if (strcasecmp(setting, "timeout") == 0) {
 824                         (void) printf("%s\n", timeout);
 825                         goto done;
 826                 }
 827
 828         }
 829         ptr = getenv("console");
 830         if (ptr != NULL) {
 831                 if (*setting == '\0')
 832                         (void) printf("Console:     %s\n", ptr);
 833                 else if (strcasecmp(setting, "console") == 0) {
 834                         (void) printf("%s\n", ptr);
 835                         goto done;
 836                 }
 837         }
 838
 839         if (*setting == '\0')
 840                 (void) printf("Bootfs:      %s\n", entry->bootfs);
 841         else if (strcasecmp(setting, "bootfs") == 0) {
 842                 (void) printf("%s\n", entry->bootfs);
 843                 goto done;
 844         }
 845
 846         ptr = getenv("xen_kernel");
 847         if (ptr != NULL) {
 848                         if (*setting == '\0') {
 849                                 (void) printf("Xen kernel:  %s\n", ptr);
 850                         } else if (strcasecmp(setting, "xen_kernel") == 0) {
 851                                 (void) printf("%s\n", ptr);
 852                                 goto done;
 853                         }
 854
 855                         if (*setting == '\0') {
 856                                 (void) printf("Xen args:    \"%s\"\n",
 857                                     getenv("xen_cmdline"));
 858                         } else if (strcasecmp(setting, "xen_cmdline") == 0) {
 859                                 (void) printf("%s\n", getenv("xen_cmdline"));
 860                                 goto done;
 861                         }
 862
 863                         if (*setting == '\0') {
 864                                 (void) printf("Kernel:      %s\n",
 865                                     getenv("bootfile"));
 866                         } if (strcasecmp(setting, "kernel") == 0) {
 867                                 (void) printf("%s\n", getenv("bootfile"));
 868                                 goto done;
 869                         }
 870         } else {
 871                 ptr = getenv("kernelname");
 872                 if (ptr != NULL) {
 873                         if (*setting == '\0') {
 874                                 (void) printf("Kernel:      %s\n", ptr);
 875                         } else if (strcasecmp(setting, "kernel") == 0) {
 876                                 (void) printf("%s\n", ptr);
 877                                 goto done;
 878                         }
 879                 }
 880         }
 881
 882         ptr = getenv("boot-args");
 883         if (ptr != NULL) {
 884                 if (*setting == '\0') {
 885                         (void) printf("Boot-args:   \"%s\"\n", ptr);
 886                 } else if (strcasecmp(setting, "boot-args") == 0) {
 887                         (void) printf("%s\n", ptr);
 888                         goto done;
 889                 }
 890         }
 891
 892         if (*setting == '\0' || strcasecmp(setting, "modules") == 0) {
 893                 (void) printf("\nModules:\n");
 894                 ficlVmSetTextOut(vm, ficlCallbackDefaultTextOut);
 895                 (void) snprintf(buf, MAX_INPUT, "show-module-options");
 896                 ret = ficlVmEvaluate(vm, buf);
 897                 if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
 898                         bam_error(_("error interpreting boot config\n"));
 899                         ret = BAM_ERROR;
 900                         goto done;
 901                 }
 902                 ret = BAM_SUCCESS;
 903                 goto done;
 904         }
 905
 906         /* if we got here with setting string, its unknown property */
 907         if (*setting != '\0') {
 908                 bam_error(_("unknown property: %s\n"), setting);
 909                 ret = BAM_ERROR;
 910         } else
 911                 ret = BAM_SUCCESS;
 912 done:
 913         bf_fini();
 914         if (mounted != BE_ERR_MOUNTED) {
 915                 (void) bam_umount_be(dir);
 916         }
 917
 918         if (dir != NULL) {
 919                 (void) rmdir(dir);
 920                 free(dir);
 921         }
 922
 923         return (ret);
 924 }
 925
 926 /*ARGSUSED*/
 927 static error_t
 928 list_entry(struct menu_lst *menu, char *menu_root, char *opt)
 929 {
 930         error_t ret = BAM_SUCCESS;
 931         struct menu_entry *entry;
 932         char *ptr, *title = NULL;
 933         int i, e = -1;
 934
 935         if (opt == NULL) {
 936                 print_nodes(B_FALSE, menu);
 937                 return (ret);
 938         }
 939
 940         if ((ptr = strchr(opt, '=')) == NULL) {
 941                 bam_error(_("invalid option: %s\n"), opt);
 942                 return (BAM_ERROR);
 943         }
 944
 945         i = ptr - opt;
 946         if (strncmp(opt, "entry", i) == 0) {
 947                 e = atoi(ptr+1);
 948         } else if (strncmp(opt, "title", i) == 0) {
 949                 title = ptr+1;
 950         } else {
 951                 bam_error(_("invalid option: %s\n"), opt);
 952                 return (BAM_ERROR);
 953         }
 954
 955         STAILQ_FOREACH(entry, menu, next) {
 956                 if (title != NULL) {
 957                         if (strcmp(title, entry->title) == 0)
 958                                 break;
 959                 } else if (entry->entry == e)
 960                         break;
 961         }
 962
 963         if (entry == NULL) {
 964                 bam_error(_("no matching entry found\n"));
 965                 return (BAM_ERROR);
 966         }
 967
 968         return (list_menu_entry(entry, ""));
 969 }
 970
 971 /*
 972  * For now this is just stub entry to support grub interface, the
 973  * known consumer is installer ict.py code, calling as:
 974  * bootadm update-menu -R /a -Z -o rdisk
 975  * Later this can be converted to do something useful.
 976  */
 977 /*ARGSUSED*/
 978 static error_t
 979 update_entry(struct menu_lst *menu, char *menu_root, char *osdev)
 980 {
 981         char path[PATH_MAX];
 982         char *pool = menu_root + 1;
 983         be_node_list_t *be_nodes, *be_node;
 984         int rv;
 985         FILE *fp;
 986
 987         (void) snprintf(path, PATH_MAX, "%s%s", menu_root, MENU);
 988         rv = be_list(NULL, &be_nodes);
 989
 990         if (rv != BE_SUCCESS)
 991                 return (BAM_ERROR);
 992
 993         fp = fopen(path, "w");
 994         if (fp == NULL) {
 995                 be_free_list(be_nodes);
 996                 return (BAM_ERROR);
 997         }
 998
 999         for (be_node = be_nodes; be_node; be_node = be_node->be_next_node) {
1000                 if (strcmp(be_node->be_rpool, pool) == 0) {
1001                         (void) fprintf(fp, "title %s\n", be_node->be_node_name);
1002                         (void) fprintf(fp, "bootfs %s\n", be_node->be_root_ds);
1003                 }
1004         }
1005
1006         be_free_list(be_nodes);
1007         (void) fclose(fp);
1008         return (BAM_SUCCESS);
1009 }
1010
1011 /*ARGSUSED*/
1012 static error_t
1013 update_temp(struct menu_lst *menu, char *dummy, char *opt)
1014 {
1015         error_t ret = BAM_ERROR;
1016         char path[PATH_MAX];
1017         char buf[MAX_INPUT];
1018         struct mnttab mpref = { 0 };
1019         struct mnttab mp = { 0 };
1020         ficlVm *vm;
1021         char *env, *o;
1022         FILE *fp;
1023
1024         (void) snprintf(path, PATH_MAX, "%s" TRANSIENT, bam_root);
1025         /*
1026          * if opt == NULL, remove transient config
1027          */
1028         if (opt == NULL) {
1029                 (void) unlink(path);
1030                 return (BAM_SUCCESS);
1031         }
1032
1033         fp = fopen(MNTTAB, "r");
1034         if (fp == NULL)
1035                 return (BAM_ERROR);
1036
1037         mpref.mnt_mountp = "/";
1038         if (getmntany(fp, &mp, &mpref) != 0) {
1039                 (void) fclose(fp);
1040                 return (BAM_ERROR);
1041         }
1042         (void) fclose(fp);
1043
1044         vm = bf_init("", ficlTextOutSilent);
1045         if (vm == NULL) {
1046                 bam_error(_("Error setting up forth interpreter\n"));
1047                 return (ret);
1048         }
1049
1050         /*
1051          * need to check current boot config, so fire up the ficl
1052          * if its xen setup, we add option to boot-args list, not replacing it.
1053          */
1054         (void) snprintf(buf, MAX_INPUT, "set currdev=zfs:%s:", mp.mnt_special);
1055         ret = ficlVmEvaluate(vm, buf);
1056         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1057                 bam_error(_("Error interpreting boot config\n"));
1058                 bf_fini();
1059                 return (BAM_ERROR);
1060         }
1061         (void) snprintf(buf, MAX_INPUT, "include /boot/forth/loader.4th");
1062         ret = ficlVmEvaluate(vm, buf);
1063         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1064                 bam_error(_("Error interpreting boot config\n"));
1065                 bf_fini();
1066                 return (BAM_ERROR);
1067         }
1068         (void) snprintf(buf, MAX_INPUT, "start");
1069         ret = ficlVmEvaluate(vm, buf);
1070         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1071                 bam_error(_("Error interpreting boot config\n"));
1072                 bf_fini();
1073                 return (BAM_ERROR);
1074         }
1075         (void) snprintf(buf, MAX_INPUT, "boot");
1076         ret = ficlVmEvaluate(vm, buf);
1077         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1078                 bam_error(_("Error interpreting boot config\n"));
1079                 bf_fini();
1080                 return (BAM_ERROR);
1081         }
1082         bf_fini();
1083
1084         if (opt[0] == '-') {
1085                 env = getenv("xen_kernel");
1086                 fp = fopen(path, "w");
1087                 if (fp == NULL)
1088                         return (BAM_ERROR);
1089
1090                 if (env != NULL) {
1091                         env = getenv("boot-args");
1092                         (void) fprintf(fp, "boot-args=\"%s %s\"\n", env, opt);
1093                 } else
1094                         (void) fprintf(fp, "boot-args=\"%s\"\n", opt);
1095                 (void) fclose(fp);
1096                 return (BAM_SUCCESS);
1097         }
1098
1099         /*
1100          * it should be the case with "kernel args"
1101          * so, we split the opt at first space
1102          * and store bootfile= and boot-args=
1103          */
1104         env = getenv("xen_kernel");
1105
1106         o = strchr(opt, ' ');
1107         if (o == NULL) {
1108                 fp = fopen(path, "w");
1109                 if (fp == NULL)
1110                         return (BAM_ERROR);
1111                 (void) fprintf(fp, "bootfile=\"%s\"\n", opt);
1112                 (void) fclose(fp);
1113                 return (BAM_SUCCESS);
1114         }
1115         *o++ = '\0';
1116         fp = fopen(path, "w");
1117         if (fp == NULL)
1118                 return (BAM_ERROR);
1119         (void) fprintf(fp, "bootfile=\"%s\"\n", opt);
1120
1121         if (env != NULL) {
1122                 env = getenv("boot-args");
1123                 (void) fprintf(fp, "boot-args=\"%s %s\"\n", env, opt);
1124         } else
1125                 (void) fprintf(fp, "boot-args=\"%s\"\n", o);
1126
1127         (void) fflush(fp);
1128         (void) fclose(fp);
1129         return (ret);
1130 }
1131
1132 static error_t
1133 list_setting(struct menu_lst *menu, char *which, char *setting)
1134 {
1135         int entry = -1;
1136         struct menu_entry *m;
1137         be_node_list_t *be_nodes, *be_node = NULL;
1138         int ret;
1139
1140         assert(which);
1141         assert(setting);
1142
1143         /*
1144          * which can be:
1145          * "" - list default entry
1146          * number - use for entry number
1147          * property name
1148          */
1149         if (*which != '\0') {
1150                 if (isdigit(*which)) {
1151                         char *rest;
1152                         errno = 0;
1153                         entry = strtol(which, &rest, 10);
1154                         if (errno != 0 || *rest != '\0') {
1155                                 bam_error(_("invalid boot entry number: %s\n"),
1156                                     which);
1157                                 return (BAM_ERROR);
1158                         }
1159                 } else
1160                         setting = which;
1161         }
1162
1163         /* find default entry */
1164         if (entry == -1) {
1165                 ret = be_list(NULL, &be_nodes);
1166                 if (ret != BE_SUCCESS) {
1167                         bam_error(_("No BE's found\n"));
1168                         return (BAM_ERROR);
1169                 }
1170                 STAILQ_FOREACH(m, menu, next) {
1171                         entry++;
1172                         for (be_node = be_nodes; be_node;
1173                             be_node = be_node->be_next_node)
1174                                 if (strcmp(be_node->be_root_ds, m->bootfs) == 0)
1175                                         break;
1176                         if (be_node->be_active_on_boot == B_TRUE)
1177                                 break; /* found active node */
1178                 }
1179                 be_free_list(be_nodes);
1180                 if (be_node == NULL) {
1181                         bam_error(_("None of BE nodes is marked active\n"));
1182                         return (BAM_ERROR);
1183                 }
1184         } else {
1185                 STAILQ_FOREACH(m, menu, next)
1186                         if (m->entry == entry)
1187                                 break;
1188
1189                 if (m == NULL) {
1190                         bam_error(_("no matching entry found\n"));
1191                         return (BAM_ERROR);
1192                 }
1193         }
1194
1195         return (list_menu_entry(m, setting));
1196 }
1197
1198 /*ARGSUSED*/
1199 static error_t
1200 disable_hyper(struct menu_lst *menu, char *osroot, char *opt)
1201 {
1202         char path[PATH_MAX];
1203
1204         (void) snprintf(path, PATH_MAX, "%s" XEN_CONFIG, bam_root);
1205         (void) unlink(path);
1206         return (BAM_SUCCESS);
1207 }
1208
1209 /*ARGSUSED*/
1210 static error_t
1211 enable_hyper(struct menu_lst *menu, char *osroot, char *opt)
1212 {
1213         ficlVm *vm;
1214         char path[PATH_MAX];
1215         char buf[MAX_INPUT];
1216         char *env;
1217         FILE *fp;
1218         struct mnttab mpref = { 0 };
1219         struct mnttab mp = { 0 };
1220         int ret;
1221
1222         fp = fopen(MNTTAB, "r");
1223         if (fp == NULL)
1224                 return (BAM_ERROR);
1225
1226         mpref.mnt_mountp = "/";
1227         if (getmntany(fp, &mp, &mpref) != 0) {
1228                 (void) fclose(fp);
1229                 return (BAM_ERROR);
1230         }
1231         (void) fclose(fp);
1232
1233         vm = bf_init("", ficlTextOutSilent);
1234         if (vm == NULL) {
1235                 bam_error(_("Error setting up forth interpreter\n"));
1236                 return (BAM_ERROR);
1237         }
1238
1239         /*
1240          * need to check current boot config, so fire up the ficl
1241          * if its xen setup, we add option to boot-args list, not replacing it.
1242          */
1243         (void) snprintf(buf, MAX_INPUT, "set currdev=zfs:%s:", mp.mnt_special);
1244         ret = ficlVmEvaluate(vm, buf);
1245         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1246                 bam_error(_("Error interpreting boot config\n"));
1247                 bf_fini();
1248                 return (BAM_ERROR);
1249         }
1250         (void) snprintf(buf, MAX_INPUT, "include /boot/forth/loader.4th");
1251         ret = ficlVmEvaluate(vm, buf);
1252         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1253                 bam_error(_("Error interpreting boot config\n"));
1254                 bf_fini();
1255                 return (BAM_ERROR);
1256         }
1257         (void) snprintf(buf, MAX_INPUT, "start");
1258         ret = ficlVmEvaluate(vm, buf);
1259         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1260                 bam_error(_("Error interpreting boot config\n"));
1261                 bf_fini();
1262                 return (BAM_ERROR);
1263         }
1264         (void) snprintf(buf, MAX_INPUT, "boot");
1265         ret = ficlVmEvaluate(vm, buf);
1266         if (ret != FICL_VM_STATUS_OUT_OF_TEXT) {
1267                 bam_error(_("Error interpreting boot config\n"));
1268                 bf_fini();
1269                 return (BAM_ERROR);
1270         }
1271         bf_fini();
1272
1273         (void) mkdir(CONF_DIR, 0755);
1274         (void) snprintf(path, PATH_MAX, "%s" XEN_CONFIG, bam_root);
1275         fp = fopen(path, "w");
1276         if (fp == NULL) {
1277                 return (BAM_ERROR);     /* error, cant write config */
1278         }
1279
1280         errno = 0;
1281         /*
1282          * on write error, remove file to ensure we have bootable config.
1283          * note we dont mind if config exists, it will get updated
1284          */
1285         (void) fprintf(fp, "xen_kernel=\"/boot/${ISADIR}/xen\"\n");
1286         if (errno != 0)
1287                 goto error;
1288
1289         /*
1290          * really simple and stupid console conversion.
1291          * it really has to be gone, it belongs to milestone/xvm properties.
1292          */
1293         env = getenv("console");
1294         if (env != NULL) {
1295                 if (strcmp(env, "ttya") == 0)
1296                         (void) fprintf(fp, "xen_cmdline=\"console=com1 %s\"\n",
1297                             opt);
1298                 else if (strcmp(env, "ttyb") == 0)
1299                         (void) fprintf(fp, "xen_cmdline=\"console=com2 %s\"\n",
1300                             opt);
1301                 else
1302                         (void) fprintf(fp, "xen_cmdline=\"console=vga %s\"\n",
1303                             opt);
1304         } else
1305                 (void) fprintf(fp, "xen_cmdline=\"%s\"\n", opt);
1306         if (errno != 0)
1307                 goto error;
1308
1309         (void) fprintf(fp,
1310             "bootfile=\"/platform/i86xpv/kernel/${ISADIR}/unix\"\n");
1311         if (errno != 0)
1312                 goto error;
1313
1314         (void) fprintf(fp,
1315             "boot-args=\"/platform/i86xpv/kernel/${ISADIR}/unix\"\n");
1316         if (errno != 0)
1317                 goto error;
1318
1319         (void) fclose(fp);
1320         if (errno != 0) {
1321                 (void) unlink(path);
1322                 return (BAM_ERROR);
1323         }
1324         return (BAM_SUCCESS);
1325 error:
1326         (void) fclose(fp);
1327         (void) unlink(path);
1328         return (BAM_ERROR);
1329 }