lkrn.c File Reference

Linux kernel image format. More...

#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/image.h>
#include <ipxe/memmap.h>
#include <ipxe/uaccess.h>
#include <ipxe/segment.h>
#include <ipxe/initrd.h>
#include <ipxe/io.h>
#include <ipxe/fdt.h>
#include <ipxe/init.h>
#include <ipxe/lkrn.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	lkrn_parse (struct image *image, struct lkrn_context *ctx)
	Parse kernel image. More...
static int	lkrn_ram (struct image *image, struct lkrn_context *ctx)
	Locate start of RAM. More...
static int	lkrn_exec (struct image *image)
	Execute kernel image. More...
static int	lkrn_probe (struct image *image)
	Probe kernel image. More...
struct image_type lkrn_image_type	__image_type (PROBE_NORMAL)
	Linux kernel image type. More...
static int	zimg_parse (struct image *image, struct zimg_context *zctx)
	Parse compressed kernel image. More...
static int	zimg_extract (struct image *image, struct image *extracted)
	Extract compresed kernel image. More...
static int	zimg_probe (struct image *image)
	Probe compressed kernel image. More...

Detailed Description

Linux kernel image format.

Definition in file lkrn.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

lkrn_parse()

static int lkrn_parse ( struct image *  image, struct lkrn_context *  ctx  )

static

Parse kernel image.

Parameters

image	Kernel image
ctx	Kernel image context

Return values

rc	Return status code

Definition at line 53 of file lkrn.c.

                                                                        {
        const struct lkrn_header *hdr;

        /* Initialise context */
        memset ( ctx, 0, sizeof ( *ctx ) );

        /* Read image header */
        if ( image->len < sizeof ( *hdr ) ) {
                DBGC ( image, "LKRN %s too short for header\n", image->name );
                return -ENOEXEC;
        }
        hdr = image->data;

        /* Check magic value */
        if ( hdr->magic != cpu_to_le32 ( LKRN_MAGIC_ARCH ) ) {
                DBGC ( image, "LKRN %s bad magic value %#08x\n",
                       image->name, le32_to_cpu ( hdr->magic ) );
                return -ENOEXEC;
        }

        /* Record load offset */
        ctx->offset = le64_to_cpu ( hdr->text_offset );
        if ( ctx->offset & ( ctx->offset - 1 ) ) {
                DBGC ( image, "LKRN %s offset %#zx is not a power of two\n",
                       image->name, ctx->offset );
                return -ENOEXEC;
        }

        /* Record and check image size */
        ctx->filesz = image->len;
        ctx->memsz = le64_to_cpu ( hdr->image_size );
        if ( ctx->filesz > ctx->memsz ) {
                DBGC ( image, "LKRN %s invalid image size %#zx/%#zx\n",
                       image->name, ctx->filesz, ctx->memsz );
                return -ENOEXEC;
        }

        return 0;
}

References cpu_to_le32, ctx, image::data, DBGC, ENOEXEC, hdr, le32_to_cpu, le64_to_cpu, image::len, LKRN_MAGIC_ARCH, memset(), and image::name.

Referenced by lkrn_exec(), and lkrn_probe().

lkrn_ram()

static int lkrn_ram ( struct image *  image, struct lkrn_context *  ctx  )

static

Locate start of RAM.

Parameters

image	Kernel image
ctx	Kernel image context

Return values

rc	Return status code

Definition at line 100 of file lkrn.c.

                                                                      {
        struct memmap_region region;

        /* Locate start of RAM */
        for_each_memmap ( &region, 0 ) {
                DBGC_MEMMAP ( image, &region );
                if ( ! ( region.flags & MEMMAP_FL_MEMORY ) )
                        continue;
                ctx->ram = region.min;
                DBGC ( image, "LKRN %s RAM starts at %#08lx\n",
                       image->name, ctx->ram );
                return 0;
        }

        DBGC ( image, "LKRN %s found no RAM\n", image->name );
        return -ENOTSUP;
}

References ctx, DBGC, DBGC_MEMMAP, ENOTSUP, memmap_region::flags, for_each_memmap, MEMMAP_FL_MEMORY, memmap_region::min, and image::name.

Referenced by lkrn_exec().

lkrn_exec()

static int lkrn_exec ( struct image *  image )

static

Execute kernel image.

Parameters

image

Kernel image

Return values

rc	Return status code

