libgrubmgmt/common/libgrub_bargs.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.
 */

/*
 * This file contains functions for constructing boot arguments
 * from GRUB menu for Fast Reboot.
 */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/elf.h>

#include "libgrub_impl.h"

#if defined(__sparc)
#define CUR_ELFDATA ELFDATA2MSB
#elif defined(__i386)
#define CUR_ELFDATA ELFDATA2LSB
#endif /* __i386 */

/*
 * Open the kernel file.
 * Return zero on sucess or error code otherwise.
 * On success the kernel file descriptor is returned in fdp.
 */
static int
get_kernel_fd(const char *path, int *fdp)
{
    const char  *bname;
    int     fd = -1, class, format;
    char        ident[EI_NIDENT];

    /* kernel basename must be unix */
    if ((bname = strrchr(path, '/')) == NULL)
        bname = path;
    else
        bname++;

    if (strcmp(bname, "unix") != 0) {
        if (strcmp(bname, "xen.gz") == 0)
            return (EG_XVMNOTSUP);
        return (EG_NOTUNIX);
    }

    if ((fd = open64(path, O_RDONLY)) >= 0 &&
        (pread64(fd, ident, sizeof (ident), 0) == sizeof (ident))) {

        class = ident[EI_CLASS];
        format = ident[EI_DATA];

        if ((class == ELFCLASS32 || class == ELFCLASS64) &&
            (memcmp(&ident[EI_MAG0], ELFMAG, 4) == 0) &&
            format == CUR_ELFDATA) {
            *fdp = fd;
            return (0);
        }
    }

    if (fd >= 0)
        (void) close(fd);
    return (EG_OPENKERNFILE);
}

/*
 * Construct boot arguments for Fast Reboot from the ge_barg field of
 * a GRUB menu entry.
 * Return 0 on success, errno on failure.
 */
static int
barg2bootargs(const grub_barg_t *barg, grub_boot_args_t *fbarg)
{
    int rc = 0;
    char    path[BOOTARGS_MAX];
    char    rpath[BOOTARGS_MAX];
    const grub_fsdesc_t *fsd;

    assert(fbarg);
    bzero(fbarg, sizeof (*fbarg));
    fbarg->gba_kernel_fd = -1;

    if (!IS_BARG_VALID(barg))
        return (EINVAL);
    if ((fsd = grub_get_rootfsd(&barg->gb_root)) == NULL)
        return (EG_UNKNOWNFS);

    bcopy(fsd, &fbarg->gba_fsd, sizeof (fbarg->gba_fsd));
    bcopy(barg->gb_kernel, fbarg->gba_kernel, sizeof (fbarg->gba_kernel));
    bcopy(barg->gb_module, fbarg->gba_module, sizeof (fbarg->gba_module));

    if (fbarg->gba_fsd.gfs_mountp[0] == 0 &&
        (rc = grub_fsd_mount_tmp(&fbarg->gba_fsd,
        barg->gb_root.gr_fstyp)) != 0)
        return (rc);

    if (snprintf(path, sizeof (path), "%s%s", fbarg->gba_fsd.gfs_mountp,
        fbarg->gba_kernel) >= sizeof (path)) {
        rc = E2BIG;
        goto err_out;
    }
    (void) strtok(path, " \t");
    (void) clean_path(path);

    /*
     * GRUB requires absolute path, no symlinks, so do we
     */
    if ((rc = resolvepath(path, rpath, sizeof (rpath))) == -1)
        rc = errno;
    else {
        rpath[rc] = 0;
        if (strcmp(rpath, path) != 0)
            rc = EG_NOTABSPATH;
        else
            rc = get_kernel_fd(rpath, &fbarg->gba_kernel_fd);
    }

    /* construct bootargs command-line */
    if (rc == 0 && snprintf(fbarg->gba_bootargs,
        sizeof (fbarg->gba_bootargs), "%s %s", fbarg->gba_fsd.gfs_mountp,
        fbarg->gba_kernel) >= sizeof (fbarg->gba_bootargs))
        rc = E2BIG;

err_out:
    if (rc != 0)
        grub_cleanup_boot_args(fbarg);

    return (rc);
}

/*
 * Construct boot arguments for Fast Reboot from grub_menu_t.
 * Return 0 on success, errno on failure.
 */
static int
grub_entry_get_boot_args(grub_entry_t *ent, grub_boot_args_t *fbarg)
{
    int rc = EG_INVALIDENT;

    if (IS_ENTRY_VALID(ent) && (rc = grub_entry_construct_barg(ent)) == 0)
        return (barg2bootargs(&ent->ge_barg, fbarg));
    else
        return (rc);
}

/*
 * Construct boot arguments for Fast Reboot from grub_menu_t and the
 * entry number.
 * Return 0 on success, errno on failure.
 */
static int
grub_menu_get_boot_args(const grub_menu_t *mp, int num,
    grub_boot_args_t *fbarg)
{
    grub_entry_t *ent;

    assert(mp);
    assert(fbarg);

    if ((ent = grub_menu_get_entry(mp, num)) == NULL)
        return (EG_NOENTRY);

    return (grub_entry_get_boot_args(ent, fbarg));
}

/*
 * Construct boot arguments from the specified GRUB menu entry.
 * Caller must allocate space for fbarg, and call grub_cleanup_boot_args()
 * when it's done with fbarg to clean up.
 *
 * Return 0 on success, errno on failure.
 */
int
grub_get_boot_args(grub_boot_args_t *fbarg, const char *menupath, int num)
{
    int rc;
    grub_menu_t *mp;

    assert(fbarg);
    if ((rc = grub_menu_init(menupath, &mp)) == 0) {
        rc = grub_menu_get_boot_args(mp, num, fbarg);
        grub_menu_fini(mp);
    }
    return (rc);
}

/*
 * Clean up when done with fbarg: close file handle, unmount file
 * systems.  Must be safe to call even if not all the fields are
 * set up.
 */
void
grub_cleanup_boot_args(grub_boot_args_t *fbarg)
{
    if (fbarg == NULL)
        return;

    (void) close(fbarg->gba_kernel_fd);
    grub_fsd_umount_tmp(&fbarg->gba_fsd);
}