bootstub.c

// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include <efi.h>
#include <efilib.h>

// Here's a struct to locate the pointers we need to update in the zeropage
// structure. Everything else should already be hardcoded at compile time.
// See arch/x86/include/asm/bootparam.h in the kernel source for the real deal.
struct hacked_params {
    uint8_t  pad0[0x1c0];
    uint32_t v0206_efi_signature;          /* 1c0 */
    uint32_t v0206_efi_system_table;       /* 1c4 */
    uint32_t v0206_efi_mem_desc_size;      /* 1c8 */
    uint32_t v0206_efi_mem_desc_version;   /* 1cc */
    uint32_t v0206_efi_mmap;               /* 1d0 */
    uint32_t v0206_efi_mmap_size;          /* 1d4 */
    uint32_t v0206_efi_system_table_hi;    /* 1d8 */
    uint32_t v0206_efi_mmap_hi;            /* 1dc */
    uint8_t  pad1[0x214 - 0x1e0];
    uint32_t code32_start;                 /* 214 */
    uint8_t  pad2[0x228 - 0x218];
    uint32_t cmd_line_ptr;                 /* 228 */
} __attribute__ ((packed));


// Find where the preloaded params struct is located in RAM. At the moment
// we're assuming that it immediately precedes the start of the bootstub,
// aligned to a 4K boundary, because that's where our build system puts it.
struct hacked_params *find_params_struct(UINTN bootstub_location)
{
    return (struct hacked_params *)(bootstub_location - 0x1000);
}

// Copy a string to the right within a buffer.
static void shove_over(char *src, char *dst)
{
    int i = 0;
    for (i=0; src[i]; i++)
        ;                               // find strlen(src)
    dst += i;
    src += i;
    i++;                                // also terminating '\0';
    while (i--)
        *dst-- = *src--;
}

// sprintf(dst,"%02x",val)
static void one_byte(char *dst, uint8_t val)
{
    dst[0] = "0123456789abcdef"[(val >> 4) & 0x0F];
    dst[1] = "0123456789abcdef"[val & 0x0F];
}

// Display a GUID in canonical form
static void emit_guid(char *dst, uint8_t *guid)
{
    one_byte(dst, guid[3]); dst += 2;
    one_byte(dst, guid[2]); dst += 2;
    one_byte(dst, guid[1]); dst += 2;
    one_byte(dst, guid[0]); dst += 2;
    *dst++ = '-';
    one_byte(dst, guid[5]); dst += 2;
    one_byte(dst, guid[4]); dst += 2;
    *dst++ = '-';
    one_byte(dst, guid[7]); dst += 2;
    one_byte(dst, guid[6]); dst += 2;
    *dst++ = '-';
    one_byte(dst, guid[8]); dst += 2;
    one_byte(dst, guid[9]); dst += 2;
    *dst++ = '-';
    one_byte(dst, guid[10]); dst += 2;
    one_byte(dst, guid[11]); dst += 2;
    one_byte(dst, guid[12]); dst += 2;
    one_byte(dst, guid[13]); dst += 2;
    one_byte(dst, guid[14]); dst += 2;
    one_byte(dst, guid[15]); dst += 2;
}


// Replace any %D with the device letter, and replace any %P with the partition
// number. For example, ("root=/dev/sd%D%P",2,3) gives "root=/dev/sdc3".
// Replace any %U with the human-readable form of the GUID (if provided). The
// input string must be mutable and end with a trailing '\0', and have enough
// room for all the expansion.
static void update_cmdline_inplace(char *src, int devnum, int partnum,
                                   uint8_t *guid)
{
    char *dst;

    // Use sane values (sda3) for ridiculous inputs.
    if (devnum < 0 || devnum > 25 || partnum < 1 || partnum > 99)
    {
        devnum = 0;
        partnum = 3;
    }

    for( dst = src; *src; src++, dst++ )
    {
        if ( src[0] == '%' )
        {
            switch (src[1])
            {
            case 'P':
                if (partnum > 9)
                    *dst++ = '0' + (partnum / 10);
                *dst = '0' + partnum % 10;
                src++;
                break;
            case 'D':
                *dst = 'a' + devnum;
                src++;
                break;
            case 'U':
                if (guid) {
                    shove_over(src+2, dst+36);
                    emit_guid(dst, guid);
                    src = dst+35;
                    dst += 35;
                }
            default:
                *dst = *src;
            }
        }
        else if (dst != src)
            *dst = *src;
    }
    *dst = '\0';
}

