/* * cbfs-payload-linux * * Copyright (C) 2013 Patrick Georgi <patrick@georgi-clan.de> * * 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; version 2 of the License. * * 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. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "common.h" #include "cbfs.h" #include "linux.h" /* trampoline */ extern void *trampoline_start; extern long trampoline_size; /* * Current max number of segments include: * * 1. parameters * 2. kernel * 3. trampoline * 4. optional cmdline * 5. optional initrd * 6. terminating entry segment */ #define MAX_NUM_SEGMENTS 6 struct bzpayload { /* Input variables. */ int num_segments; struct cbfs_payload_segment segs[MAX_NUM_SEGMENTS]; struct buffer parameters; struct buffer kernel; struct buffer trampoline; struct buffer cmdline; struct buffer initrd; /* Output variables. */ enum comp_algo algo; comp_func_ptr compress; struct buffer output; size_t offset; struct cbfs_payload_segment *out_seg; }; static int bzp_init(struct bzpayload *bzp, enum comp_algo algo) { memset(bzp, 0, sizeof(*bzp)); /* * Need at least the terminating entry segment. */ bzp->num_segments = 1; bzp->algo = algo; bzp->compress = compression_function(algo); if (bzp->compress == NULL) { ERROR("Invalid compression algorithm specified.\n"); return -1; } return 0; } static int bzp_add_initrd(struct bzpayload *bzp, const char *fname) { if (fname == NULL) return 0; if (buffer_from_file(&bzp->initrd, fname)) { ERROR("could not open initrd.\n"); return -1; } bzp->num_segments++; return 0; } static void bzp_add_segment(struct bzpayload *bzp, struct buffer *b, void *data, size_t size) { buffer_init(b, NULL, data, size); bzp->num_segments++; } static int bzp_add_trampoline(struct bzpayload *bzp) { bzp_add_segment(bzp, &bzp->trampoline, trampoline_start, trampoline_size); return 0; } static int bzp_add_cmdline(struct bzpayload *bzp, char *cmdline) { if (cmdline == NULL) return 0; bzp_add_segment(bzp, &bzp->cmdline, cmdline, strlen(cmdline) + 1); return 0; } static int bzp_add_params(struct bzpayload *bzp, struct linux_params *params) { bzp_add_segment(bzp, &bzp->parameters, params, sizeof(*params)); return 0; } static int bzp_add_kernel(struct bzpayload *bzp, const struct buffer *in, size_t setup_size) { char *input = buffer_get(in); size_t kern_sz = buffer_size(in) - setup_size; bzp_add_segment(bzp, &bzp->kernel, &input[setup_size], kern_sz); return 0; } static int bzp_init_output(struct bzpayload *bzp, const char *name) { size_t sz = 0; sz += buffer_size(&bzp->parameters); sz += buffer_size(&bzp->kernel); sz += buffer_size(&bzp->trampoline); sz += buffer_size(&bzp->cmdline); sz += buffer_size(&bzp->initrd); bzp->offset = bzp->num_segments * sizeof(struct cbfs_payload_segment); sz += bzp->offset; if (buffer_create(&bzp->output, sz, name) != 0) return -1; bzp->out_seg = &bzp->segs[0]; return 0; } static void bzp_output_segment(struct bzpayload *bzp, struct buffer *b, uint32_t type, uint64_t load_addr) { struct buffer out; struct cbfs_payload_segment *seg; int len = 0; /* Don't process empty buffers. */ if (b != NULL && buffer_size(b) == 0) return; seg = bzp->out_seg; seg->type = type; seg->load_addr = load_addr; bzp->out_seg++; /* No buffer associated with segment. */ if (b == NULL) return; /* Use a temp buffer for easier management. */ buffer_splice(&out, &bzp->output, bzp->offset, buffer_size(b)); seg->mem_len = buffer_size(b); seg->offset = bzp->offset; bzp->compress(buffer_get(b), buffer_size(b), buffer_get(&out), &len); seg->compression = bzp->algo; seg->len = len; /* Update output offset. */ bzp->offset += len; } /* TODO: * handle special arguments * mem= argument - only affects loading decisions (kernel + initrd), not e820 -> build time * vga= argument (FILO ignores this) * add support for more parameters to trampoline: * alt_mem_k, ext_mem_k (not strictly necessary since e820 takes precedence) * framebuffer/console values * * larger work: * is compress() safe to use in a size constrained buffer? ie. do(es) the * compression algorithm(s) stop once the compression result reaches input * size (ie. incompressible data)? */ int parse_bzImage_to_payload(const struct buffer *input, struct buffer *output, const char *initrd_name, char *cmdline, enum comp_algo algo) { struct bzpayload bzp; unsigned int initrd_base = 64*1024*1024; struct linux_header *hdr = (struct linux_header *)input->data; unsigned int setup_size = 4 * 512; if (bzp_init(&bzp, algo) != 0) return -1; if (bzp_add_trampoline(&bzp) != 0) return -1; if (bzp_add_initrd(&bzp, initrd_name) != 0) return -1; if (bzp_add_cmdline(&bzp, cmdline) != 0) return -1; if (hdr->setup_sects != 0) { setup_size = (hdr->setup_sects + 1) * 512; } /* Setup parameter block. Imitate FILO. */ struct linux_params params; params.mount_root_rdonly = hdr->root_flags; params.orig_root_dev = hdr->root_dev; /* Sensible video defaults. Might be overridden on runtime by coreboot tables. */ params.orig_video_mode = 3; params.orig_video_cols = 80; params.orig_video_lines = 25; params.orig_video_isVGA = 1; params.orig_video_points = 16; params.loader_type = 0xff; /* Unregistered Linux loader */ if (cmdline != NULL) { if (hdr->protocol_version < 0x202) { params.cl_magic = CL_MAGIC_VALUE; params.cl_offset = COMMAND_LINE_LOC - LINUX_PARAM_LOC; } else { params.cmd_line_ptr = COMMAND_LINE_LOC; } } unsigned long kernel_base = 0x100000; if ((hdr->protocol_version >= 0x200) && (!hdr->loadflags & 1)) { kernel_base = 0x1000; /* zImage kernel */ } /* kernel prefers an address, so listen */ if ((hdr->protocol_version >= 0x20a) && (!(hdr->pref_address >> 32))) { kernel_base = hdr->pref_address; } if (hdr->protocol_version >= 0x205) { params.relocatable_kernel = hdr->relocatable_kernel; params.kernel_alignment = hdr->kernel_alignment; if (hdr->relocatable_kernel != 0) { /* 16 MB should be way outside coreboot's playground, * so if possible (relocatable kernel) use that to * avoid a trampoline copy. */ kernel_base = ALIGN(16*1024*1024, params.kernel_alignment); } } /* We have a trampoline and use that, but it can simply use * this information for its jump to real Linux. */ params.kernel_start = kernel_base; if (bzp_add_kernel(&bzp, input, setup_size) != 0) return -1; if (buffer_size(&bzp.initrd) != 0) { /* TODO: this is a bit of a hack. Linux recommends to store * initrd near to end-of-mem, but that's hard to do on build * time. It definitely fails to read the image if it's too * close to the kernel, so give it some room. */ initrd_base = kernel_base + buffer_size(&bzp.kernel); initrd_base = ALIGN(initrd_base, 16*1024*1024); params.initrd_start = initrd_base; params.initrd_size = buffer_size(&bzp.initrd); } if (bzp_add_params(&bzp, ¶ms) != 0) return -1; if (bzp_init_output(&bzp, input->name) != 0) return -1; /* parameter block */ bzp_output_segment(&bzp, &bzp.parameters, PAYLOAD_SEGMENT_DATA, LINUX_PARAM_LOC); /* code block */ bzp_output_segment(&bzp, &bzp.kernel, PAYLOAD_SEGMENT_CODE, kernel_base); /* trampoline */ bzp_output_segment(&bzp, &bzp.trampoline, PAYLOAD_SEGMENT_CODE, TRAMPOLINE_ENTRY_LOC); /* cmdline */ bzp_output_segment(&bzp, &bzp.cmdline, PAYLOAD_SEGMENT_DATA, COMMAND_LINE_LOC); /* initrd */ bzp_output_segment(&bzp, &bzp.initrd, PAYLOAD_SEGMENT_DATA, initrd_base); /* Terminating entry segment. */ bzp_output_segment(&bzp, NULL, PAYLOAD_SEGMENT_ENTRY, TRAMPOLINE_ENTRY_LOC); /* Set size of buffer taking into account potential compression. */ buffer_set_size(&bzp.output, bzp.offset); /* Make passed-in output buffer be valid. */ buffer_clone(output, &bzp.output); /* Serialize the segments with the correct encoding. */ xdr_segs(output, bzp.segs, bzp.num_segments); return 0; }