Definition at line 124 of file lkrn.c.

                                             {
        static struct image fdtimg = {
                .refcnt = REF_INIT ( free_image ),
                .name = "<FDT>",
                .flags = ( IMAGE_STATIC | IMAGE_STATIC_NAME ),
        };
        struct lkrn_context ctx;
        struct memmap_region region;
        struct fdt_header *fdt;
        size_t initrdsz;
        size_t totalsz;
        void *dest;
        int rc;

        /* Parse header */
        if ( ( rc = lkrn_parse ( image, &ctx ) ) != 0 )
                goto err_parse;

        /* Locate start of RAM */
        if ( ( rc = lkrn_ram ( image, &ctx ) ) != 0 )
                goto err_ram;

        /* Place kernel at specified address from start of RAM */
        ctx.entry = ( ctx.ram + ctx.offset );
        DBGC ( image, "LKRN %s loading to [%#08lx,%#08lx,%#08lx)\n",
               image->name, ctx.entry, ( ctx.entry + ctx.filesz ),
               ( ctx.entry + ctx.memsz ) );

        /* Place initrd after kernel, aligned to the kernel's image offset */
        ctx.initrd = ( ctx.ram + initrd_align ( ctx.offset + ctx.memsz ) );
        ctx.initrd = ( ( ctx.initrd + ctx.offset - 1 ) & ~( ctx.offset - 1 ) );
        initrdsz = initrd_len();
        if ( initrdsz ) {
                DBGC ( image, "LKRN %s initrd at [%#08lx,%#08lx)\n",
                       image->name, ctx.initrd, ( ctx.initrd + initrdsz ) );
        }

        /* Place device tree after initrd */
        ctx.fdt = ( ctx.initrd + initrd_align ( initrdsz ) );

        /* Construct device tree and post-initrd image */
        if ( ( rc = fdt_create ( &fdt, image->cmdline, ctx.initrd,
                                 initrdsz ) ) != 0 ) {
                goto err_fdt;
        }
        fdtimg.data = fdt;
        fdtimg.len = be32_to_cpu ( fdt->totalsize );
        list_add_tail ( &fdtimg.list, &images );
        DBGC ( image, "LKRN %s FDT at [%08lx,%08lx)\n",
               image->name, ctx.fdt, ( ctx.fdt + fdtimg.len ) );

        /* Find post-reshuffle region */
        if ( ( rc = initrd_region ( initrdsz, &region ) ) != 0 ) {
                DBGC ( image, "LKRN %s no available region: %s\n",
                       image->name, strerror ( rc ) );
                goto err_region;
        }

        /* Check that everything can be placed at its target addresses */
        totalsz = ( ctx.fdt + fdtimg.len - ctx.ram );
        if ( ( ctx.entry >= region.min ) &&
             ( ( ctx.offset + totalsz ) <= memmap_size ( &region ) ) ) {
                /* Target addresses are within the reshuffle region */
                DBGC ( image, "LKRN %s fits within reshuffle region\n",
                       image->name );
        } else {
                /* Target addresses are outside the reshuffle region */
                if ( ( rc = prep_segment ( phys_to_virt ( ctx.entry ),
                                           totalsz, totalsz ) ) != 0 ) {
                        DBGC ( image, "LKRN %s could not prepare segment: "
                               "%s\n", image->name, strerror ( rc ) );
                        goto err_segment;
                }
        }

        /* This is the point of no return: we are about to reshuffle
         * and thereby destroy the external heap.  No errors are
         * allowed to occur after this point.
         */

        /* Shut down ready for boot */
        shutdown_boot();

        /* Prepend kernel to reshuffle list, reshuffle, and remove kernel */
        list_add ( &image->list, &images );
        initrd_reshuffle();
        list_del ( &image->list );

        /* Load kernel to entry point and zero bss */
        dest = phys_to_virt ( ctx.entry );
        memmove ( dest, image->data, ctx.filesz );
        memset ( ( dest + ctx.filesz ), 0, ( ctx.memsz - ctx.filesz ) );

        /* Load initrds and device tree */
        dest = phys_to_virt ( ctx.initrd );
        initrd_load_all ( dest );

        /* Jump to kernel entry point */
        DBGC ( image, "LKRN %s jumping to kernel at %#08lx\n",
               image->name, ctx.entry );
        lkrn_jump ( ctx.entry, ctx.fdt );

        /* There is no way for the image to return, since we provide
         * no return address.
         */
        assert ( 0 );

        return -ECANCELED; /* -EIMPOSSIBLE */

 err_segment:
 err_region:
        list_del ( &fdtimg.list );
        fdt_remove ( fdt );
 err_fdt:
 err_ram:
 err_parse:
        return rc;
}

References assert(), be32_to_cpu, image::cmdline, ctx, image::data, DBGC, dest, ECANCELED, fdt_create(), fdt_remove(), free_image(), IMAGE_STATIC, IMAGE_STATIC_NAME, images, initrd_align(), initrd_len, initrd_load_all(), initrd_region(), initrd_reshuffle(), image::len, image::list, list_add, list_add_tail, list_del, lkrn_jump(), lkrn_parse(), lkrn_ram(), memmap_size(), memmove(), memset(), memmap_region::min, image::name, prep_segment(), rc, REF_INIT, image::refcnt, shutdown_boot(), and strerror().

lkrn_probe()

static int lkrn_probe ( struct image *  image )

static

Probe kernel image.

Parameters

image

Kernel image

Return values

rc	Return status code

Definition at line 249 of file lkrn.c.

                                              {
        struct lkrn_context ctx;
        int rc;

        /* Parse header */
        if ( ( rc = lkrn_parse ( image, &ctx ) ) != 0 )
                return rc;

        DBGC ( image, "LKRN %s is a Linux kernel\n", image->name );
        return 0;
}

References ctx, DBGC, lkrn_parse(), image::name, and rc.

__image_type()

struct image_type lkrn_image_type __image_type

(

PROBE_NORMAL

)

Linux kernel image type.

Linux kernel compressed image type.

zimg_parse()

static int zimg_parse ( struct image *  image, struct zimg_context *  zctx  )

static

Parse compressed kernel image.

Parameters

image	Compressed kernel image
zctx	Compressed kernel image context

Return values

rc	Return status code

Definition at line 275 of file lkrn.c.

                                                                         {
        const struct zimg_header *zhdr;

        /* Initialise context */
        memset ( zctx, 0, sizeof ( *zctx ) );

        /* Parse header */
        if ( image->len < sizeof ( *zhdr ) ) {
                DBGC ( image, "ZIMG %s too short for header\n",
                       image->name );
                return -ENOEXEC;
        }
        zhdr = image->data;

        /* Check magic value */
        if ( zhdr->magic != cpu_to_le32 ( ZIMG_MAGIC ) ) {
                DBGC ( image, "ZIMG %s bad magic value %#08x\n",
                       image->name, le32_to_cpu ( zhdr->magic ) );
                return -ENOEXEC;
        }

        /* Record and check offset and length */
        zctx->offset = le32_to_cpu ( zhdr->offset );
        zctx->len = le32_to_cpu ( zhdr->len );
        if ( ( zctx->offset > image->len ) ||
             ( zctx->len > ( image->len - zctx->offset ) ) ) {
                DBGC ( image, "ZIMG %s bad range [+%#zx,+%#zx)/%#zx\n",
                       image->name, zctx->offset,
                       (zctx->offset + zctx->len ), image->len );
                return -ENOEXEC;
        }

        /* Record compression type */
        zctx->type.raw = zhdr->type;

        return 0;
}

References cpu_to_le32, image::data, DBGC, ENOEXEC, le32_to_cpu, image::len, zimg_header::len, zimg_context::len, zimg_header::magic, memset(), image::name, zimg_header::offset, zimg_context::offset, zimg_context::raw, zimg_header::type, zimg_context::type, and ZIMG_MAGIC.

Referenced by zimg_extract(), and zimg_probe().

zimg_extract()

static int zimg_extract ( struct image *  image, struct image *  extracted  )

static

Extract compresed kernel image.

Parameters

image	Compressed kernel image
extracted	Extracted image

Return values

rc	Return status code

Definition at line 320 of file lkrn.c.

                                                                         {
        struct zimg_context zctx;
        const void *payload;
        int rc;

        /* Parse header */
        if ( ( rc = zimg_parse ( image, &zctx ) ) != 0 )
                return rc;
        DBGC ( image, "ZIMG %s has %s-compressed payload at [+%#zx,+%#zx)\n",
               image->name, zctx.type.string, zctx.offset,
               ( zctx.offset + zctx.len ) );

        /* Extract compressed payload */
        payload = ( image->data + zctx.offset );
        if ( ( rc = image_set_data ( extracted, payload, zctx.len ) ) != 0 ) {
                DBGC ( image, "ZIMG %s could not extract: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }

        return 0;
}

References image::data, DBGC, image_set_data(), zimg_context::len, image::name, zimg_context::offset, rc, strerror(), zimg_context::string, zimg_context::type, and zimg_parse().

zimg_probe()

static int zimg_probe ( struct image *  image )

static

Probe compressed kernel image.

Parameters

image

Compressed kernel image

Return values

rc	Return status code

Definition at line 349 of file lkrn.c.

                                              {
        struct zimg_context zctx;
        int rc;

        /* Parse header */
        if ( ( rc = zimg_parse ( image, &zctx ) ) != 0 )
                return rc;

        DBGC ( image, "ZIMG %s is a %s-compressed Linux kernel\n",
               image->name, zctx.type.string );
        return 0;
}

References DBGC, image::name, rc, zimg_context::string, zimg_context::type, and zimg_parse().