// This is handy to write status codes to the LEDs for debugging.
static __inline void port80w (unsigned short int value)
{
    __asm__ __volatile__ ("outw %w0,$0x80": :"a" (value));
}


// The code to switch to 32-bit mode and start the kernel.
extern void trampoline(unsigned long, void *);


// Reserve some space for the EFI memory map.
// Danger Will Robinson: this is just a guess at the size and alignment. If
// it's too small, the EFI GetMemoryMap() call will fail.
// FIXME: Make the size dynamic? Retry with larger size on failure?
static unsigned char mmap_buf[0x2000] __attribute__ ((aligned(0x200)));

// Parameters that we're given by the BIOS
typedef struct cros_boot_info {
    UINTN drive_number;                 // 0 - 25
    UINTN partition_number;             // 1 - 99
    UINTN original_address;             // our RAM address prior to execution
    // The guid stuff was added later, so we need to consider it optional, at
    // least for testing.
    uint8_t partition_guid[16];         // kernel partition GUID
} cros_boot_info_t;


// Here's the entry point. It will be loaded by the BIOS as a standard EFI
// application, which means it will be relocated.
EFI_STATUS efi_main (EFI_HANDLE image, EFI_SYSTEM_TABLE *systab)
{
    UINTN mmap_size = sizeof(mmap_buf);
    UINTN mmap_key = 0;
    UINTN desc_size = 0;
    UINT32 desc_version = 0;
    EFI_LOADED_IMAGE *loaded_image;
    EFI_GUID loaded_image_protocol = LOADED_IMAGE_PROTOCOL;
    EFI_GUID zero_guid = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
    void *guid_ptr;

    // I'm here.
    port80w(0xb0b0);

    // Find the parameters that the BIOS has passed to us.
    if (uefi_call_wrapper(systab->BootServices->HandleProtocol, 3,
                          image,
                          &loaded_image_protocol,
                          &loaded_image) != 0)
    {
        uefi_call_wrapper(systab->ConOut->OutputString, 3, systab->ConOut,
                          L"Can't locate protocol\r\n");
        goto fail;
    }
    cros_boot_info_t *booting = loaded_image->LoadOptions;
    if (loaded_image->LoadOptionsSize < 40) // DWR: min size including guid
        guid_ptr = &zero_guid;
    else
        guid_ptr = booting->partition_guid;

    // Find the parameters that we're passing to the kernel.
    struct hacked_params *params = find_params_struct(booting->original_address);

    // Update the kernel command-line string with the correct rootfs device
    update_cmdline_inplace((char *)(unsigned long)(params->cmd_line_ptr),
                           booting->drive_number,
                           booting->partition_number + 1,
                           guid_ptr);

    // Obtain the EFI memory map.
    if (uefi_call_wrapper(systab->BootServices->GetMemoryMap, 5,
                          &mmap_size, mmap_buf, &mmap_key,
                          &desc_size, &desc_version) != 0)
    {
        uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut,
                          L"Can't get memory map\r\n");
        goto fail;
    }

    // Update the pointers to the EFI memory map and system table.
    params->v0206_efi_signature = ('4' << 24 | '6' << 16 | 'L' << 8 | 'E');
    params->v0206_efi_system_table = (uint32_t) (unsigned long)systab;
    params->v0206_efi_mem_desc_size = desc_size;
    params->v0206_efi_mem_desc_version = desc_version;
    params->v0206_efi_mmap = (uint32_t) (unsigned long)mmap_buf;
    params->v0206_efi_mmap_size = mmap_size;
    params->v0206_efi_mmap_hi = (uint32_t)((uint64_t)mmap_buf >> 32);
    params->v0206_efi_system_table_hi = (uint32_t) ((uint64_t)systab >> 32);


    // Done with BIOS.
    if (uefi_call_wrapper(systab->BootServices->ExitBootServices, 2,
                          image, mmap_key) != 0)
    {
        uefi_call_wrapper(systab->ConOut->OutputString, 2, systab->ConOut,
                          L"Can't exit boot services\r\n");
        goto fail;
    }


    // Trampoline to 32-bit entry point. Should never return.
    trampoline(params->code32_start, params);

fail:

    // Bad Things happened.
    port80w(0xeeee);

    return EFI_LOAD_ERROR;
}