i386/libi386/linux.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Toomas Soome <tsoome@me.com>
 */

/*
 * Primitive linux loader, at the moment only intended to load memtest86+.bin.
 *
 * Note the linux kernel location conflicts with loader, so we need to
 * read in to temporary space and relocate on exec, when btx is stopped.
 */
#include <sys/cdefs.h>
#include <sys/stat.h>
#include <stand.h>
#include <machine/metadata.h>
#include <machine/pc/bios.h>

#include "linux.h"
#include "bootstrap.h"
#include "libi386.h"
#include "btxv86.h"

static int linux_loadkernel(char *, u_int64_t, struct preloaded_file **);
static int linux_loadinitrd(char *, u_int64_t, struct preloaded_file **);
static int linux_exec(struct preloaded_file *);
static int linux_execinitrd(struct preloaded_file *);

struct file_format linux = { linux_loadkernel, linux_exec };
struct file_format linux_initrd = { linux_loadinitrd, linux_execinitrd };

uint32_t linux_text_len;
uint32_t linux_data_tmp_addr;
uint32_t linux_data_real_addr;
static size_t max_cmdline_size;

static void
test_addr(uint64_t addr, uint64_t length, vm_offset_t *result)
{
    vm_offset_t candidate;

    if (addr + length >= 0xa0000)
        length = 0xa0000 - addr;

    candidate = addr + length - (LINUX_CL_OFFSET + max_cmdline_size);
    if (candidate > LINUX_OLD_REAL_MODE_ADDR)
        candidate = LINUX_OLD_REAL_MODE_ADDR;
    if (candidate < addr)
        return;

    if (candidate > *result || *result == (vm_offset_t)-1)
        *result = candidate;
}

static vm_offset_t
find_real_addr(struct preloaded_file *fp)
{
    struct bios_smap *smap;
    struct file_metadata *md;
    int entries, i;
    vm_offset_t candidate = -1;

    md = file_findmetadata(fp, MODINFOMD_SMAP);
    if (md == NULL) {
        printf("no memory smap\n");
        return (candidate);
    }
    entries = md->md_size / sizeof (struct bios_smap);
    smap = (struct bios_smap *)md->md_data;
    for (i = 0; i < entries; i++) {
        if (smap[i].type != SMAP_TYPE_MEMORY)
            continue;
        if (smap[i].base >= 0xa0000)
            continue;
        test_addr(smap[i].base, smap[i].length, &candidate);
    }
    return (candidate);
}

