/* boot.c - load and bootstrap a kernel */ /* * GRUB -- GRand Unified Bootloader * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. * * 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; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "shared.h" #include "freebsd.h" #include "imgact_aout.h" #include "i386-elf.h" static int cur_addr; entry_func entry_addr; static struct mod_list mll[99]; static int linux_mem_size; /* * The next two functions, 'load_image' and 'load_module', are the building * blocks of the multiboot loader component. They handle essentially all * of the gory details of loading in a bootable image and the modules. */ kernel_t load_image (char *kernel, char *arg, kernel_t suggested_type, unsigned long load_flags) { int len, i, exec_type = 0, align_4k = 1; entry_func real_entry_addr = 0; kernel_t type = KERNEL_TYPE_NONE; unsigned long flags = 0, text_len = 0, data_len = 0, bss_len = 0; char *str = 0, *str2 = 0; struct linux_kernel_header *lh; union { struct multiboot_header *mb; struct exec *aout; Elf32_Ehdr *elf; } pu; /* presuming that MULTIBOOT_SEARCH is large enough to encompass an executable header */ unsigned char buffer[MULTIBOOT_SEARCH]; /* sets the header pointer to point to the beginning of the buffer by default */ pu.aout = (struct exec *) buffer; if (!grub_open (kernel)) return KERNEL_TYPE_NONE; if (!(len = grub_read (buffer, MULTIBOOT_SEARCH)) || len < 32) { grub_close (); if (!errnum) errnum = ERR_EXEC_FORMAT; return KERNEL_TYPE_NONE; } for (i = 0; i < len; i++) { if (MULTIBOOT_FOUND ((int) (buffer + i), len - i)) { flags = ((struct multiboot_header *) (buffer + i))->flags; if (flags & MULTIBOOT_UNSUPPORTED) { grub_close (); errnum = ERR_BOOT_FEATURES; return KERNEL_TYPE_NONE; } type = KERNEL_TYPE_MULTIBOOT; str2 = "Multiboot"; break; } } /* Use BUFFER as a linux kernel header, if the image is Linux zImage or bzImage. */ lh = (struct linux_kernel_header *) buffer; /* ELF loading supported if multiboot, FreeBSD and NetBSD. */ if ((type == KERNEL_TYPE_MULTIBOOT || pu.elf->e_ident[EI_OSABI] == ELFOSABI_FREEBSD || grub_strcmp (pu.elf->e_ident + EI_BRAND, "FreeBSD") == 0 || suggested_type == KERNEL_TYPE_NETBSD) && len > sizeof (Elf32_Ehdr) && BOOTABLE_I386_ELF ((*((Elf32_Ehdr *) buffer)))) { if (type == KERNEL_TYPE_MULTIBOOT) entry_addr = (entry_func) pu.elf->e_entry; else entry_addr = (entry_func) (pu.elf->e_entry & 0xFFFFFF); if (entry_addr < (entry_func) 0x100000) errnum = ERR_BELOW_1MB; /* don't want to deal with ELF program header at some random place in the file -- this generally won't happen */ if (pu.elf->e_phoff == 0 || pu.elf->e_phnum == 0 || ((pu.elf->e_phoff + (pu.elf->e_phentsize * pu.elf->e_phnum)) >= len)) errnum = ERR_EXEC_FORMAT; str = "elf"; if (type == KERNEL_TYPE_NONE) { /* At the moment, there is no way to identify a NetBSD ELF kernel, so rely on the suggested type by the user. */ if (suggested_type == KERNEL_TYPE_NETBSD) { str2 = "NetBSD"; type = suggested_type; } else { str2 = "FreeBSD"; type = KERNEL_TYPE_FREEBSD; } } } else if (flags & MULTIBOOT_AOUT_KLUDGE) { pu.mb = (struct multiboot_header *) (buffer + i); entry_addr = (entry_func) pu.mb->entry_addr; cur_addr = pu.mb->load_addr; /* first offset into file */ grub_seek (i - (pu.mb->header_addr - cur_addr)); /* If the load end address is zero, load the whole contents. */ if (! pu.mb->load_end_addr) pu.mb->load_end_addr = cur_addr + filemax; text_len = pu.mb->load_end_addr - cur_addr; data_len = 0; /* If the bss end address is zero, assume that there is no bss area. */ if (! pu.mb->bss_end_addr) pu.mb->bss_end_addr = pu.mb->load_end_addr; bss_len = pu.mb->bss_end_addr - pu.mb->load_end_addr; if (pu.mb->header_addr < pu.mb->load_addr || pu.mb->load_end_addr <= pu.mb->load_addr || pu.mb->bss_end_addr < pu.mb->load_end_addr || (pu.mb->header_addr - pu.mb->load_addr) > i) errnum = ERR_EXEC_FORMAT; if (cur_addr < 0x100000) errnum = ERR_BELOW_1MB; pu.aout = (struct exec *) buffer; exec_type = 2; str = "kludge"; } else if (len > sizeof (struct exec) && !N_BADMAG ((*(pu.aout)))) { entry_addr = (entry_func) pu.aout->a_entry; if (type == KERNEL_TYPE_NONE) { /* * If it doesn't have a Multiboot header, then presume * it is either a FreeBSD or NetBSD executable. If so, * then use a magic number of normal ordering, ZMAGIC to * determine if it is FreeBSD. * * This is all because freebsd and netbsd seem to require * masking out some address bits... differently for each * one... plus of course we need to know which booting * method to use. */ entry_addr = (entry_func) ((int) entry_addr & 0xFFFFFF); if (buffer[0] == 0xb && buffer[1] == 1) { type = KERNEL_TYPE_FREEBSD; cur_addr = (int) entry_addr; str2 = "FreeBSD"; } else { type = KERNEL_TYPE_NETBSD; cur_addr = (int) entry_addr & 0xF00000; if (N_GETMAGIC ((*(pu.aout))) != NMAGIC) align_4k = 0; str2 = "NetBSD"; } } /* first offset into file */ grub_seek (N_TXTOFF (*(pu.aout))); text_len = pu.aout->a_text; data_len = pu.aout->a_data; bss_len = pu.aout->a_bss; if (cur_addr < 0x100000) errnum = ERR_BELOW_1MB; exec_type = 1; str = "a.out"; } else if (lh->boot_flag == BOOTSEC_SIGNATURE && lh->setup_sects <= LINUX_MAX_SETUP_SECTS) { int big_linux = 0; int setup_sects = lh->setup_sects; if (lh->header == LINUX_MAGIC_SIGNATURE && lh->version >= 0x0200) { big_linux = (lh->loadflags & LINUX_FLAG_BIG_KERNEL); lh->type_of_loader = LINUX_BOOT_LOADER_TYPE; /* Put the real mode part at as a high location as possible. */ linux_data_real_addr = (char *) ((mbi.mem_lower << 10) - LINUX_SETUP_MOVE_SIZE); /* But it must not exceed the traditional area. */ if (linux_data_real_addr > (char *) LINUX_OLD_REAL_MODE_ADDR) linux_data_real_addr = (char *) LINUX_OLD_REAL_MODE_ADDR; if (lh->version >= 0x0201) { lh->heap_end_ptr = LINUX_HEAP_END_OFFSET; lh->loadflags |= LINUX_FLAG_CAN_USE_HEAP; } if (lh->version >= 0x0202) lh->cmd_line_ptr = linux_data_real_addr + LINUX_CL_OFFSET; else { lh->cl_magic = LINUX_CL_MAGIC; lh->cl_offset = LINUX_CL_OFFSET; lh->setup_move_size = LINUX_SETUP_MOVE_SIZE; } } else { /* Your kernel is quite old... */ lh->cl_magic = LINUX_CL_MAGIC; lh->cl_offset = LINUX_CL_OFFSET; setup_sects = LINUX_DEFAULT_SETUP_SECTS; linux_data_real_addr = (char *) LINUX_OLD_REAL_MODE_ADDR; } /* If SETUP_SECTS is not set, set it to the default (4). */ if (! setup_sects) setup_sects = LINUX_DEFAULT_SETUP_SECTS; data_len = setup_sects << 9; text_len = filemax - data_len - SECTOR_SIZE; linux_data_tmp_addr = (char *) LINUX_BZIMAGE_ADDR + text_len; if (! big_linux && text_len > linux_data_real_addr - (char *) LINUX_ZIMAGE_ADDR) { grub_printf (" linux 'zImage' kernel too big, try 'make bzImage'\n"); errnum = ERR_WONT_FIT; } else if (linux_data_real_addr + LINUX_SETUP_MOVE_SIZE > RAW_ADDR ((char *) (mbi.mem_lower << 10))) errnum = ERR_WONT_FIT; else { grub_printf (" [Linux-%s, setup=0x%x, size=0x%x]\n", (big_linux ? "bzImage" : "zImage"), data_len, text_len); /* Video mode selection support. What a mess! */ /* NOTE: Even the word "mess" is not still enough to represent how wrong and bad the Linux video support is, but I don't want to hear complaints from Linux fanatics any more. -okuji */ { char *vga; /* Find the substring "vga=". */ vga = grub_strstr (arg, "vga="); if (vga) { char *value = vga + 4; int vid_mode; /* Handle special strings. */ if (substring ("normal", value) < 1) vid_mode = LINUX_VID_MODE_NORMAL; else if (substring ("ext", value) < 1) vid_mode = LINUX_VID_MODE_EXTENDED; else if (substring ("ask", value) < 1) vid_mode = LINUX_VID_MODE_ASK; else if (safe_parse_maxint (&value, &vid_mode)) ; else { /* ERRNUM is already set inside the function safe_parse_maxint. */ grub_close (); return KERNEL_TYPE_NONE; } lh->vid_mode = vid_mode; } } /* Check the mem= option to limit memory used for initrd. */ { char *mem; mem = grub_strstr (arg, "mem="); if (mem) { char *value = mem + 4; safe_parse_maxint (&value, &linux_mem_size); switch (errnum) { case ERR_NUMBER_OVERFLOW: /* If an overflow occurs, use the maximum address for initrd instead. This is good, because MAXINT is greater than LINUX_INITRD_MAX_ADDRESS. */ linux_mem_size = LINUX_INITRD_MAX_ADDRESS; errnum = ERR_NONE; break; case ERR_NONE: { int shift = 0; switch (grub_tolower (*value)) { case 'g': shift += 10; case 'm': shift += 10; case 'k': shift += 10; default: break; } /* Check an overflow. */ if (linux_mem_size > (MAXINT >> shift)) linux_mem_size = LINUX_INITRD_MAX_ADDRESS; else linux_mem_size <<= shift; } break; default: linux_mem_size = 0; errnum = ERR_NONE; break; } } else linux_mem_size = 0; } /* It is possible that DATA_LEN + SECTOR_SIZE is greater than MULTIBOOT_SEARCH, so the data may have been read partially. */ if (data_len + SECTOR_SIZE <= MULTIBOOT_SEARCH) grub_memmove (linux_data_tmp_addr, buffer, data_len + SECTOR_SIZE); else { grub_memmove (linux_data_tmp_addr, buffer, MULTIBOOT_SEARCH); grub_read (linux_data_tmp_addr + MULTIBOOT_SEARCH, data_len + SECTOR_SIZE - MULTIBOOT_SEARCH); } if (lh->header != LINUX_MAGIC_SIGNATURE || lh->version < 0x0200) /* Clear the heap space. */ grub_memset (linux_data_tmp_addr + ((setup_sects + 1) << 9), 0, (64 - setup_sects - 1) << 9); /* Copy command-line plus memory hack to staging area. NOTE: Linux has a bug that it doesn't handle multiple spaces between two options and a space after a "mem=" option isn't removed correctly so the arguments to init could be like {"init", "", "", NULL}. This affects some not-very-clever shells. Thus, the code below does a trick to avoid the bug. That is, copy "mem=XXX" to the end of the command-line, and avoid to copy spaces unnecessarily. Hell. */ { char *src = skip_to (0, arg); char *dest = linux_data_tmp_addr + LINUX_CL_OFFSET; while (dest < linux_data_tmp_addr + LINUX_CL_END_OFFSET && *src) *(dest++) = *(src++); /* Old Linux kernels have problems determining the amount of the available memory. To work around this problem, we add the "mem" option to the kernel command line. This has its own drawbacks because newer kernels can determine the memory map more accurately. Boot protocol 2.03, which appeared in Linux 2.4.18, provides a pointer to the kernel version string, so we could check it. But since kernel 2.4.18 and newer are known to detect memory reliably, boot protocol 2.03 already implies that the kernel is new enough. The "mem" option is added if neither of the following conditions is met: 1) The "mem" option is already present. 2) The "kernel" command is used with "--no-mem-option". 3) GNU GRUB is configured not to pass the "mem" option. 4) The kernel supports boot protocol 2.03 or newer. */ if (! grub_strstr (arg, "mem=") && ! (load_flags & KERNEL_LOAD_NO_MEM_OPTION) && lh->version < 0x0203 /* kernel version < 2.4.18 */ && dest + 15 < linux_data_tmp_addr + LINUX_CL_END_OFFSET) { *dest++ = ' '; *dest++ = 'm'; *dest++ = 'e'; *dest++ = 'm'; *dest++ = '='; dest = convert_to_ascii (dest, 'u', (extended_memory + 0x400)); *dest++ = 'K'; } *dest = 0; } /* offset into file */ grub_seek (data_len + SECTOR_SIZE); cur_addr = (int) linux_data_tmp_addr + LINUX_SETUP_MOVE_SIZE; grub_read ((char *) LINUX_BZIMAGE_ADDR, text_len); if (errnum == ERR_NONE) { grub_close (); /* Sanity check. */ if (suggested_type != KERNEL_TYPE_NONE && ((big_linux && suggested_type != KERNEL_TYPE_BIG_LINUX) || (! big_linux && suggested_type != KERNEL_TYPE_LINUX))) { errnum = ERR_EXEC_FORMAT; return KERNEL_TYPE_NONE; } /* Ugly hack. */ linux_text_len = text_len; return big_linux ? KERNEL_TYPE_BIG_LINUX : KERNEL_TYPE_LINUX; } } } else /* no recognizable format */ errnum = ERR_EXEC_FORMAT; /* return if error */ if (errnum) { grub_close (); return KERNEL_TYPE_NONE; } /* fill the multiboot info structure */ mbi.cmdline = (int) arg; mbi.mods_count = 0; mbi.mods_addr = 0; mbi.boot_device = (current_drive << 24) | current_partition; mbi.flags &= ~(MB_INFO_MODS | MB_INFO_AOUT_SYMS | MB_INFO_ELF_SHDR); mbi.syms.a.tabsize = 0; mbi.syms.a.strsize = 0; mbi.syms.a.addr = 0; mbi.syms.a.pad = 0; printf (" [%s-%s", str2, str); str = ""; if (exec_type) /* can be loaded like a.out */ { if (flags & MULTIBOOT_AOUT_KLUDGE) str = "-and-data"; printf (", loadaddr=0x%x, text%s=0x%x", cur_addr, str, text_len); /* read text, then read data */ if (grub_read ((char *) RAW_ADDR (cur_addr), text_len) == text_len) { cur_addr += text_len; if (!(flags & MULTIBOOT_AOUT_KLUDGE)) { /* we have to align to a 4K boundary */ if (align_4k) cur_addr = (cur_addr + 0xFFF) & 0xFFFFF000; else printf (", C"); printf (", data=0x%x", data_len); if ((grub_read ((char *) RAW_ADDR (cur_addr), data_len) != data_len) && !errnum) errnum = ERR_EXEC_FORMAT; cur_addr += data_len; } if (!errnum) { memset ((char *) RAW_ADDR (cur_addr), 0, bss_len); cur_addr += bss_len; printf (", bss=0x%x", bss_len); } } else if (!errnum) errnum = ERR_EXEC_FORMAT; if (!errnum && pu.aout->a_syms && pu.aout->a_syms < (filemax - filepos)) { int symtab_err, orig_addr = cur_addr; /* we should align to a 4K boundary here for good measure */ if (align_4k) cur_addr = (cur_addr + 0xFFF) & 0xFFFFF000; mbi.syms.a.addr = cur_addr; *((int *) RAW_ADDR (cur_addr)) = pu.aout->a_syms; cur_addr += sizeof (int); printf (", symtab=0x%x", pu.aout->a_syms); if (grub_read ((char *) RAW_ADDR (cur_addr), pu.aout->a_syms) == pu.aout->a_syms) { cur_addr += pu.aout->a_syms; mbi.syms.a.tabsize = pu.aout->a_syms; if (grub_read ((char *) &i, sizeof (int)) == sizeof (int)) { *((int *) RAW_ADDR (cur_addr)) = i; cur_addr += sizeof (int); mbi.syms.a.strsize = i; i -= sizeof (int); printf (", strtab=0x%x", i); symtab_err = (grub_read ((char *) RAW_ADDR (cur_addr), i) != i); cur_addr += i; } else symtab_err = 1; } else symtab_err = 1; if (symtab_err) { printf ("(bad)"); cur_addr = orig_addr; mbi.syms.a.tabsize = 0; mbi.syms.a.strsize = 0; mbi.syms.a.addr = 0; } else mbi.flags |= MB_INFO_AOUT_SYMS; } } else /* ELF executable */ { unsigned loaded = 0, memaddr, memsiz, filesiz; Elf32_Phdr *phdr; /* reset this to zero for now */ cur_addr = 0; /* scan for program segments */ for (i = 0; i < pu.elf->e_phnum; i++) { phdr = (Elf32_Phdr *) (pu.elf->e_phoff + ((int) buffer) + (pu.elf->e_phentsize * i)); if (phdr->p_type == PT_LOAD) { /* offset into file */ grub_seek (phdr->p_offset); filesiz = phdr->p_filesz; if (type == KERNEL_TYPE_FREEBSD || type == KERNEL_TYPE_NETBSD) memaddr = RAW_ADDR (phdr->p_paddr & 0xFFFFFF); else memaddr = RAW_ADDR (phdr->p_paddr); memsiz = phdr->p_memsz; if (memaddr < RAW_ADDR (0x100000)) errnum = ERR_BELOW_1MB; /* If the memory range contains the entry address, get the physical address here. */ if (type == KERNEL_TYPE_MULTIBOOT && (unsigned) entry_addr >= phdr->p_vaddr && (unsigned) entry_addr < phdr->p_vaddr + memsiz) real_entry_addr = (entry_func) ((unsigned) entry_addr + memaddr - phdr->p_vaddr); /* make sure we only load what we're supposed to! */ if (filesiz > memsiz) filesiz = memsiz; /* mark memory as used */ if (cur_addr < memaddr + memsiz) cur_addr = memaddr + memsiz; printf (", <0x%x:0x%x:0x%x>", memaddr, filesiz, memsiz - filesiz); /* increment number of segments */ loaded++; /* load the segment */ if (memcheck (memaddr, memsiz) && grub_read ((char *) memaddr, filesiz) == filesiz) { if (memsiz > filesiz) memset ((char *) (memaddr + filesiz), 0, memsiz - filesiz); } else break; } } if (! errnum) { if (! loaded) errnum = ERR_EXEC_FORMAT; else { /* Load ELF symbols. */ Elf32_Shdr *shdr = NULL; int tab_size, sec_size; int symtab_err = 0; mbi.syms.e.num = pu.elf->e_shnum; mbi.syms.e.size = pu.elf->e_shentsize; mbi.syms.e.shndx = pu.elf->e_shstrndx; /* We should align to a 4K boundary here for good measure. */ if (align_4k) cur_addr = (cur_addr + 0xFFF) & 0xFFFFF000; tab_size = pu.elf->e_shentsize * pu.elf->e_shnum; grub_seek (pu.elf->e_shoff); /* * Should not need to call RAW_ADDR; cur_addr is already * adjusted to account for grub_scratch_mem. * XXX Linux might calculate cur_addr differently. */ if (grub_read ((char *) (cur_addr), tab_size) == tab_size) { mbi.syms.e.addr = cur_addr; shdr = (Elf32_Shdr *) mbi.syms.e.addr; cur_addr += tab_size; printf (", shtab=0x%x", cur_addr); for (i = 0; i < mbi.syms.e.num; i++) { /* This section is a loaded section, so we don't care. */ if (shdr[i].sh_addr != 0) continue; /* This section is empty, so we don't care. */ if (shdr[i].sh_size == 0) continue; /* Align the section to a sh_addralign bits boundary. */ cur_addr = ((cur_addr + shdr[i].sh_addralign) & - (int) shdr[i].sh_addralign); grub_seek (shdr[i].sh_offset); sec_size = shdr[i].sh_size; /* * Should not need to call RAW_ADDR; cur_addr is already * adjusted to account for grub_scratch_mem. * XXX Linux might calculate cur_addr differently. */ if (! (memcheck (cur_addr, sec_size) && (grub_read ((char *) (cur_addr), sec_size) == sec_size))) { symtab_err = 1; break; } shdr[i].sh_addr = cur_addr; cur_addr += sec_size; } } else symtab_err = 1; if (mbi.syms.e.addr < RAW_ADDR(0x10000)) symtab_err = 1; if (symtab_err) { printf ("(bad)"); mbi.syms.e.num = 0; mbi.syms.e.size = 0; mbi.syms.e.addr = 0; mbi.syms.e.shndx = 0; cur_addr = 0; } else mbi.flags |= MB_INFO_ELF_SHDR; } } } if (! errnum) { grub_printf (", entry=0x%x]\n", (unsigned) entry_addr); /* If the entry address is physically different from that of the ELF header, correct it here. */ if (real_entry_addr) entry_addr = real_entry_addr; } else { putchar ('\n'); type = KERNEL_TYPE_NONE; } grub_close (); /* Sanity check. */ if (suggested_type != KERNEL_TYPE_NONE && suggested_type != type) { errnum = ERR_EXEC_FORMAT; return KERNEL_TYPE_NONE; } return type; } int load_module (char *module, char *arg) { int len; /* if we are supposed to load on 4K boundaries */ cur_addr = (cur_addr + 0xFFF) & 0xFFFFF000; if (!grub_open (module)) return 0; len = grub_read ((char *) cur_addr, -1); if (! len) { grub_close (); return 0; } printf (" [Multiboot-module @ 0x%x, 0x%x bytes]\n", cur_addr, len); /* these two simply need to be set if any modules are loaded at all */ mbi.flags |= MB_INFO_MODS; mbi.mods_addr = (int) mll; mll[mbi.mods_count].cmdline = (int) arg; mll[mbi.mods_count].mod_start = cur_addr; cur_addr += len; mll[mbi.mods_count].mod_end = cur_addr; mll[mbi.mods_count].pad = 0; /* increment number of modules included */ mbi.mods_count++; grub_close (); return 1; } int load_initrd (char *initrd) { int len; unsigned long moveto; unsigned long max_addr; struct linux_kernel_header *lh = (struct linux_kernel_header *) (cur_addr - LINUX_SETUP_MOVE_SIZE); #ifndef NO_DECOMPRESSION no_decompression = 1; #endif if (! grub_open (initrd)) goto fail; len = grub_read ((char *) cur_addr, -1); if (! len) { grub_close (); goto fail; } if (linux_mem_size) moveto = linux_mem_size; else moveto = (mbi.mem_upper + 0x400) << 10; moveto = (moveto - len) & 0xfffff000; max_addr = (lh->header == LINUX_MAGIC_SIGNATURE && lh->version >= 0x0203 ? lh->initrd_addr_max : LINUX_INITRD_MAX_ADDRESS); if (moveto + len >= max_addr) moveto = (max_addr - len) & 0xfffff000; /* XXX: Linux 2.3.xx has a bug in the memory range check, so avoid the last page. XXX: Linux 2.2.xx has a bug in the memory range check, which is worse than that of Linux 2.3.xx, so avoid the last 64kb. *sigh* */ moveto -= 0x10000; memmove ((void *) RAW_ADDR (moveto), (void *) cur_addr, len); printf (" [Linux-initrd @ 0x%x, 0x%x bytes]\n", moveto, len); /* FIXME: Should check if the kernel supports INITRD. */ lh->ramdisk_image = RAW_ADDR (moveto); lh->ramdisk_size = len; grub_close (); fail: #ifndef NO_DECOMPRESSION no_decompression = 0; #endif return ! errnum; } #ifdef GRUB_UTIL /* Dummy function to fake the *BSD boot. */ static void bsd_boot_entry (int flags, int bootdev, int sym_start, int sym_end, int mem_upper, int mem_lower) { stop (); } #endif /* * All "*_boot" commands depend on the images being loaded into memory * correctly, the variables in this file being set up correctly, and * the root partition being set in the 'saved_drive' and 'saved_partition' * variables. */ void bsd_boot (kernel_t type, int bootdev, char *arg) { char *str; int clval = 0, i; struct bootinfo bi; #ifdef GRUB_UTIL entry_addr = (entry_func) bsd_boot_entry; #else stop_floppy (); #endif while (*(++arg) && *arg != ' '); str = arg; while (*str) { if (*str == '-') { while (*str && *str != ' ') { if (*str == 'C') clval |= RB_CDROM; if (*str == 'a') clval |= RB_ASKNAME; if (*str == 'b') clval |= RB_HALT; if (*str == 'c') clval |= RB_CONFIG; if (*str == 'd') clval |= RB_KDB; if (*str == 'D') clval |= RB_MULTIPLE; if (*str == 'g') clval |= RB_GDB; if (*str == 'h') clval |= RB_SERIAL; if (*str == 'm') clval |= RB_MUTE; if (*str == 'r') clval |= RB_DFLTROOT; if (*str == 's') clval |= RB_SINGLE; if (*str == 'v') clval |= RB_VERBOSE; str++; } continue; } str++; } if (type == KERNEL_TYPE_FREEBSD) { clval |= RB_BOOTINFO; bi.bi_version = BOOTINFO_VERSION; *arg = 0; while ((--arg) > (char *) MB_CMDLINE_BUF && *arg != '/'); if (*arg == '/') bi.bi_kernelname = arg + 1; else bi.bi_kernelname = 0; bi.bi_nfs_diskless = 0; bi.bi_n_bios_used = 0; /* this field is apparently unused */ for (i = 0; i < N_BIOS_GEOM; i++) { struct geometry geom; /* XXX Should check the return value. */ get_diskinfo (i + 0x80, &geom); /* FIXME: If HEADS or SECTORS is greater than 255, then this will break the geometry information. That is a drawback of BSD but not of GRUB. */ bi.bi_bios_geom[i] = (((geom.cylinders - 1) << 16) + (((geom.heads - 1) & 0xff) << 8) + (geom.sectors & 0xff)); } bi.bi_size = sizeof (struct bootinfo); bi.bi_memsizes_valid = 1; bi.bi_bios_dev = saved_drive; bi.bi_basemem = mbi.mem_lower; bi.bi_extmem = extended_memory; if (mbi.flags & MB_INFO_AOUT_SYMS) { bi.bi_symtab = mbi.syms.a.addr; bi.bi_esymtab = mbi.syms.a.addr + 4 + mbi.syms.a.tabsize + mbi.syms.a.strsize; } #if 0 else if (mbi.flags & MB_INFO_ELF_SHDR) { /* FIXME: Should check if a symbol table exists and, if exists, pass the table to BI. */ } #endif else { bi.bi_symtab = 0; bi.bi_esymtab = 0; } /* call entry point */ (*entry_addr) (clval, bootdev, 0, 0, 0, ((int) (&bi))); } else { /* * We now pass the various bootstrap parameters to the loaded * image via the argument list. * * This is the official list: * * arg0 = 8 (magic) * arg1 = boot flags * arg2 = boot device * arg3 = start of symbol table (0 if not loaded) * arg4 = end of symbol table (0 if not loaded) * arg5 = transfer address from image * arg6 = transfer address for next image pointer * arg7 = conventional memory size (640) * arg8 = extended memory size (8196) * * ...in actuality, we just pass the parameters used by the kernel. */ /* call entry point */ unsigned long end_mark; if (mbi.flags & MB_INFO_AOUT_SYMS) end_mark = (mbi.syms.a.addr + 4 + mbi.syms.a.tabsize + mbi.syms.a.strsize); else /* FIXME: it should be mbi.syms.e.size. */ end_mark = 0; (*entry_addr) (clval, bootdev, 0, end_mark, extended_memory, mbi.mem_lower); } }