source: bootcd/isolinux/syslinux-6.03/com32/mboot/mboot.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
 *   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
 *
 *   Permission is hereby granted, free of charge, to any person
 *   obtaining a copy of this software and associated documentation
 *   files (the "Software"), to deal in the Software without
 *   restriction, including without limitation the rights to use,
 *   copy, modify, merge, publish, distribute, sublicense, and/or
 *   sell copies of the Software, and to permit persons to whom
 *   the Software is furnished to do so, subject to the following
 *   conditions:
 *
 *   The above copyright notice and this permission notice shall
 *   be included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 *
 * ----------------------------------------------------------------------- */

/*
 * mboot.c
 *
 * Module to load a multiboot kernel
 */

#include "mboot.h"

struct multiboot_info mbinfo;
struct syslinux_pm_regs regs;
struct my_options opt, set;

struct module_data {
    void *data;
    size_t len;
    const char *cmdline;
};

static int map_modules(struct module_data *modules, int nmodules)
{
    struct mod_list *mod_list;
    addr_t map_list = 0;
    size_t list_size = nmodules * sizeof *mod_list;
    int i;

    mod_list = malloc(list_size);
    if (!mod_list) {
        printf("Failed to allocate module list\n");
        return -1;
    }

    map_list = map_data(mod_list, list_size, 16, 0);
    if (!map_list) {
        printf("Cannot map module list\n");
        return -1;
    }

    for (i = 0; i < nmodules; i++) {
        addr_t mod_map = 0;
        addr_t cmd_map = 0;

        dprintf("Module %d cmdline: \"%s\"\n", i, modules[i].cmdline);

        cmd_map = map_string(modules[i].cmdline);

        mod_map = map_data(modules[i].data, modules[i].len, 4096, MAP_HIGH);
        if (!mod_map) {
            printf("Failed to map module (memory fragmentation issue?)\n");
            return -1;
        }
        mod_list[i].mod_start = mod_map;
        mod_list[i].mod_end = mod_map + modules[i].len;
        mod_list[i].cmdline = cmd_map;
        mod_list[i].pad = 0;
    }

    mbinfo.flags |= MB_INFO_MODS;
    mbinfo.mods_count = nmodules;
    mbinfo.mods_addr = map_list;
    return 0;
}

static int get_modules(char **argv, struct module_data **mdp)
{
    char **argp, **argx;
    struct module_data *mp;
    int rv;
    int module_count = 1;
    int arglen;
    const char module_separator[] = "---";

    for (argp = argv; *argp; argp++) {
        if (!strcmp(*argp, module_separator))
            module_count++;
    }

    *mdp = mp = malloc(module_count * sizeof(struct module_data));
    if (!mp) {
        error("Out of memory!\n");
        return -1;
    }

    argp = argv;
    while (*argp) {
        /* Note: it seems Grub transparently decompresses all compressed files,
           not just the primary kernel. */
        printf("Loading %s... ", *argp);
        rv = zloadfile(*argp, &mp->data, &mp->len);

        if (rv) {
            printf("failed!\n");
            return -1;
        }
        printf("ok\n");

        /* 
         * Note: Grub includes the kernel filename in the command line, so we
         * want to match that behavior.
         */
        arglen = 0;
        for (argx = argp; *argx && strcmp(*argx, module_separator); argx++)
            arglen += strlen(*argx) + 1;

        if (arglen == 0) {
            mp->cmdline = strdup("");
        } else {
            char *p;
            mp->cmdline = p = malloc(arglen);
            for (; *argp && strcmp(*argp, module_separator); argp++) {
                p = stpcpy(p, *argp);
                *p++ = ' ';
            }
            *--p = '\0';
        }
        mp++;
        if (*argp)
            argp++;             /* Advance past module_separator */
    }

    return module_count;
}

int main(int argc, char *argv[])
{
    int nmodules;
    struct module_data *modules;
    struct multiboot_header *mbh;
    bool keeppxe = false;

    openconsole(&dev_null_r, &dev_stdcon_w);

    (void)argc;                 /* Unused */
    argv++;

    while (*argv) {
        bool v = true;
        const char *p = *argv;

        if (!memcmp(p, "-no", 3)) {
            v = false;
            p += 3;
        }

        if (!strcmp(p, "-solaris")) {
            opt.solaris = v;
            set.solaris = true;
        } else if (!strcmp(p, "-aout")) {
            opt.aout = v;
            set.aout = true;
        } else
            break;
        argv++;
    }

    if (!*argv) {
        error
            ("Usage: mboot.c32 [opts] mboot_file args... [--- module args...]...\n"
             "Options:\n"
             "  -solaris  Enable Solaris DHCP information passing\n"
             "  -aout     Use the \"a.out kludge\" if enabled, even for ELF\n"
             "            This matches the Multiboot spec, but differs from Grub\n");
        return 1;
    }

    /* Load the files */
    nmodules = get_modules(argv, &modules);
    if (nmodules < 1) {
        error("No files found!\n");
        return 1;               /* Failure */
    }

    if (init_map())
        return 1;               /* Failed to allocate initial map */

    /*
     * Map the primary image.  This should be done before mapping anything
     * else, since it will have fixed address requirements.
     */
    mbh = map_image(modules[0].data, modules[0].len);
    if (!mbh)
        return 1;

    /* Map the mbinfo structure */
    regs.ebx = map_data(&mbinfo, sizeof mbinfo, 4, 0);
    if (!regs.ebx) {
        error("Failed to map Multiboot info structure!\n");
        return 1;
    }

    /* Map the primary command line */
    if (modules[0].cmdline) {
        mbinfo.cmdline = map_string(modules[0].cmdline);
        dprintf("Main cmdline: \"%s\"\n", modules[0].cmdline);
        if (mbinfo.cmdline)
            mbinfo.flags |= MB_INFO_CMDLINE;
    }

    /* Map auxilliary images */
    if (nmodules > 1) {
        if (map_modules(modules + 1, nmodules - 1))
            return 1;
    }

    /* Add auxilliary information */
    mboot_make_memmap();
    mboot_apm();
    mboot_syslinux_info();

    if (opt.solaris)
        mboot_solaris_dhcp_hack();

    /* Set the graphics mode if requested */
    set_graphics_mode(mbh, &mbinfo);

    /* Run it */
    mboot_run(keeppxe ? 3 : 0);
    error("mboot.c32: boot failed\n");
    return 1;
}