static int
linux_loadkernel(char *filename, uint64_t dest, struct preloaded_file **result)
{
    struct linux_kernel_header lh;
    struct preloaded_file *fp;
    struct stat sb;
    ssize_t n;
    int fd, error = 0;
    int setup_sects, linux_big;
    unsigned long data, text;
    vm_offset_t mem;
    struct relocate_data *rdata;

    /*
     * relocater_data is space allocated in relocater_tramp.S
     * There is space for 3 instances + terminating zero in case
     * all 3 entries are used.
     */
    rdata = (struct relocate_data *)&relocater_data;

    if (filename == NULL)
        return (EFTYPE);

    /* is kernel already loaded? */
    fp = file_findfile(NULL, NULL);
    if (fp != NULL)
        return (EFTYPE);

    if ((fd = open(filename, O_RDONLY)) == -1)
        return (errno);

    if (fstat(fd, &sb) != 0) {
        printf("stat failed\n");
        error = errno;
        close(fd);
        return (error);
    }

    n = read(fd, &lh, sizeof (lh));
    if (n != sizeof (lh)) {
        printf("error reading kernel header\n");
        error = EIO;
        goto end;
    }

    if (lh.boot_flag != BOOTSEC_SIGNATURE) {
        printf("invalid magic number\n");
        error = EFTYPE;
        goto end;
    }

    setup_sects = lh.setup_sects;
    linux_big = 0;
    max_cmdline_size = 256;

    if (setup_sects > LINUX_MAX_SETUP_SECTS) {
        printf("too many setup sectors\n");
        error = EFTYPE;
        goto end;
    }

    fp = file_alloc();
    if (fp == NULL) {
        error = ENOMEM;
        goto end;
    }

    bios_addsmapdata(fp);

    if (lh.header == LINUX_MAGIC_SIGNATURE && lh.version >= 0x0200) {
        linux_big = lh.loadflags & LINUX_FLAG_BIG_KERNEL;
        lh.type_of_loader = LINUX_BOOT_LOADER_TYPE;

        if (lh.version >= 0x0206)
            max_cmdline_size = lh.cmdline_size + 1;

        linux_data_real_addr = find_real_addr(fp);
        if (linux_data_real_addr == -1) {
            printf("failed to detect suitable low memory\n");
            file_discard(fp);
            error = ENOMEM;
            goto end;
        }
        if (lh.version >= 0x0201) {
            lh.heap_end_ptr = LINUX_HEAP_END_OFFSET;
            lh.loadflags |= LINUX_FLAG_CAN_USE_HEAP;
        }
        if (lh.version >= 0x0202) {
            lh.cmd_line_ptr = linux_data_real_addr +
                LINUX_CL_OFFSET;
        } else {
            lh.cl_magic = LINUX_CL_MAGIC;
            lh.cl_offset = LINUX_CL_OFFSET;
            lh.setup_move_size = LINUX_CL_OFFSET + max_cmdline_size;
        }
    } else {
        /* old kernel */
        lh.cl_magic = LINUX_CL_MAGIC;
        lh.cl_offset = LINUX_CL_OFFSET;
        setup_sects = LINUX_DEFAULT_SETUP_SECTS;
        linux_data_real_addr = LINUX_OLD_REAL_MODE_ADDR;
    }
    if (setup_sects == 0)
        setup_sects = LINUX_DEFAULT_SETUP_SECTS;

    data = setup_sects << 9;
    text = sb.st_size - data - 512;

    /* temporary location of real mode part */
    linux_data_tmp_addr = LINUX_BZIMAGE_ADDR + text;

    if (!linux_big && text > linux_data_real_addr - LINUX_ZIMAGE_ADDR) {
        printf("Linux zImage is too big, use bzImage instead\n");
        file_discard(fp);
        error = EFBIG;
        goto end;
    }
    printf("   [Linux-%s, setup=0x%x, size=0x%x]\n",
        (linux_big ? "bzImage" : "zImage"), data, text);

    /* copy real mode part to place */
    i386_copyin(&lh, linux_data_tmp_addr, sizeof (lh));
    n = data + 512 - sizeof (lh);
    if (archsw.arch_readin(fd, linux_data_tmp_addr+sizeof (lh), n) != n) {
        printf("failed to read %s\n", filename);
        file_discard(fp);
        error = errno;
        goto end;
    }

    /* Clear the heap space. */
    if (lh.header != LINUX_MAGIC_SIGNATURE || lh.version < 0x0200) {
        memset(PTOV(linux_data_tmp_addr + ((setup_sects + 1) << 9)),
            0, (LINUX_MAX_SETUP_SECTS - setup_sects - 1) << 9);
    }

    mem = LINUX_BZIMAGE_ADDR;

    if (archsw.arch_readin(fd, mem, text) != text) {
        printf("failed to read %s\n", filename);
        file_discard(fp);
        error = EIO;
        goto end;
    }

    fp->f_name = strdup(filename);
    if (linux_big)
        fp->f_type = strdup("Linux bzImage");
    else
        fp->f_type = strdup("Linux zImage");

    /*
     * NOTE: f_addr and f_size is used here as hint for module
     * allocation, as module location will be f_addr + f_size.
     */
    fp->f_addr = linux_data_tmp_addr;
    fp->f_size = LINUX_SETUP_MOVE_SIZE;
    linux_text_len = text;

    if (linux_big == 0) {
        rdata[0].src = LINUX_BZIMAGE_ADDR;
        rdata[0].dest = LINUX_ZIMAGE_ADDR;
        rdata[0].size = text;
        rdata[1].src = linux_data_tmp_addr;
        rdata[1].dest = linux_data_real_addr;
        rdata[1].size = LINUX_SETUP_MOVE_SIZE;
        /* make sure the next entry is zeroed */
        rdata[2].src = 0;
        rdata[2].dest = 0;
        rdata[2].size = 0;
    } else {
        rdata[0].src = linux_data_tmp_addr;
        rdata[0].dest = linux_data_real_addr;
        rdata[0].size = LINUX_SETUP_MOVE_SIZE;
        /* make sure the next entry is zeroed */
        rdata[1].src = 0;
        rdata[1].dest = 0;
        rdata[1].size = 0;
    }

    *result = fp;
    setenv("kernelname", fp->f_name, 1);
end:
    close(fd);
    return (error);
}

