1 /*-
2 * Copyright (c) 2014 Roger Pau Monné <[email protected]>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /*
28 * This multiboot implementation only implements a subset of the full
29 * multiboot specification in order to be able to boot Xen and a
30 * FreeBSD Dom0. Trying to use it to boot other multiboot compliant
31 * kernels will most surely fail.
32 *
33 * The full multiboot specification can be found here:
34 * http://www.gnu.org/software/grub/manual/multiboot/multiboot.html
35 */
36
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
39
40 #include <sys/param.h>
41 #include <sys/exec.h>
42 #include <sys/linker.h>
43 #include <sys/module.h>
44 #include <sys/stdint.h>
45 #define _MACHINE_ELF_WANT_32BIT
46 #include <machine/elf.h>
47 #include <string.h>
48 #include <stand.h>
49
50 #include "bootstrap.h"
51 #include "multiboot.h"
52 #include "libi386.h"
53 #include <btxv86.h>
54
55 #define MULTIBOOT_SUPPORTED_FLAGS \
56 (MULTIBOOT_PAGE_ALIGN|MULTIBOOT_MEMORY_INFO)
57 #define NUM_MODULES 2
58 #define METADATA_FIXED_SIZE (PAGE_SIZE*4)
59 #define METADATA_MODULE_SIZE PAGE_SIZE
60
61 #define METADATA_RESV_SIZE(mod_num) \
62 roundup(METADATA_FIXED_SIZE + METADATA_MODULE_SIZE * mod_num, PAGE_SIZE)
63
64 extern int elf32_loadfile_raw(char *filename, uint64_t dest,
65 struct preloaded_file **result, int multiboot);
66 extern int elf64_load_modmetadata(struct preloaded_file *fp, uint64_t dest);
67 extern int elf64_obj_loadfile(char *filename, uint64_t dest,
68 struct preloaded_file **result);
69
70 static int multiboot_loadfile(char *, uint64_t, struct preloaded_file **);
71 static int multiboot_exec(struct preloaded_file *);
72
73 static int multiboot_obj_loadfile(char *, uint64_t, struct preloaded_file **);
74 static int multiboot_obj_exec(struct preloaded_file *fp);
75
76 struct file_format multiboot = { multiboot_loadfile, multiboot_exec };
77 struct file_format multiboot_obj =
78 { multiboot_obj_loadfile, multiboot_obj_exec };
79
80 extern void multiboot_tramp();
81
82 static const char mbl_name[] = "FreeBSD Loader";
83
84 static int
num_modules(struct preloaded_file * kfp)85 num_modules(struct preloaded_file *kfp)
86 {
87 struct kernel_module *kmp;
88 int mod_num = 0;
89
90 for (kmp = kfp->f_modules; kmp != NULL; kmp = kmp->m_next)
91 mod_num++;
92
93 return (mod_num);
94 }
95
96 static vm_offset_t
max_addr(void)97 max_addr(void)
98 {
99 struct preloaded_file *fp;
100 vm_offset_t addr = 0;
101
102 for (fp = file_findfile(NULL, NULL); fp != NULL; fp = fp->f_next) {
103 if (addr < (fp->f_addr + fp->f_size))
104 addr = fp->f_addr + fp->f_size;
105 }
106
107 return (addr);
108 }
109
110 static int
multiboot_loadfile(char * filename,uint64_t dest,struct preloaded_file ** result)111 multiboot_loadfile(char *filename, uint64_t dest,
112 struct preloaded_file **result)
113 {
114 uint32_t *magic;
115 int i, error;
116 caddr_t header_search;
117 ssize_t search_size;
118 int fd;
119 struct multiboot_header *header;
120 char *cmdline;
121
122 /*
123 * Read MULTIBOOT_SEARCH size in order to search for the
124 * multiboot magic header.
125 */
126 if (filename == NULL)
127 return (EFTYPE);
128 if ((fd = open(filename, O_RDONLY)) == -1)
129 return (errno);
130 header_search = malloc(MULTIBOOT_SEARCH);
131 if (header_search == NULL) {
132 close(fd);
133 return (ENOMEM);
134 }
135 search_size = read(fd, header_search, MULTIBOOT_SEARCH);
136 magic = (uint32_t *)header_search;
137
138 header = NULL;
139 for (i = 0; i < (search_size / sizeof(uint32_t)); i++) {
140 if (magic[i] == MULTIBOOT_HEADER_MAGIC) {
141 header = (struct multiboot_header *)&magic[i];
142 break;
143 }
144 }
145
146 if (header == NULL) {
147 error = EFTYPE;
148 goto out;
149 }
150
151 /* Valid multiboot header has been found, validate checksum */
152 if (header->magic + header->flags + header->checksum != 0) {
153 printf(
154 "Multiboot checksum failed, magic: 0x%x flags: 0x%x checksum: 0x%x\n",
155 header->magic, header->flags, header->checksum);
156 error = EFTYPE;
157 goto out;
158 }
159
160 if ((header->flags & ~MULTIBOOT_SUPPORTED_FLAGS) != 0) {
161 printf("Unsupported multiboot flags found: 0x%x\n",
162 header->flags);
163 error = EFTYPE;
164 goto out;
165 }
166
167 error = elf32_loadfile_raw(filename, dest, result, 1);
168 if (error != 0) {
169 printf(
170 "elf32_loadfile_raw failed: %d unable to load multiboot kernel\n",
171 error);
172 goto out;
173 }
174
175 /*
176 * f_addr is already aligned to PAGE_SIZE, make sure
177 * f_size it's also aligned so when the modules are loaded
178 * they are aligned to PAGE_SIZE.
179 */
180 (*result)->f_size = roundup((*result)->f_size, PAGE_SIZE);
181
182 out:
183 free(header_search);
184 close(fd);
185 return (error);
186 }
187
188 static int
multiboot_exec(struct preloaded_file * fp)189 multiboot_exec(struct preloaded_file *fp)
190 {
191 vm_offset_t module_start, last_addr, metadata_size;
192 vm_offset_t modulep, kernend, entry;
193 struct file_metadata *md;
194 Elf_Ehdr *ehdr;
195 struct multiboot_info *mb_info = NULL;
196 struct multiboot_mod_list *mb_mod = NULL;
197 char *cmdline = NULL;
198 size_t len;
199 int error, mod_num;
200
201 /*
202 * Don't pass the memory size found by the bootloader, the memory
203 * available to Dom0 will be lower than that.
204 */
205 unsetenv("smbios.memory.enabled");
206
207 /* Allocate the multiboot struct and fill the basic details. */
208 mb_info = malloc(sizeof(struct multiboot_info));
209 if (mb_info == NULL) {
210 error = ENOMEM;
211 goto error;
212 }
213 bzero(mb_info, sizeof(struct multiboot_info));
214 mb_info->flags = MULTIBOOT_INFO_MEMORY|MULTIBOOT_INFO_BOOT_LOADER_NAME;
215 mb_info->mem_lower = bios_basemem / 1024;
216 mb_info->mem_upper = bios_extmem / 1024;
217 mb_info->boot_loader_name = VTOP(mbl_name);
218
219 /* Set the Xen command line. */
220 if (fp->f_args == NULL) {
221 /* Add the Xen command line if it is set. */
222 cmdline = getenv("xen_cmdline");
223 if (cmdline != NULL) {
224 fp->f_args = strdup(cmdline);
225 if (fp->f_args == NULL) {
226 error = ENOMEM;
227 goto error;
228 }
229 }
230 }
231 if (fp->f_args != NULL) {
232 len = strlen(fp->f_name) + 1 + strlen(fp->f_args) + 1;
233 cmdline = malloc(len);
234 if (cmdline == NULL) {
235 error = ENOMEM;
236 goto error;
237 }
238 snprintf(cmdline, len, "%s %s", fp->f_name, fp->f_args);
239 mb_info->cmdline = VTOP(cmdline);
240 mb_info->flags |= MULTIBOOT_INFO_CMDLINE;
241 }
242
243 /* Find the entry point of the Xen kernel and save it for later */
244 if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL) {
245 printf("Unable to find %s entry point\n", fp->f_name);
246 error = EINVAL;
247 goto error;
248 }
249 ehdr = (Elf_Ehdr *)&(md->md_data);
250 entry = ehdr->e_entry & 0xffffff;
251
252 /*
253 * Prepare the multiboot module list, Xen assumes the first
254 * module is the Dom0 kernel, and the second one is the initramfs.
255 * This is not optimal for FreeBSD, that doesn't have a initramfs
256 * but instead loads modules dynamically and creates the metadata
257 * info on-the-fly.
258 *
259 * As expected, the first multiboot module is going to be the
260 * FreeBSD kernel loaded as a raw file. The second module is going
261 * to contain the metadata info and the loaded modules.
262 *
263 * On native FreeBSD loads all the modules and then places the
264 * metadata info at the end, but this is painful when running on Xen,
265 * because it relocates the second multiboot module wherever it
266 * likes. In order to workaround this limitation the metadata
267 * information is placed at the start of the second module and
268 * the original modulep value is saved together with the other
269 * metadata, so we can relocate everything.
270 *
271 * Native layout:
272 * fp->f_addr + fp->f_size
273 * +---------+----------------+------------+
274 * | | | |
275 * | Kernel | Modules | Metadata |
276 * | | | |
277 * +---------+----------------+------------+
278 * fp->f_addr modulep kernend
279 *
280 * Xen layout:
281 *
282 * Initial:
283 * fp->f_addr + fp->f_size
284 * +---------+----------+----------------+------------+
285 * | | | | |
286 * | Kernel | Reserved | Modules | Metadata |
287 * | | | | dry run |
288 * +---------+----------+----------------+------------+
289 * fp->f_addr
290 *
291 * After metadata polacement (ie: final):
292 * fp->f_addr + fp->f_size
293 * +-----------+---------+----------+----------------+
294 * | | | | |
295 * | Kernel | Free | Metadata | Modules |
296 * | | | | |
297 * +-----------+---------+----------+----------------+
298 * fp->f_addr modulep kernend
299 * \__________/ \__________________________/
300 * Multiboot module 0 Multiboot module 1
301 */
302
303 fp = file_findfile(NULL, "elf kernel");
304 if (fp == NULL) {
305 printf("No FreeBSD kernel provided, aborting\n");
306 error = EINVAL;
307 goto error;
308 }
309
310 if (fp->f_metadata != NULL) {
311 printf("FreeBSD kernel already contains metadata, aborting\n");
312 error = EINVAL;
313 goto error;
314 }
315
316
317 mb_mod = malloc(sizeof(struct multiboot_mod_list) * NUM_MODULES);
318 if (mb_mod == NULL) {
319 error = ENOMEM;
320 goto error;
321 }
322
323 bzero(mb_mod, sizeof(struct multiboot_mod_list) * NUM_MODULES);
324
325 /*
326 * Calculate how much memory is needed for the metatdata. We did
327 * an approximation of the maximum size when loading the kernel,
328 * but now we know the exact size, so we can release some of this
329 * preallocated memory if not needed.
330 */
331 last_addr = roundup(max_addr(), PAGE_SIZE);
332 mod_num = num_modules(fp);
333
334 /*
335 * Place the metadata after the last used address in order to
336 * calculate it's size, this will not be used.
337 */
338 error = bi_load64(fp->f_args, last_addr, &modulep, &kernend, 0);
339 if (error != 0) {
340 printf("bi_load64 failed: %d\n", error);
341 goto error;
342 }
343 metadata_size = roundup(kernend - last_addr, PAGE_SIZE);
344
345 /* Check that the size is not greater than what we have reserved */
346 if (metadata_size > METADATA_RESV_SIZE(mod_num)) {
347 printf("Required memory for metadata is greater than reserved "
348 "space, please increase METADATA_FIXED_SIZE and "
349 "METADATA_MODULE_SIZE and rebuild the loader\n");
350 error = ENOMEM;
351 goto error;
352 }
353
354 /* Clean the metadata added to the kernel in the bi_load64 dry run */
355 file_removemetadata(fp);
356
357 /*
358 * This is the position where the second multiboot module
359 * will be placed.
360 */
361 module_start = fp->f_addr + fp->f_size - metadata_size;
362
363 error = bi_load64(fp->f_args, module_start, &modulep, &kernend, 0);
364 if (error != 0) {
365 printf("bi_load64 failed: %d\n", error);
366 goto error;
367 }
368
369 mb_mod[0].mod_start = fp->f_addr;
370 mb_mod[0].mod_end = fp->f_addr + fp->f_size;
371 mb_mod[0].mod_end -= METADATA_RESV_SIZE(mod_num);
372
373 mb_mod[1].mod_start = module_start;
374 mb_mod[1].mod_end = last_addr;
375
376 mb_info->mods_count = NUM_MODULES;
377 mb_info->mods_addr = VTOP(mb_mod);
378 mb_info->flags |= MULTIBOOT_INFO_MODS;
379
380 dev_cleanup();
381 __exec((void *)VTOP(multiboot_tramp), (void *)entry,
382 (void *)VTOP(mb_info));
383
384 panic("exec returned");
385
386 error:
387 if (mb_mod)
388 free(mb_mod);
389 if (mb_info)
390 free(mb_info);
391 if (cmdline)
392 free(cmdline);
393 return (error);
394 }
395
396 static int
multiboot_obj_loadfile(char * filename,uint64_t dest,struct preloaded_file ** result)397 multiboot_obj_loadfile(char *filename, uint64_t dest,
398 struct preloaded_file **result)
399 {
400 struct preloaded_file *mfp, *kfp, *rfp;
401 struct kernel_module *kmp;
402 int error, mod_num;
403
404 /* See if there's a multiboot kernel loaded */
405 mfp = file_findfile(NULL, "elf multiboot kernel");
406 if (mfp == NULL)
407 return (EFTYPE);
408
409 /*
410 * We have a multiboot kernel loaded, see if there's a FreeBSD
411 * kernel loaded also.
412 */
413 kfp = file_findfile(NULL, "elf kernel");
414 if (kfp == NULL) {
415 /*
416 * No kernel loaded, this must be it. The kernel has to
417 * be loaded as a raw file, it will be processed by
418 * Xen and correctly loaded as an ELF file.
419 */
420 rfp = file_loadraw(filename, "elf kernel", 0);
421 if (rfp == NULL) {
422 printf(
423 "Unable to load %s as a multiboot payload kernel\n",
424 filename);
425 return (EINVAL);
426 }
427
428 /* Load kernel metadata... */
429 setenv("kernelname", filename, 1);
430 error = elf64_load_modmetadata(rfp, rfp->f_addr + rfp->f_size);
431 if (error) {
432 printf("Unable to load kernel %s metadata error: %d\n",
433 rfp->f_name, error);
434 return (EINVAL);
435 }
436
437 /*
438 * Save space at the end of the kernel in order to place
439 * the metadata information. We do an approximation of the
440 * max metadata size, this is not optimal but it's probably
441 * the best we can do at this point. Once all modules are
442 * loaded and the size of the metadata is known this
443 * space will be recovered if not used.
444 */
445 mod_num = num_modules(rfp);
446 rfp->f_size = roundup(rfp->f_size, PAGE_SIZE);
447 rfp->f_size += METADATA_RESV_SIZE(mod_num);
448 *result = rfp;
449 } else {
450 /* The rest should be loaded as regular modules */
451 error = elf64_obj_loadfile(filename, dest, result);
452 if (error != 0) {
453 printf("Unable to load %s as an object file, error: %d",
454 filename, error);
455 return (error);
456 }
457 }
458
459 return (0);
460 }
461
462 static int
multiboot_obj_exec(struct preloaded_file * fp)463 multiboot_obj_exec(struct preloaded_file *fp)
464 {
465
466 return (EFTYPE);
467 }
468