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