libgrubmgmt/common/libgrub_cmd.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 * Copyright 2015 Nexenta Systems, Inc.
 */

/*
 * This file contains all the functions that implement the following
 * GRUB commands:
 *  kernel, kernel$, module, module$, findroot, bootfs
 * Return 0 on success, errno on failure.
 */
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <alloca.h>
#include <errno.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/fs/ufs_mount.h>
#include <sys/dktp/fdisk.h>
#if defined(__i386)
#include <sys/x86_archext.h>
#endif /* __i386 */

#include "libgrub_impl.h"

#define RESET_MODULE(barg)  ((barg)->gb_module[0] = 0)

#define BPROP_ZFSBOOTFS "zfs-bootfs"
#define BPROP_BOOTPATH  "bootpath"

#if defined(__i386)
static const char cpuid_dev[] = "/dev/cpu/self/cpuid";

/*
 * Return 1 if the system supports 64-bit mode, 0 if it doesn't,
 * or -1 on failure.
 */
static int
cpuid_64bit_capable(void)
{
    int fd, ret = -1;
    struct {
        uint32_t cp_eax, cp_ebx, cp_ecx, cp_edx;
    } cpuid_regs;

    if ((fd = open(cpuid_dev, O_RDONLY)) == -1)
        return (ret);

    if (pread(fd, &cpuid_regs, sizeof (cpuid_regs), 0x80000001) ==
        sizeof (cpuid_regs))
        ret = ((CPUID_AMD_EDX_LM & cpuid_regs.cp_edx) != 0);

    (void) close(fd);
    return (ret);
}
#endif /* __i386 */


/*
 * Expand $ISAIDR
 */
#if !defined(__i386)
/* ARGSUSED */
#endif /* __i386 */
static size_t
barg_isadir_var(char *var, int sz)
{
#if defined(__i386)
    if (cpuid_64bit_capable() == 1)
        return (strlcpy(var, "amd64", sz));
#endif /* __i386 */

    var[0] = 0;
    return (0);
}

/*
 * Expand $ZFS-BOOTFS
 */
static size_t
barg_bootfs_var(const grub_barg_t *barg, char *var, int sz)
{
    int n;

    assert(barg);
    if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) == 0) {
        n = snprintf(var, sz,
            BPROP_ZFSBOOTFS "=%s," BPROP_BOOTPATH "=\"%s\"",
            barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev,
            barg->gb_root.gr_physpath);
    } else  {
        var[0] = 0;
        n = 0;
    }
    return (n);
}

/*
 * Expand all the variables without appending them more than once.
 */
static int
expand_var(char *arg, size_t argsz, const char *var, size_t varsz,
    char *val, size_t valsz)
{
    char    *sp = arg;
    size_t  sz = argsz, len;
    char    *buf, *dst, *src;
    int ret = 0;

    buf = alloca(argsz);
    dst = buf;

    while ((src = strstr(sp, var)) != NULL) {

        len = src - sp;

        if (len + valsz > sz) {
            ret = E2BIG;
            break;
        }

        (void) bcopy(sp, dst, len);
        (void) bcopy(val, dst + len, valsz);
        dst += len + valsz;
        sz -= len + valsz;
        sp = src + varsz;
    }

    if (strlcpy(dst, sp, sz) >= sz)
        ret = E2BIG;

    if (ret == 0)
        bcopy(buf, arg, argsz);
    return (ret);
}

/*
 * Searches first occurence of boot-property 'bprop' in str.
 * str supposed to be in format:
 * " [-B prop=[value][,prop=[value]]...]
 */
static const char *
find_bootprop(const char *str, const char *bprop)
{
    const char *s;
    size_t bplen, len;

    assert(str);
    assert(bprop);

    bplen = strlen(bprop);
    s = str;

    while ((str = strstr(s, " -B")) != NULL ||
        (str = strstr(s, "\t-B")) != NULL) {
        s = str + 3;
        len = strspn(s, " \t");

        /* empty -B option, skip it */
        if (len != 0 && s[len] == '-')
            continue;

        s += len;
        do {
            len = strcspn(s, "= \t");
            if (s[len] !=  '=')
                break;

            /* boot property we are looking for? */
            if (len == bplen && strncmp(s, bprop, bplen) == 0)
                return (s);

            s += len;

            /* skip boot property value */
            while ((s = strpbrk(s + 1, "\"\', \t")) != NULL) {

                /* skip quoted */
                if (s[0] == '\"' || s[0] == '\'') {
                    if ((s = strchr(s + 1, s[0])) == NULL) {
                        /* unbalanced quotes */
                        return (s);
                    }
                }
                else
                    break;
            }

            /* no more boot properties */
            if (s == NULL)
                return (s);

            /* no more boot properties in that -B block */
            if (s[0] != ',')
                break;

            s += strspn(s, ",");
        } while (s[0] != ' ' && s[0] != '\t');
    }
    return (NULL);
}

/*
 * Add bootpath property to str if
 *  1. zfs-bootfs property is set explicitly
 * and
 *  2. bootpath property is not set
 */
static int
update_bootpath(char *str, size_t strsz, const char *bootpath)
{
    size_t n;
    char *buf;
    const char *bfs;

    /* zfs-bootfs is not specified, or bootpath is allready set */
    if ((bfs = find_bootprop(str, BPROP_ZFSBOOTFS)) == NULL ||
        find_bootprop(str, BPROP_BOOTPATH) != NULL)
        return (0);

    n = bfs - str;
    buf = alloca(strsz);

    bcopy(str, buf, n);
    if (snprintf(buf + n, strsz - n, BPROP_BOOTPATH "=\"%s\",%s",
        bootpath, bfs) >= strsz - n)
        return (E2BIG);

    bcopy(buf, str, strsz);
    return (0);
}

static int
match_bootfs(zfs_handle_t *zfh, void *data)
{
    int     ret;
    const char  *zfn;
    grub_barg_t *barg = (grub_barg_t *)data;

    ret = (zfs_get_type(zfh) == ZFS_TYPE_FILESYSTEM &&
        (zfn = zfs_get_name(zfh)) != NULL &&
        strcmp(barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev, zfn) == 0);

    if (ret != 0)
        barg->gb_walkret = 0;
    else
        (void) zfs_iter_filesystems(zfh, match_bootfs, barg);

    zfs_close(zfh);
    return (barg->gb_walkret == 0);
}

static void
reset_root(grub_barg_t *barg)
{
    (void) memset(&barg->gb_root, 0, sizeof (barg->gb_root));
    barg->gb_bootsign[0] = 0;
    barg->gb_kernel[0] = 0;
    RESET_MODULE(barg);
}

/* ARGSUSED */
int
skip_line(const grub_line_t *lp, grub_barg_t *barg)
{
    return (0);
}

/* ARGSUSED */
int
error_line(const grub_line_t *lp, grub_barg_t *barg)
{
    if (lp->gl_cmdtp == GRBM_ROOT_CMD)
        return (EG_ROOTNOTSUPP);
    return (EG_INVALIDLINE);
}

int
kernel(const grub_line_t *lp, grub_barg_t *barg)
{
    RESET_MODULE(barg);
    if (strlcpy(barg->gb_kernel, lp->gl_arg, sizeof (barg->gb_kernel)) >=
        sizeof (barg->gb_kernel))
        return (E2BIG);

    return (0);
}

int
module(const grub_line_t *lp, grub_barg_t *barg)
{
    if (strlcpy(barg->gb_module, lp->gl_arg, sizeof (barg->gb_module)) >=
        sizeof (barg->gb_module))
        return (E2BIG);

    return (0);
}

int
dollar_kernel(const grub_line_t *lp, grub_barg_t *barg)
{
    int ret;
    size_t  bfslen, isalen;
    char    isadir[32];
    char    bootfs[BOOTARGS_MAX];

    RESET_MODULE(barg);
    if (strlcpy(barg->gb_kernel, lp->gl_arg, sizeof (barg->gb_kernel)) >=
        sizeof (barg->gb_kernel))
        return (E2BIG);

    bfslen = barg_bootfs_var(barg, bootfs, sizeof (bootfs));
    isalen = barg_isadir_var(isadir, sizeof (isadir));

    if (bfslen >= sizeof (bootfs) || isalen >= sizeof (isadir))
        return (EINVAL);

    if ((ret = expand_var(barg->gb_kernel, sizeof (barg->gb_kernel),
        ZFS_BOOT_VAR, strlen(ZFS_BOOT_VAR), bootfs, bfslen)) != 0)
        return (ret);

    if ((ret = expand_var(barg->gb_kernel, sizeof (barg->gb_kernel),
        ISADIR_VAR, strlen(ISADIR_VAR), isadir, isalen)) != 0)
        return (ret);

    if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) == 0)
        ret = update_bootpath(barg->gb_kernel, sizeof (barg->gb_kernel),
            barg->gb_root.gr_physpath);

    return (ret);
}

int
dollar_module(const grub_line_t *lp, grub_barg_t *barg)
{
    int ret;
    size_t  isalen;
    char    isadir[32];

    if (strlcpy(barg->gb_module, lp->gl_arg, sizeof (barg->gb_module)) >=
        sizeof (barg->gb_module))
        return (E2BIG);

    if ((isalen = barg_isadir_var(isadir, sizeof (isadir))) >= sizeof
        (isadir))
        return (EINVAL);

    ret = expand_var(barg->gb_module, sizeof (barg->gb_module),
        ISADIR_VAR, strlen(ISADIR_VAR), isadir, isalen);

    return (ret);
}


int
findroot(const grub_line_t *lp, grub_barg_t *barg)
{
    size_t sz, bsz;
    const char *sign;

    reset_root(barg);

    sign = lp->gl_arg;
    barg->gb_prtnum = (uint_t)PRTNUM_INVALID;
    barg->gb_slcnum = (uint_t)SLCNUM_WHOLE_DISK;

    if (sign[0] == '(') {
        const char *pos;

        ++sign;
        if ((pos = strchr(sign, ',')) == NULL || (sz = pos - sign) == 0)
            return (EG_FINDROOTFMT);

        ++pos;
        if (!IS_PRTNUM_VALID(barg->gb_prtnum = pos[0] - '0'))
            return (EG_FINDROOTFMT);

        ++pos;
        /*
         * check the slice only when its presented
         */
        if (pos[0] != ')') {
            if (pos[0] != ',' ||
                !IS_SLCNUM_VALID(barg->gb_slcnum = pos[1]) ||
                pos[2] != ')')
                return (EG_FINDROOTFMT);
        }
    } else {
        sz = strlen(sign);
    }

    bsz = strlen(BOOTSIGN_DIR "/");
    if (bsz + sz + 1 > sizeof (barg->gb_bootsign))
        return (E2BIG);

    bcopy(BOOTSIGN_DIR "/", barg->gb_bootsign, bsz);
    bcopy(sign, barg->gb_bootsign + bsz, sz);
    barg->gb_bootsign [bsz + sz] = 0;

    return (grub_find_bootsign(barg));
}

int
bootfs(const grub_line_t *lp, grub_barg_t *barg)
{
    zfs_handle_t    *zfh;
    grub_menu_t *mp = barg->gb_entry->ge_menu;
    char        *gfs_devp;
    size_t      gfs_dev_len;

    /* Check if root is zfs */
    if (strcmp(barg->gb_root.gr_fstyp, MNTTYPE_ZFS) != 0)
        return (EG_NOTZFS);

    gfs_devp = barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev;
    gfs_dev_len = sizeof (barg->gb_root.gr_fs[GRBM_ZFS_BOOTFS].gfs_dev);

    /*
     * If the bootfs value is the same as the bootfs for the pool,
     * do nothing.
     */
    if (strcmp(lp->gl_arg, gfs_devp) == 0)
        return (0);

    if (strlcpy(gfs_devp, lp->gl_arg, gfs_dev_len) >= gfs_dev_len)
        return (E2BIG);

    /* check if specified bootfs belongs to the root pool */
    if ((zfh = zfs_open(mp->gm_fs.gf_lzfh,
        barg->gb_root.gr_fs[GRBM_ZFS_TOPFS].gfs_dev,
        ZFS_TYPE_FILESYSTEM)) == NULL)
        return (EG_OPENZFS);

    barg->gb_walkret = EG_UNKBOOTFS;
    (void) zfs_iter_filesystems(zfh, match_bootfs, barg);
    zfs_close(zfh);

    if (barg->gb_walkret == 0)
        (void) grub_fsd_get_mountp(barg->gb_root.gr_fs +
            GRBM_ZFS_BOOTFS, MNTTYPE_ZFS);

    return (barg->gb_walkret);
}