linux_load.c@ 1372

Last change on this file since 1372 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.6 KB

Line
1	/*
2	* Linux/i386 loader
3	* Supports bzImage, zImage and Image format.
4	*
5	* Based on work by Steve Gehlbach.
6	* Portions are taken from mkelfImage.
7	*
8	* 2003-09 by SONE Takeshi
9	*/
10	#include <etherboot.h>
11
12	#include <lib.h>
13
14	#include <fs.h>
15	#include <sys_info.h>
16
17	#include "context.h"
18	#include "segment.h"
19
20	#define DEBUG_THIS DEBUG_LINUXLOAD
21	#include <debug.h>
22
23	#define LINUX_PARAM_LOC 0x90000
24	#define COMMAND_LINE_LOC 0x91000
25	#define GDT_LOC 0x92000
26	#define STACK_LOC 0x93000
27
28	/* The header of Linux/i386 kernel */
29	struct linux_header {
30	uint8_t reserved1[0x1f1]; /* 0x000 */
31	uint8_t setup_sects; /* 0x1f1 */
32	uint16_t root_flags; /* 0x1f2 */
33	uint8_t reserved2[6]; /* 0x1f4 */
34	uint16_t vid_mode; /* 0x1fa */
35	uint16_t root_dev; /* 0x1fc */
36	uint16_t boot_sector_magic; /* 0x1fe */
37	/* 2.00+ */
38	uint8_t reserved3[2]; /* 0x200 */
39	uint8_t header_magic[4]; /* 0x202 */
40	uint16_t protocol_version; /* 0x206 */
41	uint32_t realmode_swtch; /* 0x208 */
42	uint16_t start_sys; /* 0x20c */
43	uint16_t kver_addr; /* 0x20e */
44	uint8_t type_of_loader; /* 0x210 */
45	uint8_t loadflags; /* 0x211 */
46	uint16_t setup_move_size; /* 0x212 */
47	uint32_t code32_start; /* 0x214 */
48	uint32_t ramdisk_image; /* 0x218 */
49	uint32_t ramdisk_size; /* 0x21c */
50	uint8_t reserved4[4]; /* 0x220 */
51	/* 2.01+ */
52	uint16_t heap_end_ptr; /* 0x224 */
53	uint8_t reserved5[2]; /* 0x226 */
54	/* 2.02+ */
55	uint32_t cmd_line_ptr; /* 0x228 */
56	/* 2.03+ */
57	uint32_t initrd_addr_max; /* 0x22c */
58	} __attribute__ ((packed));
59
60
61	/* Paramters passed to 32-bit part of Linux
62	* This is another view of the structure above.. */
63	struct linux_params {
64	uint8_t orig_x; /* 0x00 */
65	uint8_t orig_y; /* 0x01 */
66	uint16_t ext_mem_k; /* 0x02 -- EXT_MEM_K sits here */
67	uint16_t orig_video_page; /* 0x04 */
68	uint8_t orig_video_mode; /* 0x06 */
69	uint8_t orig_video_cols; /* 0x07 */
70	uint16_t unused2; /* 0x08 */
71	uint16_t orig_video_ega_bx; /* 0x0a */
72	uint16_t unused3; /* 0x0c */
73	uint8_t orig_video_lines; /* 0x0e */
74	uint8_t orig_video_isVGA; /* 0x0f */
75	uint16_t orig_video_points; /* 0x10 */
76
77	/* VESA graphic mode -- linear frame buffer */
78	uint16_t lfb_width; /* 0x12 */
79	uint16_t lfb_height; /* 0x14 */
80	uint16_t lfb_depth; /* 0x16 */
81	uint32_t lfb_base; /* 0x18 */
82	uint32_t lfb_size; /* 0x1c */
83	uint16_t cl_magic; /* 0x20 */
84	#define CL_MAGIC_VALUE 0xA33F
85	uint16_t cl_offset; /* 0x22 */
86	uint16_t lfb_linelength; /* 0x24 */
87	uint8_t red_size; /* 0x26 */
88	uint8_t red_pos; /* 0x27 */
89	uint8_t green_size; /* 0x28 */
90	uint8_t green_pos; /* 0x29 */
91	uint8_t blue_size; /* 0x2a */
92	uint8_t blue_pos; /* 0x2b */
93	uint8_t rsvd_size; /* 0x2c */
94	uint8_t rsvd_pos; /* 0x2d */
95	uint16_t vesapm_seg; /* 0x2e */
96	uint16_t vesapm_off; /* 0x30 */
97	uint16_t pages; /* 0x32 */
98	uint8_t reserved4[12]; /* 0x34 -- 0x3f reserved for future expansion */
99
100	//struct apm_bios_info apm_bios_info; /* 0x40 */
101	uint8_t apm_bios_info[0x40];
102	//struct drive_info_struct drive_info; /* 0x80 */
103	uint8_t drive_info[0x20];
104	//struct sys_desc_table sys_desc_table; /* 0xa0 */
105	uint8_t sys_desc_table[0x140];
106	uint32_t alt_mem_k; /* 0x1e0 */
107	uint8_t reserved5[4]; /* 0x1e4 */
108	uint8_t e820_map_nr; /* 0x1e8 */
109	uint8_t reserved6[9]; /* 0x1e9 */
110	uint16_t mount_root_rdonly; /* 0x1f2 */
111	uint8_t reserved7[4]; /* 0x1f4 */
112	uint16_t ramdisk_flags; /* 0x1f8 */
113	#define RAMDISK_IMAGE_START_MASK 0x07FF
114	#define RAMDISK_PROMPT_FLAG 0x8000
115	#define RAMDISK_LOAD_FLAG 0x4000
116	uint8_t reserved8[2]; /* 0x1fa */
117	uint16_t orig_root_dev; /* 0x1fc */
118	uint8_t reserved9[1]; /* 0x1fe */
119	uint8_t aux_device_info; /* 0x1ff */
120	uint8_t reserved10[2]; /* 0x200 */
121	uint8_t param_block_signature[4]; /* 0x202 */
122	uint16_t param_block_version; /* 0x206 */
123	uint8_t reserved11[8]; /* 0x208 */
124	uint8_t loader_type; /* 0x210 */
125	#define LOADER_TYPE_LOADLIN 1
126	#define LOADER_TYPE_BOOTSECT_LOADER 2
127	#define LOADER_TYPE_SYSLINUX 3
128	#define LOADER_TYPE_ETHERBOOT 4
129	#define LOADER_TYPE_KERNEL 5
130	uint8_t loader_flags; /* 0x211 */
131	uint8_t reserved12[2]; /* 0x212 */
132	uint32_t kernel_start; /* 0x214 */
133	uint32_t initrd_start; /* 0x218 */
134	uint32_t initrd_size; /* 0x21c */
135	uint8_t reserved12_5[8]; /* 0x220 */
136	uint32_t cmd_line_ptr; /* 0x228 */
137	uint8_t reserved13[164]; /* 0x22c */
138	struct e820entry e820_map[E820MAX]; /* 0x2d0 */
139	uint8_t reserved16[688]; /* 0x550 */
140	#define COMMAND_LINE_SIZE 256
141	/* Command line is copied here by 32-bit i386/kernel/head.S.
142	* So I will follow the boot protocol, rather than putting it
143	* directly here. --ts1 */
144	uint8_t command_line[COMMAND_LINE_SIZE]; /* 0x800 */
145	uint8_t reserved17[1792]; /* 0x900 - 0x1000 */
146	};
147
148	uint64_t forced_memsize;
149
150	/* Load the first part the file and check if it's Linux */
151	static uint32_t load_linux_header(struct linux_header *hdr)
152	{
153	int load_high;
154	uint32_t kern_addr;
155
156	if (file_read(hdr, sizeof hdr) != sizeof hdr) {
157	debug("Can't read Linux header\n");
158	return 0;
159	}
160	if (hdr->boot_sector_magic != 0xaa55) {
161	debug("Not a Linux kernel image\n");
162	return 0;
163	}
164
165	/* Linux is found. Print some information */
166	if (memcmp(hdr->header_magic, "HdrS", 4) != 0) {
167	/* This may be floppy disk image or something.
168	* Perform a simple (incomplete) sanity check. */
169	if (hdr->setup_sects >= 16
170	\|\| file_size() - (hdr->setup_sects<<9) >= 512<<10) {
171	debug("This looks like a bootdisk image but not like Linux...\n");
172	return 0;
173	}
174
175	debugx("Possible very old Linux");
176	/* This kernel does not even have a protocol version.
177	* Force the value. */
178	hdr->protocol_version = 0; /* pre-2.00 */
179	} else
180	printf("Found Linux");
181	if (hdr->protocol_version >= 0x200 && hdr->kver_addr) {
182	char kver[256];
183	file_seek(hdr->kver_addr + 0x200);
184	if (file_read(kver, sizeof kver) != 0) {
185	kver[255] = 0;
186	printf(" version %s", kver);
187	}
188	}
189	debug(" (protocol %#x)", hdr->protocol_version);
190	load_high = 0;
191	if (hdr->protocol_version >= 0x200) {
192	debug(" (loadflags %#x)", hdr->loadflags);
193	load_high = hdr->loadflags & 1;
194	}
195	if (load_high) {
196	printf(" bzImage");
197	kern_addr = 0x100000;
198	} else {
199	printf(" zImage or Image");
200	kern_addr = 0x1000;
201	}
202	printf(".\n");
203
204	return kern_addr;
205	}
206
207	/* Set up parameters for 32-bit kernel */
208	static void
209	init_linux_params(struct linux_params params, struct linux_header hdr)
210	{
211	debug("Setting up paramters at %#lx\n", virt_to_phys(params));
212	memset(params, 0, sizeof *params);
213
214	/* Copy some useful values from header */
215	params->mount_root_rdonly = hdr->root_flags;
216	params->orig_root_dev = hdr->root_dev;
217
218	/* Video parameters.
219	* This assumes we have VGA in standard 80x25 text mode,
220	* just like our vga.c does.
221	* Cursor position is filled later to allow some more printf's. */
222	params->orig_video_mode = 3;
223	params->orig_video_cols = 80;
224	params->orig_video_lines = 25;
225	params->orig_video_isVGA = 1;
226	params->orig_video_points = 16;
227
228	params->loader_type = 0xff; /* Unregistered Linux loader */
229	}
230
231	/* Memory map */
232	static void
233	set_memory_size(struct linux_params params, struct sys_info info)
234	{
235	uint32_t i;
236	uint32_t ramtop = 0;
237	struct e820entry *linux_map;
238	struct e820entry *filo_map;
239
240	linux_map = params->e820_map;
241
242	filo_map = meminfo.map;
243	for (i = 0; i < meminfo.map_count; i++, linux_map++, filo_map++) {
244	if (i < E820MAX) {
245	/* Convert to BIOS e820 style */
246	linux_map->addr = filo_map->addr;
247	linux_map->size = filo_map->size;
248	linux_map->type = filo_map->type;
249	// debug("%016Lx - %016Lx\n", linux_map->addr,linux_map->addr + linux_map->size);
250	params->e820_map_nr = i+1;
251	}
252
253	}
254	ramtop = meminfo.memsize;
255	debug("ramtop=%#xk\n", ramtop);
256	/* Size of memory above 1MB in KB */
257	params->alt_mem_k = ramtop;
258	/* old style, 64MB max */
259	if (ramtop >= (64<<10))
260	params->ext_mem_k = (63<<10);
261	else
262	params->ext_mem_k = params->alt_mem_k;
263
264	debug("ext_mem_k=%d, alt_mem_k=%d\n", params->ext_mem_k, params->alt_mem_k);
265	}
266
267	/*
268	* Parse command line
269	* Some parameters, like initrd=<file>, are not passed to kernel,
270	* we are responsible to process them.
271	* Parameters for kernel are copied to kern_cmdline. Returns name of initrd.
272	*/
273	static char parse_command_line(const char orig_cmdline, char *kern_cmdline)
274	{
275	const char start, sep, end, val;
276	char name[64];
277	int len;
278	int k_len;
279	int to_kern;
280	char *initrd = 0;
281	int toolong = 0;
282
283	forced_memsize = 0;
284
285	if (!orig_cmdline) {
286	*kern_cmdline = 0;
287	return 0;
288	}
289
290	k_len = 0;
291	debug("original command line: \"%s\"\n", orig_cmdline);
292	debug("kernel command line at %#lx\n", virt_to_phys(kern_cmdline));
293
294	start = orig_cmdline;
295	while (*start == ' ')
296	start++;
297	while (*start) {
298	end = strchr(start, ' ');
299	if (!end)
300	end = start + strlen(start);
301	sep = strchr(start, '=');
302	if (!sep \|\| sep > end)
303	sep = end;
304	len = sep - start;
305	if (len >= sizeof(name))
306	len = sizeof(name) - 1;
307	memcpy(name, start, len);
308	name[len] = 0;
309
310	if (*sep == '=') {
311	val = sep + 1;
312	len = end - val;
313	} else {
314	val = 0;
315	len = 0;
316	}
317
318	/* Only initrd= and mem= are handled here. vga= is not,
319	* which I believe is a paramter to the realmode part of Linux,
320	* which we don't execute. */
321	if (strcmp(name, "initrd") == 0) {
322	if (!val)
323	printf("Missing filename to initrd parameter\n");
324	else {
325	initrd = allot(len + 1);
326	memcpy(initrd, val, len);
327	initrd[len] = 0;
328	debug("initrd=%s\n", initrd);
329	}
330	/* Don't pass this to kernel */
331	to_kern = 0;
332	} else if (strcmp(name, "mem") == 0) {
333	if (!val)
334	printf("Missing value for mem parameter\n");
335	else {
336	forced_memsize = strtoull_with_suffix(val, (char**)&val, 0);
337	if (forced_memsize == 0)
338	printf("Invalid mem option, ignored\n");
339	if (val != end) {
340	printf("Garbage after mem=<size>, ignored\n");
341	forced_memsize = 0;
342	}
343	// debug("mem=%Lu\n", forced_memsize);
344	}
345	/* mem= is for both loader and kernel */
346	to_kern = 1;
347	} else
348	to_kern = 1;
349
350	if (to_kern) {
351	/* Copy to kernel command line buffer */
352	if (k_len != 0)
353	kern_cmdline[k_len++] = ' '; /* put separator */
354	len = end - start;
355	if (k_len + len >= COMMAND_LINE_SIZE) {
356	len = COMMAND_LINE_SIZE - k_len - 1;
357	if (!toolong) {
358	printf("Kernel command line is too long; truncated to "
359	"%d bytes\n", COMMAND_LINE_SIZE-1);
360	toolong = 1;
361	}
362	}
363	memcpy(kern_cmdline + k_len, start, len);
364	k_len += len;
365	}
366
367	start = end;
368	while (*start == ' ')
369	start++;
370	}
371	kern_cmdline[k_len] = 0;
372	debug("kernel command line (%d bytes): \"%s\"\n", k_len, kern_cmdline);
373
374	return initrd;
375	}
376
377	/* Set command line location */
378	static void set_command_line_loc(struct linux_params *params,
379	struct linux_header *hdr)
380	{
381	if (hdr->protocol_version >= 0x202) {
382	/* new style */
383	params->cmd_line_ptr = COMMAND_LINE_LOC;
384	} else {
385	/* old style */
386	params->cl_magic = CL_MAGIC_VALUE;
387	params->cl_offset = COMMAND_LINE_LOC - LINUX_PARAM_LOC;
388	}
389	}
390
391	/* Load 32-bit part of kernel */
392	static int load_linux_kernel(struct linux_header *hdr, uint32_t kern_addr)
393	{
394	uint32_t kern_offset, kern_size;
395
396	if (hdr->setup_sects == 0)
397	hdr->setup_sects = 4;
398	kern_offset = (hdr->setup_sects + 1) * 512;
399	file_seek(kern_offset);
400	kern_size = file_size() - kern_offset;
401	debug("offset=%#x addr=%#x size=%#x\n", kern_offset, kern_addr, kern_size);
402
403	if (using_devsize) {
404	printf("Attempt to load up to end of device as kernel; "
405	"specify the image size\n");
406	return 0;
407	}
408
409	printf("Loading kernel... ");
410	if (file_read(phys_to_virt(kern_addr), kern_size) != kern_size) {
411	printf("Can't read kernel\n");
412	return 0;
413	}
414	printf("ok\n");
415
416	return kern_size;
417	}
418
419	static int load_initrd(struct linux_header hdr, struct sys_info info,
420	uint32_t kern_end, struct linux_params params, const char initrd_file)
421	{
422	uint32_t max;
423	uint32_t start, end, size;
424	uint64_t forced;
425	extern char _virt_start[], _end[];
426
427	if (!file_open(initrd_file)) {
428	printf("Can't open initrd: %s\n", initrd_file);
429	return -1;
430	}
431	if (using_devsize) {
432	printf("Attempt to load up to end of device as initrd; "
433	"specify the image size\n");
434	return -1;
435	}
436	size = file_size();
437
438
439	/* Find out the kernel's restriction on how high the initrd can be
440	* placed */
441	if (hdr->protocol_version >= 0x203)
442	max = hdr->initrd_addr_max;
443	else
444	max = 0x38000000; /* Hardcoded value for older kernels */
445
446	/* FILO itself is at the top of RAM. (relocated)
447	* So, try putting initrd just below us. */
448	end = virt_to_phys(_virt_start);
449	if (end > max)
450	end = max;
451
452	/* If "mem=" option is given, we have to put the initrd within
453	* the specified range. */
454	if (forced_memsize) {
455	forced = forced_memsize;
456	if (forced > max)
457	forced = max;
458	/* If the "mem=" is lower, it's easy */
459	if (forced <= end)
460	end = forced;
461	else {
462	/* Otherwise, see if we can put it above us */
463	if (virt_to_phys(_end) + size <= forced)
464	end = forced; /* Ok */
465	}
466	}
467
468	start = end - size;
469	start &= ~0xfff; /* page align */
470	end = start + size;
471
472	debug("start=%#x end=%#x\n", start, end);
473
474	if (start < kern_end) {
475	printf("Initrd is too big\n");
476	return -1;
477	}
478
479	printf("Loading initrd... ");
480	if (file_read(phys_to_virt(start), size) != size) {
481	printf("Can't read initrd\n");
482	return -1;
483	}
484	printf("ok\n");
485
486	params->initrd_start = start;
487	params->initrd_size = size;
488
489	return 0;
490	}
491
492	static void hardware_setup(void)
493	{
494	/* Disable nmi */
495	outb(0x80, 0x70);
496
497	/* Make sure any coprocessor is properly reset.. */
498	outb(0, 0xf0);
499	outb(0, 0xf1);
500
501	/* we're getting screwed again and again by this problem of the 8259.
502	* so we're going to leave this lying around for inclusion into
503	* crt0.S on an as-needed basis.
504	*
505	* well, that went ok, I hope. Now we have to reprogram the interrupts :-(
506	* we put them right after the intel-reserved hardware interrupts, at
507	* int 0x20-0x2F. There they won't mess up anything. Sadly IBM really
508	* messed this up with the original PC, and they haven't been able to
509	* rectify it afterwards. Thus the bios puts interrupts at 0x08-0x0f,
510	* which is used for the internal hardware interrupts as well. We just
511	* have to reprogram the 8259's, and it isn't fun.
512	*/
513
514	outb(0x11, 0x20); /* initialization sequence to 8259A-1 */
515	outb(0x11, 0xA0); /* and to 8259A-2 */
516
517	outb(0x20, 0x21); /* start of hardware int's (0x20) */
518	outb(0x28, 0xA1); /* start of hardware int's 2 (0x28) */
519
520	outb(0x04, 0x21); /* 8259-1 is master */
521	outb(0x02, 0xA1); /* 8259-2 is slave */
522
523	outb(0x01, 0x21); /* 8086 mode for both */
524	outb(0x01, 0xA1);
525
526	outb(0xFF, 0xA1); /* mask off all interrupts for now */
527	outb(0xFB, 0x21); /* mask all irq's but irq2 which is cascaded */
528	}
529
530	/* Start Linux */
531	static int start_linux(uint32_t kern_addr, struct linux_params *params)
532	{
533	struct segment_desc *linux_gdt;
534	struct context *ctx;
535	#if 0
536	extern int cursor_x, cursor_y;
537	#endif
538
539	ctx = init_context(phys_to_virt(STACK_LOC), 4096, 0);
540
541	/* Linux expects GDT being in low memory */
542	linux_gdt = phys_to_virt(GDT_LOC);
543	memset(linux_gdt, 0, 13*sizeof(struct segment_desc));
544	/* Normal kernel code/data segments */
545	linux_gdt[2] = gdt[FLAT_CODE];
546	linux_gdt[3] = gdt[FLAT_DATA];
547	/* 2.6 kernel uses 12 and 13, but head.S uses backward-compatible
548	* segments (2 and 3), so it SHOULD not be a problem.
549	* However, some distro kernels (eg. RH9) with backported threading
550	* patch use 12 and 13 also when booting... */
551	linux_gdt[12] = gdt[FLAT_CODE];
552	linux_gdt[13] = gdt[FLAT_DATA];
553	ctx->gdt_base = GDT_LOC;
554	ctx->gdt_limit = 14*8-1;
555	ctx->cs = 0x10;
556	ctx->ds = 0x18;
557	ctx->es = 0x18;
558	ctx->fs = 0x18;
559	ctx->gs = 0x18;
560	ctx->ss = 0x18;
561
562	/* Parameter location */
563	ctx->esi = virt_to_phys(params);
564
565	/* Entry point */
566	ctx->eip = kern_addr;
567
568	debug("eip=%#x\n", kern_addr);
569	printf("Jumping to entry point...\n");
570
571	#ifdef VGA_CONSOLE
572	/* Update VGA cursor position.
573	* This must be here because the printf changes the value! */
574	#if 0
575	params->orig_x = cursor_x;
576	params->orig_y = cursor_y;
577	#endif
578	#endif
579
580	/* Go... */
581	ctx = switch_to(ctx);
582
583	/* It's impossible but... */
584	printf("Returned with eax=%#x\n", ctx->eax);
585
586	return ctx->eax;
587	}
588
589	int linux_load(struct sys_info info, const char file, const char *cmdline)
590	{
591	struct linux_header hdr;
592	struct linux_params *params;
593	uint32_t kern_addr, kern_size;
594	char *initrd_file = 0;
595
596	if (!file_open(file))
597	return -1;
598
599	kern_addr = load_linux_header(&hdr);
600	if (kern_addr == 0)
601	return LOADER_NOT_SUPPORT;
602
603	params = phys_to_virt(LINUX_PARAM_LOC);
604	init_linux_params(params, &hdr);
605	set_memory_size(params, info);
606	initrd_file = parse_command_line(cmdline, phys_to_virt(COMMAND_LINE_LOC));
607	set_command_line_loc(params, &hdr);
608
609	kern_size = load_linux_kernel(&hdr, kern_addr);
610	if (kern_size == 0) {
611	if (initrd_file)
612	forget(initrd_file);
613	return -1;
614	}
615
616	if (initrd_file) {
617	if (load_initrd(&hdr, info, kern_addr+kern_size, params, initrd_file)
618	!= 0) {
619	forget(initrd_file);
620	return -1;
621	}
622	forget(initrd_file);
623	}
624
625	hardware_setup();
626
627	start_linux(kern_addr, params);
628	return 0;
629	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/PC/Etherboot-src/filo/i386/linux_load.c@ 1372

Download in other formats: