usr/src/lib/libgrubmgmt/common/libgrub_cmd.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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2015 Nexenta Systems, Inc.
  27  */
  28
  29 /*
  30  * This file contains all the functions that implement the following
  31  * GRUB commands:
  32  *      kernel, kernel$, module, module$, findroot, bootfs
  33  * Return 0 on success, errno on failure.
  34  */
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <assert.h>
  38 #include <alloca.h>
  39 #include <errno.h>
  40 #include <strings.h>
  41 #include <unistd.h>
  42 #include <fcntl.h>
  43 #include <sys/types.h>
  44 #include <sys/fs/ufs_mount.h>
  45 #include <sys/dktp/fdisk.h>
  46 #if defined(__i386)
  47 #include <sys/x86_archext.h>
  48 #endif /* __i386 */
  49
  50 #include "libgrub_impl.h"
  51
  52 #define RESET_MODULE(barg)      ((barg)->gb_module[0] = 0)
  53
  54 #define BPROP_ZFSBOOTFS "zfs-bootfs"
  55 #define BPROP_BOOTPATH  "bootpath"
  56
  57 #if defined(__i386)
  58 static const char cpuid_dev[] = "/dev/cpu/self/cpuid";
  59
  60 /*
  61  * Return 1 if the system supports 64-bit mode, 0 if it doesn't,
  62  * or -1 on failure.
  63  */
  64 static int
  65 cpuid_64bit_capable(void)
  66 {
  67         int fd, ret = -1;
  68         struct {
  69                 uint32_t cp_eax, cp_ebx, cp_ecx, cp_edx;
  70         } cpuid_regs;
  71
  72         if ((fd = open(cpuid_dev, O_RDONLY)) == -1)
  73                 return (ret);
  74
  75         if (pread(fd, &cpuid_regs, sizeof (cpuid_regs), 0x80000001) ==
  76             sizeof (cpuid_regs))
  77                 ret = ((CPUID_AMD_EDX_LM & cpuid_regs.cp_edx) != 0);
  78
  79         (void) close(fd);
  80         return (ret);
  81 }
  82 #endif /* __i386 */
  83
  84
  85 /*
  86  * Expand $ISAIDR
  87  */
  88 #if !defined(__i386)
  89 /* ARGSUSED */
  90 #endif /* __i386 */
  91 static size_t
  92 barg_isadir_var(char *var, int sz)
  93 {
  94 #if defined(__i386)
  95         if (cpuid_64bit_capable() == 1)
  96                 return (strlcpy(var, "amd64", sz));
  97 #endif /* __i386 */
  98
  99         var[0] = 0;
 100         return (0);
 101 }
 102
 103 /*
 104  * Expand $ZFS-BOOTFS
 105  */
 106 static size_t
 107 barg_bootfs_var(const grub_barg_t *barg, char *var, int sz)
 108 {
 109         int n;
 110
 111         assert(barg);
 112         if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) == 0) {
 113                 n = snprintf(var, sz,
 114                     BPROP_ZFSBOOTFS "=%s," BPROP_BOOTPATH "=\"%s\"",
 115                     barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev,
 116                     barg->gb_root.gr_physpath);
 117         } else  {
 118                 var[0] = 0;
 119                 n = 0;
 120         }
 121         return (n);
 122 }
 123
 124 /*
 125  * Expand all the variables without appending them more than once.
 126  */
 127 static int
 128 expand_var(char *arg, size_t argsz, const char *var, size_t varsz,
 129     char *val, size_t valsz)
 130 {
 131         char    *sp = arg;
 132         size_t  sz = argsz, len;
 133         char    *buf, *dst, *src;
 134         int     ret = 0;
 135
 136         buf = alloca(argsz);
 137         dst = buf;
 138
 139         while ((src = strstr(sp, var)) != NULL) {
 140
 141                 len = src - sp;
 142
 143                 if (len + valsz > sz) {
 144                         ret = E2BIG;
 145                         break;
 146                 }
 147
 148                 (void) bcopy(sp, dst, len);
 149                 (void) bcopy(val, dst + len, valsz);
 150                 dst += len + valsz;
 151                 sz -= len + valsz;
 152                 sp = src + varsz;
 153         }
 154
 155         if (strlcpy(dst, sp, sz) >= sz)
 156                 ret = E2BIG;
 157
 158         if (ret == 0)
 159                 bcopy(buf, arg, argsz);
 160         return (ret);
 161 }
 162
 163 /*
 164  * Searches first occurence of boot-property 'bprop' in str.
 165  * str supposed to be in format:
 166  * " [-B prop=[value][,prop=[value]]...]
 167  */
 168 static const char *
 169 find_bootprop(const char *str, const char *bprop)
 170 {
 171         const char *s;
 172         size_t bplen, len;
 173
 174         assert(str);
 175         assert(bprop);
 176
 177         bplen = strlen(bprop);
 178         s = str;
 179
 180         while ((str = strstr(s, " -B")) != NULL ||
 181             (str = strstr(s, "\t-B")) != NULL) {
 182                 s = str + 3;
 183                 len = strspn(s, " \t");
 184
 185                 /* empty -B option, skip it */
 186                 if (len != 0 && s[len] == '-')
 187                         continue;
 188
 189                 s += len;
 190                 do {
 191                         len = strcspn(s, "= \t");
 192                         if (s[len] !=  '=')
 193                                 break;
 194
 195                         /* boot property we are looking for? */
 196                         if (len == bplen && strncmp(s, bprop, bplen) == 0)
 197                                 return (s);
 198
 199                         s += len;
 200
 201                         /* skip boot property value */
 202                         while ((s = strpbrk(s + 1, "\"\', \t")) != NULL) {
 203
 204                                 /* skip quoted */
 205                                 if (s[0] == '\"' || s[0] == '\'') {
 206                                         if ((s = strchr(s + 1, s[0])) == NULL) {
 207                                                 /* unbalanced quotes */
 208                                                 return (s);
 209                                         }
 210                                 }
 211                                 else
 212                                         break;
 213                         }
 214
 215                         /* no more boot properties */
 216                         if (s == NULL)
 217                                 return (s);
 218
 219                         /* no more boot properties in that -B block */
 220                         if (s[0] != ',')
 221                                 break;
 222
 223                         s += strspn(s, ",");
 224                 } while (s[0] != ' ' && s[0] != '\t');
 225         }
 226         return (NULL);
 227 }
 228
 229 /*
 230  * Add bootpath property to str if
 231  *      1. zfs-bootfs property is set explicitly
 232  * and
 233  *      2. bootpath property is not set
 234  */
 235 static int
 236 update_bootpath(char *str, size_t strsz, const char *bootpath)
 237 {
 238         size_t n;
 239         char *buf;
 240         const char *bfs;
 241
 242         /* zfs-bootfs is not specified, or bootpath is allready set */
 243         if ((bfs = find_bootprop(str, BPROP_ZFSBOOTFS)) == NULL ||
 244             find_bootprop(str, BPROP_BOOTPATH) != NULL)
 245                 return (0);
 246
 247         n = bfs - str;
 248         buf = alloca(strsz);
 249
 250         bcopy(str, buf, n);
 251         if (snprintf(buf + n, strsz - n, BPROP_BOOTPATH "=\"%s\",%s",
 252             bootpath, bfs) >= strsz - n)
 253                 return (E2BIG);
 254
 255         bcopy(buf, str, strsz);
 256         return (0);
 257 }
 258
 259 static int
 260 match_bootfs(zfs_handle_t *zfh, void *data)
 261 {
 262         int             ret;
 263         const char      *zfn;
 264         grub_barg_t     *barg = (grub_barg_t *)data;
 265
 266         ret = (zfs_get_type(zfh) == ZFS_TYPE_FILESYSTEM &&
 267             (zfn = zfs_get_name(zfh)) != NULL &&
 268             strcmp(barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev, zfn) == 0);
 269
 270         if (ret != 0)
 271                 barg->gb_walkret = 0;
 272         else
 273                 (void) zfs_iter_filesystems(zfh, match_bootfs, barg);
 274
 275         zfs_close(zfh);
 276         return (barg->gb_walkret == 0);
 277 }
 278
 279 static void
 280 reset_root(grub_barg_t *barg)
 281 {
 282         (void) memset(&barg->gb_root, 0, sizeof (barg->gb_root));
 283         barg->gb_bootsign[0] = 0;
 284         barg->gb_kernel[0] = 0;
 285         RESET_MODULE(barg);
 286 }
 287
 288 /* ARGSUSED */
 289 int
 290 skip_line(const grub_line_t *lp, grub_barg_t *barg)
 291 {
 292         return (0);
 293 }
 294
 295 /* ARGSUSED */
 296 int
 297 error_line(const grub_line_t *lp, grub_barg_t *barg)
 298 {
 299         if (lp->gl_cmdtp == GRBM_ROOT_CMD)
 300                 return (EG_ROOTNOTSUPP);
 301         return (EG_INVALIDLINE);
 302 }
 303
 304 int
 305 kernel(const grub_line_t *lp, grub_barg_t *barg)
 306 {
 307         RESET_MODULE(barg);
 308         if (strlcpy(barg->gb_kernel, lp->gl_arg, sizeof (barg->gb_kernel)) >=
 309             sizeof (barg->gb_kernel))
 310                 return (E2BIG);
 311
 312         return (0);
 313 }
 314
 315 int
 316 module(const grub_line_t *lp, grub_barg_t *barg)
 317 {
 318         if (strlcpy(barg->gb_module, lp->gl_arg, sizeof (barg->gb_module)) >=
 319             sizeof (barg->gb_module))
 320                 return (E2BIG);
 321
 322         return (0);
 323 }
 324
 325 int
 326 dollar_kernel(const grub_line_t *lp, grub_barg_t *barg)
 327 {
 328         int     ret;
 329         size_t  bfslen, isalen;
 330         char    isadir[32];
 331         char    bootfs[BOOTARGS_MAX];
 332
 333         RESET_MODULE(barg);
 334         if (strlcpy(barg->gb_kernel, lp->gl_arg, sizeof (barg->gb_kernel)) >=
 335             sizeof (barg->gb_kernel))
 336                 return (E2BIG);
 337
 338         bfslen = barg_bootfs_var(barg, bootfs, sizeof (bootfs));
 339         isalen = barg_isadir_var(isadir, sizeof (isadir));
 340
 341         if (bfslen >= sizeof (bootfs) || isalen >= sizeof (isadir))
 342                 return (EINVAL);
 343
 344         if ((ret = expand_var(barg->gb_kernel, sizeof (barg->gb_kernel),
 345             ZFS_BOOT_VAR, strlen(ZFS_BOOT_VAR), bootfs, bfslen)) != 0)
 346                 return (ret);
 347
 348         if ((ret = expand_var(barg->gb_kernel, sizeof (barg->gb_kernel),
 349             ISADIR_VAR, strlen(ISADIR_VAR), isadir, isalen)) != 0)
 350                 return (ret);
 351
 352         if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) == 0)
 353                 ret = update_bootpath(barg->gb_kernel, sizeof (barg->gb_kernel),
 354                     barg->gb_root.gr_physpath);
 355
 356         return (ret);
 357 }
 358
 359 int
 360 dollar_module(const grub_line_t *lp, grub_barg_t *barg)
 361 {
 362         int     ret;
 363         size_t  isalen;
 364         char    isadir[32];
 365
 366         if (strlcpy(barg->gb_module, lp->gl_arg, sizeof (barg->gb_module)) >=
 367             sizeof (barg->gb_module))
 368                 return (E2BIG);
 369
 370         if ((isalen = barg_isadir_var(isadir, sizeof (isadir))) >= sizeof
 371             (isadir))
 372                 return (EINVAL);
 373
 374         ret = expand_var(barg->gb_module, sizeof (barg->gb_module),
 375             ISADIR_VAR, strlen(ISADIR_VAR), isadir, isalen);
 376
 377         return (ret);
 378 }
 379
 380
 381 int
 382 findroot(const grub_line_t *lp, grub_barg_t *barg)
 383 {
 384         size_t sz, bsz;
 385         const char *sign;
 386
 387         reset_root(barg);
 388
 389         sign = lp->gl_arg;
 390         barg->gb_prtnum = (uint_t)PRTNUM_INVALID;
 391         barg->gb_slcnum = (uint_t)SLCNUM_WHOLE_DISK;
 392
 393         if (sign[0] == '(') {
 394                 const char *pos;
 395
 396                 ++sign;
 397                 if ((pos = strchr(sign, ',')) == NULL || (sz = pos - sign) == 0)
 398                         return (EG_FINDROOTFMT);
 399
 400                 ++pos;
 401                 if (!IS_PRTNUM_VALID(barg->gb_prtnum = pos[0] - '0'))
 402                         return (EG_FINDROOTFMT);
 403
 404                 ++pos;
 405                 /*
 406                  * check the slice only when its presented
 407                  */
 408                 if (pos[0] != ')') {
 409                         if (pos[0] != ',' ||
 410                             !IS_SLCNUM_VALID(barg->gb_slcnum = pos[1]) ||
 411                             pos[2] != ')')
 412                                 return (EG_FINDROOTFMT);
 413                 }
 414         } else {
 415                 sz = strlen(sign);
 416         }
 417
 418         bsz = strlen(BOOTSIGN_DIR "/");
 419         if (bsz + sz + 1 > sizeof (barg->gb_bootsign))
 420                 return (E2BIG);
 421
 422         bcopy(BOOTSIGN_DIR "/", barg->gb_bootsign, bsz);
 423         bcopy(sign, barg->gb_bootsign + bsz, sz);
 424         barg->gb_bootsign [bsz + sz] = 0;
 425
 426         return (grub_find_bootsign(barg));
 427 }
 428
 429 int
 430 bootfs(const grub_line_t *lp, grub_barg_t *barg)
 431 {
 432         zfs_handle_t    *zfh;
 433         grub_menu_t     *mp = barg->gb_entry->ge_menu;
 434         char            *gfs_devp;
 435         size_t          gfs_dev_len;
 436
 437         /* Check if root is zfs */
 438         if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) != 0)
 439                 return (EG_NOTZFS);
 440
 441         gfs_devp = barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev;
 442         gfs_dev_len = sizeof (barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev);
 443
 444         /*
 445          * If the bootfs value is the same as the bootfs for the pool,
 446          * do nothing.
 447          */
 448         if (strcmp(lp->gl_arg, gfs_devp) == 0)
 449                 return (0);
 450
 451         if (strlcpy(gfs_devp, lp->gl_arg, gfs_dev_len) >= gfs_dev_len)
 452                 return (E2BIG);
 453
 454         /* check if specified bootfs belongs to the root pool */
 455         if ((zfh = zfs_open(mp->gm_fs.gf_lzfh,
 456             barg->gb_root.gr_fs[GRBM_ZFS_TOPFS].gfs_dev,
 457             ZFS_TYPE_FILESYSTEM)) == NULL)
 458                 return (EG_OPENZFS);
 459
 460         barg->gb_walkret = EG_UNKBOOTFS;
 461         (void) zfs_iter_filesystems(zfh, match_bootfs, barg);
 462         zfs_close(zfh);
 463
 464         if (barg->gb_walkret == 0)
 465                 (void) grub_fsd_get_mountp(barg->gb_root.gr_fs +
 466                     GRBM_ZFS_BOOTFS, MNTTYPE_ZFS);
 467
 468         return (barg->gb_walkret);
 469 }