static int
linux_exec(struct preloaded_file *fp)
{
    struct linux_kernel_header *lh = (struct linux_kernel_header *)
        PTOV(linux_data_tmp_addr);
    struct preloaded_file *mfp = fp->f_next;
    struct relocate_data *rdata;
    char *arg, *vga;
    char *src, *dst;
    int linux_big;
    uint32_t moveto, max_addr;
    uint16_t segment;
    struct i386_devdesc *rootdev;

    if (strcmp(fp->f_type, "Linux bzImage") == 0)
        linux_big = 1;
    else if (strcmp(fp->f_type, "Linux zImage") == 0)
        linux_big = 0;
    else
        return (EFTYPE);

    i386_getdev((void **)(&rootdev), fp->f_name, NULL);
    if (rootdev != NULL)
        relocator_edx = bd_unit2bios(rootdev->d_unit);

    rdata = (struct relocate_data *)&relocater_data;
    /*
     * command line
     * if not set in fp, read from boot-args env
     */
    if (fp->f_args == NULL)
        fp->f_args = getenv("boot-args");
    arg = fp->f_args;       /* it can still be NULL */

    /* video mode selection */
    if (arg && (vga = strstr(arg, "vga=")) != NULL) {
        char *value = vga + 4;
        uint16_t vid_mode;

        if (strncmp(value, "normal", 6) < 1)
            vid_mode = LINUX_VID_MODE_NORMAL;
        else if (strncmp(value, "ext", 3) < 1)
            vid_mode = LINUX_VID_MODE_EXTENDED;
        else if (strncmp(value, "ask", 3) < 1)
            vid_mode = LINUX_VID_MODE_ASK;
        else {
            long mode;
            errno = 0;

            /*
             * libstand sets ERANGE as only error case;
             * however, the actual value is 16bit, so
             * additional check is needed.
             */
            mode = strtol(value, NULL, 0);
            if (errno != 0 || mode >> 16 != 0 || mode == 0) {
                printf("bad value for video mode\n");
                return (EINTR);
            }
            vid_mode = (uint16_t) mode;
        }
        lh->vid_mode = vid_mode;
    }

    src = arg;
    dst = (char *)PTOV(linux_data_tmp_addr + LINUX_CL_OFFSET);
    if (src != NULL) {
        while (*src != 0 && dst < (char *)
            PTOV(linux_data_tmp_addr + LINUX_CL_END_OFFSET))
            *(dst++) = *(src++);
    }
    *dst = 0;

    /* set up module relocation */
    if (mfp != NULL) {
        moveto = (bios_extmem / 1024 + 0x400) << 10;
        moveto = (moveto - mfp->f_size) & 0xfffff000;
        max_addr = (lh->header == LINUX_MAGIC_SIGNATURE &&
            lh->version >= 0x0203 ?
            lh->initrd_addr_max : LINUX_INITRD_MAX_ADDRESS);
        if (moveto + mfp->f_size >= max_addr)
            moveto = (max_addr - mfp->f_size) & 0xfffff000;

        /*
         * XXX: Linux 2.3.xx has a bug in the memory range check,
         * so avoid the last page.
         * XXX: Linux 2.2.xx has a bug in the memory range check,
         * which is worse than that of Linux 2.3.xx, so avoid the
         * last 64kb. *sigh*
         */
        moveto -= 0x10000;

        /* need to relocate initrd first */
        if (linux_big == 0) {
            rdata[2].src = rdata[1].src;
            rdata[2].dest = rdata[1].dest;
            rdata[2].size = rdata[1].size;
            rdata[1].src = rdata[0].src;
            rdata[1].dest = rdata[0].dest;
            rdata[1].size = rdata[0].size;
            rdata[0].src = mfp->f_addr;
            rdata[0].dest = moveto;
            rdata[0].size = mfp->f_size;
        } else {
            rdata[1].src = rdata[0].src;
            rdata[1].dest = rdata[0].dest;
            rdata[1].size = rdata[0].size;
            rdata[0].src = mfp->f_addr;
            rdata[0].dest = moveto;
            rdata[0].size = mfp->f_size;
        }
        lh->ramdisk_image = moveto;
        lh->ramdisk_size = mfp->f_size;
    }

    segment = linux_data_real_addr >> 4;
    relocator_ds = segment;
    relocator_es = segment;
    relocator_fs = segment;
    relocator_gs = segment;
    relocator_ss = segment;
    relocator_sp = LINUX_ESP;
    relocator_ip = 0;
    relocator_cs = segment + 0x20;
    relocator_a20_enabled = 1;
    i386_copyin(relocater, 0x600, relocater_size);

    dev_cleanup();

    __exec((void *)0x600);

    panic("exec returned");

    return (EINTR);     /* not reached */
}

static int
linux_loadinitrd(char *filename, uint64_t dest, struct preloaded_file **result)
{
    struct preloaded_file *mfp;
    vm_offset_t mem;

    if (filename == NULL)
        return (EFTYPE);

    /* check if the kernel is loaded */
    mfp = file_findfile(NULL, "Linux bzImage");
    if (mfp == NULL)
        mfp = file_findfile(NULL, "Linux zImage");
    if (mfp == NULL)
        return (EFTYPE);

    mfp = file_loadraw(filename, "module", 0, NULL, 0);
    if (mfp == NULL)
        return (EFTYPE);
    *result = mfp;
    return (0);
}

static int linux_execinitrd(struct preloaded_file *pf)
{
    return (EFTYPE);
}