util/cbfstool/cbfs-payload-linux.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "common.h"
   8 #include "cbfs.h"
   9 #include "linux.h"
  10
  11 /* trampoline */
  12 extern unsigned char trampoline[];
  13 extern unsigned int trampoline_len;
  14
  15 /*
  16  * Current max number of segments include:
  17  *
  18  * 1. parameters
  19  * 2. kernel
  20  * 3. trampoline
  21  * 4. optional cmdline
  22  * 5. optional initrd
  23  * 6. terminating entry segment
  24  */
  25 #define MAX_NUM_SEGMENTS 6
  26
  27 struct bzpayload {
  28         /* Input variables. */
  29         int num_segments;
  30         struct cbfs_payload_segment segs[MAX_NUM_SEGMENTS];
  31         struct buffer parameters;
  32         struct buffer kernel;
  33         struct buffer trampoline;
  34         struct buffer cmdline;
  35         struct buffer initrd;
  36         /* Output variables. */
  37         enum cbfs_compression algo;
  38         comp_func_ptr compress;
  39         struct buffer output;
  40         size_t offset;
  41         struct cbfs_payload_segment *out_seg;
  42 };
  43
  44 static int bzp_init(struct bzpayload *bzp, enum cbfs_compression algo)
  45 {
  46         memset(bzp, 0, sizeof(*bzp));
  47
  48         /*
  49          * Need at least the terminating entry segment.
  50          */
  51         bzp->num_segments = 1;
  52
  53         bzp->algo = algo;
  54         bzp->compress = compression_function(algo);
  55         if (bzp->compress == NULL) {
  56                 ERROR("Invalid compression algorithm specified.\n");
  57                 return -1;
  58         }
  59
  60         return 0;
  61 }
  62
  63 static int bzp_add_initrd(struct bzpayload *bzp, const char *fname)
  64 {
  65         if (fname == NULL)
  66                 return 0;
  67
  68         if (buffer_from_file(&bzp->initrd, fname)) {
  69                 ERROR("could not open initrd.\n");
  70                 return -1;
  71         }
  72
  73         bzp->num_segments++;
  74
  75         return 0;
  76 }
  77
  78 static void bzp_add_segment(struct bzpayload *bzp, struct buffer *b, void *data,
  79                             size_t size)
  80 {
  81         buffer_init(b, NULL, data, size);
  82         bzp->num_segments++;
  83 }
  84
  85 static int bzp_add_trampoline(struct bzpayload *bzp)
  86 {
  87         bzp_add_segment(bzp, &bzp->trampoline, trampoline,
  88                         trampoline_len);
  89         return 0;
  90 }
  91
  92 static int bzp_add_cmdline(struct bzpayload *bzp, char *cmdline)
  93 {
  94         if (cmdline == NULL)
  95                 return 0;
  96
  97         bzp_add_segment(bzp, &bzp->cmdline, cmdline, strlen(cmdline) + 1);
  98
  99         return 0;
 100 }
 101
 102 static int bzp_add_params(struct bzpayload *bzp, struct linux_params *params)
 103 {
 104         bzp_add_segment(bzp, &bzp->parameters, params, sizeof(*params));
 105
 106         return 0;
 107 }
 108
 109 static int bzp_add_kernel(struct bzpayload *bzp, const struct buffer *in,
 110                           size_t setup_size)
 111 {
 112         char *input = buffer_get(in);
 113         size_t kern_sz = buffer_size(in) - setup_size;
 114
 115         bzp_add_segment(bzp, &bzp->kernel, &input[setup_size], kern_sz);
 116
 117         return 0;
 118 }
 119
 120 static int bzp_init_output(struct bzpayload *bzp, const char *name)
 121 {
 122         size_t sz = 0;
 123
 124         sz += buffer_size(&bzp->parameters);
 125         sz += buffer_size(&bzp->kernel);
 126         sz += buffer_size(&bzp->trampoline);
 127         sz += buffer_size(&bzp->cmdline);
 128         sz += buffer_size(&bzp->initrd);
 129
 130         bzp->offset = bzp->num_segments * sizeof(struct cbfs_payload_segment);
 131         sz += bzp->offset;
 132
 133         if (buffer_create(&bzp->output, sz, name) != 0)
 134                 return -1;
 135
 136         bzp->out_seg = &bzp->segs[0];
 137
 138         return 0;
 139 }
 140
 141 static void bzp_output_segment(struct bzpayload *bzp, struct buffer *b,
 142                                uint32_t type, uint64_t load_addr)
 143 {
 144         struct buffer out;
 145         struct cbfs_payload_segment *seg;
 146         int len = 0;
 147
 148         /* Don't process empty buffers. */
 149         if (b != NULL && buffer_size(b) == 0)
 150                 return;
 151
 152         seg = bzp->out_seg;
 153         seg->type = type;
 154         seg->load_addr = load_addr;
 155         bzp->out_seg++;
 156
 157         /* No buffer associated with segment. */
 158         if (b == NULL)
 159                 return;
 160
 161         /* Use a temp buffer for easier management. */
 162         buffer_splice(&out, &bzp->output, bzp->offset, buffer_size(b));
 163
 164         seg->mem_len = buffer_size(b);
 165         seg->offset = bzp->offset;
 166         bzp->compress(buffer_get(b), buffer_size(b), buffer_get(&out), &len);
 167         seg->compression = bzp->algo;
 168         seg->len = len;
 169
 170         /* Update output offset. */
 171         bzp->offset += len;
 172 }
 173
 174 /* TODO:
 175  *   handle special arguments
 176  *     mem= argument - only affects loading decisions (kernel + initrd), not e820 -> build time
 177  *     vga= argument (FILO ignores this)
 178  *   add support for more parameters to trampoline:
 179  *     alt_mem_k, ext_mem_k (not strictly necessary since e820 takes precedence)
 180  *     framebuffer/console values
 181  *
 182  *  larger work:
 183  *     is compress() safe to use in a size constrained buffer? ie. do(es) the
 184  *     compression algorithm(s) stop once the compression result reaches input
 185  *     size (ie. incompressible data)?
 186  */
 187 int parse_bzImage_to_payload(const struct buffer *input,
 188                              struct buffer *output, const char *initrd_name,
 189                              char *cmdline, enum cbfs_compression algo)
 190 {
 191         struct bzpayload bzp;
 192         unsigned int initrd_base = 64*1024*1024;
 193         struct linux_header *hdr = (struct linux_header *)input->data;
 194         unsigned int setup_size = 4 * 512;
 195
 196         if (bzp_init(&bzp, algo) != 0)
 197                 return -1;
 198
 199         if (bzp_add_trampoline(&bzp) != 0)
 200                 return -1;
 201
 202         if (bzp_add_initrd(&bzp, initrd_name) != 0)
 203                 return -1;
 204
 205         if (bzp_add_cmdline(&bzp, cmdline) != 0)
 206                 return -1;
 207
 208         if (hdr->setup_sects != 0) {
 209                 setup_size = (hdr->setup_sects + 1) * 512;
 210         } else {
 211                 WARN("hdr->setup_sects is 0, which could cause boot problems.\n");
 212         }
 213
 214         /* Setup parameter block. Imitate FILO. */
 215         struct linux_params params;
 216
 217         memset(&params, 0, sizeof(struct linux_params));
 218
 219         params.mount_root_rdonly = hdr->root_flags;
 220         params.orig_root_dev = hdr->root_dev;
 221         params.init_size = hdr->init_size;
 222
 223         /* Sensible video defaults. Might be overridden on runtime by coreboot tables. */
 224         params.orig_video_mode = 3;
 225         params.orig_video_cols = 80;
 226         params.orig_video_lines = 25;
 227         params.orig_video_isVGA = 1;
 228         params.orig_video_points = 16;
 229
 230         params.loader_type = 0xff; /* Unregistered Linux loader */
 231
 232         if (cmdline != NULL) {
 233                 if (hdr->protocol_version < 0x202) {
 234                         params.cl_magic = CL_MAGIC_VALUE;
 235                         params.cl_offset = COMMAND_LINE_LOC - LINUX_PARAM_LOC;
 236                 } else {
 237                         params.cmd_line_ptr = COMMAND_LINE_LOC;
 238                 }
 239         }
 240
 241         unsigned long kernel_base = 0x100000;
 242         if ((hdr->protocol_version < 0x200) || !(hdr->loadflags & 1)) {
 243                 kernel_base = 0x1000; /* zImage kernel */
 244         }
 245         /* kernel prefers an address, so listen */
 246         if ((hdr->protocol_version >= 0x20a) && (!(hdr->pref_address >> 32))) {
 247                 kernel_base = hdr->pref_address;
 248         }
 249         if (hdr->protocol_version >= 0x205) {
 250                 params.relocatable_kernel = hdr->relocatable_kernel;
 251                 params.kernel_alignment = hdr->kernel_alignment;
 252                 if (hdr->relocatable_kernel != 0) {
 253                         /* 16 MB should be way outside coreboot's playground,
 254                          * so if possible (relocatable kernel) use that to
 255                          * avoid a trampoline copy. */
 256                         kernel_base = ALIGN_UP(16*1024*1024, params.kernel_alignment);
 257                         if (hdr->init_size == 0) {
 258                                 ERROR("init_size 0 for relocatable kernel\n");
 259                                 return -1;
 260                         }
 261                 }
 262         }
 263
 264         /* We have a trampoline and use that, but it can simply use
 265          * this information for its jump to real Linux. */
 266         params.kernel_start = kernel_base;
 267
 268         /* To make decisions based on the protocol version,
 269            copy that as well. */
 270         params.param_block_version = hdr->protocol_version;
 271
 272         if (bzp_add_kernel(&bzp, input, setup_size) != 0)
 273                 return -1;
 274
 275         if (buffer_size(&bzp.initrd) != 0) {
 276                 /* TODO: this is a bit of a hack. Linux recommends to store
 277                  * initrd near to end-of-mem, but that's hard to do on build
 278                  * time. It definitely fails to read the image if it's too
 279                  * close to the kernel, so give it some room.
 280                  */
 281                 initrd_base = kernel_base + buffer_size(&bzp.kernel);
 282                 initrd_base = ALIGN_UP(initrd_base, 64*1024*1024);
 283
 284                 params.initrd_start = initrd_base;
 285                 params.initrd_size = buffer_size(&bzp.initrd);
 286         }
 287
 288         if (bzp_add_params(&bzp, &params) != 0)
 289                 return -1;
 290
 291         if (bzp_init_output(&bzp, input->name) != 0)
 292                 return -1;
 293
 294         /* parameter block */
 295         bzp_output_segment(&bzp, &bzp.parameters,
 296                            PAYLOAD_SEGMENT_DATA, LINUX_PARAM_LOC);
 297
 298         /* code block */
 299         bzp_output_segment(&bzp, &bzp.kernel,
 300                            PAYLOAD_SEGMENT_CODE, kernel_base);
 301
 302         /* trampoline */
 303         bzp_output_segment(&bzp, &bzp.trampoline,
 304                            PAYLOAD_SEGMENT_CODE, TRAMPOLINE_ENTRY_LOC);
 305
 306         /* cmdline */
 307         bzp_output_segment(&bzp, &bzp.cmdline,
 308                            PAYLOAD_SEGMENT_DATA, COMMAND_LINE_LOC);
 309
 310         /* initrd */
 311         bzp_output_segment(&bzp, &bzp.initrd,
 312                            PAYLOAD_SEGMENT_DATA, initrd_base);
 313
 314         /* Terminating entry segment. */
 315         bzp_output_segment(&bzp, NULL, PAYLOAD_SEGMENT_ENTRY, TRAMPOLINE_ENTRY_LOC);
 316
 317         /* Set size of buffer taking into account potential compression. */
 318         buffer_set_size(&bzp.output, bzp.offset);
 319         /* Make passed-in output buffer be valid. */
 320         buffer_clone(output, &bzp.output);
 321
 322         /* Serialize the segments with the correct encoding. */
 323         xdr_segs(output, bzp.segs, bzp.num_segments);
 324         return 0;
 325 }