1
/* multiboot.c - boot a multiboot OS image. */
3
* GRUB -- GRand Unified Bootloader
4
* Copyright (C) 2003,2004,2005,2007 Free Software Foundation, Inc.
6
* GRUB is free software: you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation, either version 3 of the License, or
9
* (at your option) any later version.
11
* GRUB is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
21
* FIXME: The following features from the Multiboot specification still
22
* need to be implemented:
29
* - ROM configuration table
33
#include <grub/loader.h>
34
#include <grub/machine/loader.h>
35
#include <grub/multiboot.h>
36
#include <grub/machine/init.h>
37
#include <grub/machine/memory.h>
39
#include <grub/file.h>
41
#include <grub/rescue.h>
44
#include <grub/misc.h>
45
#include <grub/gzio.h>
47
extern grub_dl_t my_mod;
48
static struct grub_multiboot_info *mbi;
49
static grub_addr_t entry;
52
grub_multiboot_boot (void)
54
grub_multiboot_real_boot (entry, mbi);
61
grub_multiboot_unload (void)
66
for (i = 0; i < mbi->mods_count; i++)
69
((struct grub_mod_list *) mbi->mods_addr)[i].mod_start);
71
((struct grub_mod_list *) mbi->mods_addr)[i].cmdline);
73
grub_free ((void *) mbi->mods_addr);
74
grub_free ((void *) mbi->cmdline);
80
grub_dl_unref (my_mod);
85
/* Check if BUFFER contains ELF32. */
87
grub_multiboot_is_elf32 (void *buffer)
89
Elf32_Ehdr *ehdr = (Elf32_Ehdr *) buffer;
91
return ehdr->e_ident[EI_CLASS] == ELFCLASS32;
95
grub_multiboot_load_elf32 (grub_file_t file, void *buffer)
97
Elf32_Ehdr *ehdr = (Elf32_Ehdr *) buffer;
101
if (ehdr->e_ident[EI_CLASS] != ELFCLASS32)
102
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF class");
104
if (grub_dl_check_header (ehdr, sizeof(Elf32_Ehdr)))
105
return grub_error (GRUB_ERR_UNKNOWN_OS, "no valid ELF header found");
107
if (ehdr->e_type != ET_EXEC)
108
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF file type");
110
/* FIXME: Should we support program headers at strange locations? */
111
if (ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize > MULTIBOOT_SEARCH)
112
return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset");
114
entry = ehdr->e_entry;
116
/* Load every loadable segment in memory. */
117
for (i = 0; i < ehdr->e_phnum; i++)
119
phdr = (Elf32_Phdr *) ((char *) buffer + ehdr->e_phoff
120
+ i * ehdr->e_phentsize);
121
if (phdr->p_type == PT_LOAD)
123
/* The segment should fit in the area reserved for the OS. */
124
if (phdr->p_paddr < grub_os_area_addr)
125
return grub_error (GRUB_ERR_BAD_OS,
126
"segment doesn't fit in memory reserved for the OS (0x%lx < 0x%lx)",
127
phdr->p_paddr, grub_os_area_addr);
128
if (phdr->p_paddr + phdr->p_memsz > grub_os_area_addr + grub_os_area_size)
129
return grub_error (GRUB_ERR_BAD_OS,
130
"segment doesn't fit in memory reserved for the OS (0x%lx > 0x%lx)",
131
phdr->p_paddr + phdr->p_memsz,
132
grub_os_area_addr + grub_os_area_size);
134
if (grub_file_seek (file, (grub_off_t) phdr->p_offset)
136
return grub_error (GRUB_ERR_BAD_OS,
137
"invalid offset in program header");
139
if (grub_file_read (file, (void *) phdr->p_paddr, phdr->p_filesz)
140
!= (grub_ssize_t) phdr->p_filesz)
141
return grub_error (GRUB_ERR_BAD_OS,
142
"couldn't read segment from file");
144
if (phdr->p_filesz < phdr->p_memsz)
145
grub_memset ((char *) phdr->p_paddr + phdr->p_filesz, 0,
146
phdr->p_memsz - phdr->p_filesz);
153
/* Check if BUFFER contains ELF64. */
155
grub_multiboot_is_elf64 (void *buffer)
157
Elf64_Ehdr *ehdr = (Elf64_Ehdr *) buffer;
159
return ehdr->e_ident[EI_CLASS] == ELFCLASS64;
163
grub_multiboot_load_elf64 (grub_file_t file, void *buffer)
165
Elf64_Ehdr *ehdr = (Elf64_Ehdr *) buffer;
169
if (ehdr->e_ident[EI_CLASS] != ELFCLASS64)
170
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF class");
172
if (ehdr->e_ident[EI_MAG0] != ELFMAG0
173
|| ehdr->e_ident[EI_MAG1] != ELFMAG1
174
|| ehdr->e_ident[EI_MAG2] != ELFMAG2
175
|| ehdr->e_ident[EI_MAG3] != ELFMAG3
176
|| ehdr->e_version != EV_CURRENT
177
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
178
|| ehdr->e_machine != EM_X86_64)
179
return grub_error(GRUB_ERR_UNKNOWN_OS, "no valid ELF header found");
181
if (ehdr->e_type != ET_EXEC)
182
return grub_error (GRUB_ERR_UNKNOWN_OS, "invalid ELF file type");
184
/* FIXME: Should we support program headers at strange locations? */
185
if (ehdr->e_phoff + ehdr->e_phnum * ehdr->e_phentsize > MULTIBOOT_SEARCH)
186
return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset");
188
/* We still in 32-bit mode */
189
if (ehdr->e_entry > 0xffffffff)
190
return grub_error (GRUB_ERR_BAD_OS, "invalid entry point for ELF64");
192
entry = ehdr->e_entry;
194
/* Load every loadable segment in memory. */
195
for (i = 0; i < ehdr->e_phnum; i++)
197
phdr = (Elf64_Phdr *) ((char *) buffer + ehdr->e_phoff
198
+ i * ehdr->e_phentsize);
199
if (phdr->p_type == PT_LOAD)
201
/* The segment should fit in the area reserved for the OS. */
202
if (phdr->p_paddr < (grub_uint64_t) grub_os_area_addr)
203
return grub_error (GRUB_ERR_BAD_OS,
204
"segment doesn't fit in memory reserved for the OS (0x%lx < 0x%lx)",
205
phdr->p_paddr, (grub_uint64_t) grub_os_area_addr);
206
if (phdr->p_paddr + phdr->p_memsz
207
> (grub_uint64_t) grub_os_area_addr + (grub_uint64_t) grub_os_area_size)
208
return grub_error (GRUB_ERR_BAD_OS,
209
"segment doesn't fit in memory reserved for the OS (0x%lx > 0x%lx)",
210
phdr->p_paddr + phdr->p_memsz,
211
(grub_uint64_t) grub_os_area_addr + (grub_uint64_t) grub_os_area_size);
213
if (grub_file_seek (file, (grub_off_t) phdr->p_offset)
215
return grub_error (GRUB_ERR_BAD_OS,
216
"invalid offset in program header");
218
if (grub_file_read (file, (void *) ((grub_uint32_t) phdr->p_paddr),
220
!= (grub_ssize_t) phdr->p_filesz)
221
return grub_error (GRUB_ERR_BAD_OS,
222
"couldn't read segment from file");
224
if (phdr->p_filesz < phdr->p_memsz)
225
grub_memset (((char *) ((grub_uint32_t) phdr->p_paddr)
228
phdr->p_memsz - phdr->p_filesz);
235
/* Load ELF32 or ELF64. */
237
grub_multiboot_load_elf (grub_file_t file, void *buffer)
239
if (grub_multiboot_is_elf32 (buffer))
240
return grub_multiboot_load_elf32 (file, buffer);
241
else if (grub_multiboot_is_elf64 (buffer))
242
return grub_multiboot_load_elf64 (file, buffer);
244
return grub_error (GRUB_ERR_UNKNOWN_OS, "unknown ELF class");
248
grub_multiboot (int argc, char *argv[])
250
grub_file_t file = 0;
251
char buffer[MULTIBOOT_SEARCH], *cmdline = 0, *p;
252
struct grub_multiboot_header *header;
256
grub_loader_unset ();
260
grub_error (GRUB_ERR_BAD_ARGUMENT, "No kernel specified");
264
file = grub_gzfile_open (argv[0], 1);
267
grub_error (GRUB_ERR_BAD_ARGUMENT, "Couldn't open file");
271
len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
274
grub_error (GRUB_ERR_BAD_OS, "File too small");
278
/* Look for the multiboot header in the buffer. The header should
279
be at least 12 bytes and aligned on a 4-byte boundary. */
280
for (header = (struct grub_multiboot_header *) buffer;
281
((char *) header <= buffer + len - 12) || (header = 0);
282
header = (struct grub_multiboot_header *) ((char *) header + 4))
284
if (header->magic == MULTIBOOT_MAGIC
285
&& !(header->magic + header->flags + header->checksum))
291
grub_error (GRUB_ERR_BAD_ARGUMENT, "No multiboot header found");
295
if (header->flags & MULTIBOOT_UNSUPPORTED)
297
grub_error (GRUB_ERR_UNKNOWN_OS,
298
"Unsupported flag: 0x%x", header->flags);
302
if (grub_multiboot_load_elf (file, buffer) != GRUB_ERR_NONE)
305
mbi = grub_malloc (sizeof (struct grub_multiboot_info));
309
mbi->flags = MULTIBOOT_INFO_MEMORY;
311
/* Convert from bytes to kilobytes. */
312
mbi->mem_lower = grub_lower_mem / 1024;
313
mbi->mem_upper = grub_upper_mem / 1024;
315
for (i = 0, len = 0; i < argc; i++)
316
len += grub_strlen (argv[i]) + 1;
318
cmdline = p = grub_malloc (len);
322
for (i = 0; i < argc; i++)
324
p = grub_stpcpy (p, argv[i]);
328
/* Remove the space after the last word. */
331
mbi->flags |= MULTIBOOT_INFO_CMDLINE;
332
mbi->cmdline = (grub_uint32_t) cmdline;
334
mbi->flags |= MULTIBOOT_INFO_BOOT_LOADER_NAME;
335
mbi->boot_loader_name = (grub_uint32_t) grub_strdup (PACKAGE_STRING);
337
grub_loader_set (grub_multiboot_boot, grub_multiboot_unload, 1);
341
grub_file_close (file);
343
if (grub_errno != GRUB_ERR_NONE)
347
grub_dl_unref (my_mod);
353
grub_module (int argc, char *argv[])
355
grub_file_t file = 0;
356
grub_ssize_t size, len = 0;
357
char *module = 0, *cmdline = 0, *p;
362
grub_error (GRUB_ERR_BAD_ARGUMENT, "No module specified");
368
grub_error (GRUB_ERR_BAD_ARGUMENT,
369
"You need to load the multiboot kernel first");
373
file = grub_gzfile_open (argv[0], 1);
377
size = grub_file_size (file);
378
module = grub_memalign (MULTIBOOT_MOD_ALIGN, size);
382
if (grub_file_read (file, module, size) != size)
384
grub_error (GRUB_ERR_FILE_READ_ERROR, "Couldn't read file");
388
for (i = 0; i < argc; i++)
389
len += grub_strlen (argv[i]) + 1;
391
cmdline = p = grub_malloc (len);
395
for (i = 0; i < argc; i++)
397
p = grub_stpcpy (p, argv[i]);
401
/* Remove the space after the last word. */
404
if (mbi->flags & MULTIBOOT_INFO_MODS)
406
struct grub_mod_list *modlist = (struct grub_mod_list *) mbi->mods_addr;
408
modlist = grub_realloc (modlist, (mbi->mods_count + 1)
409
* sizeof (struct grub_mod_list));
412
mbi->mods_addr = (grub_uint32_t) modlist;
413
modlist += mbi->mods_count;
414
modlist->mod_start = (grub_uint32_t) module;
415
modlist->mod_end = (grub_uint32_t) module + size;
416
modlist->cmdline = (grub_uint32_t) cmdline;
422
struct grub_mod_list *modlist = grub_malloc (sizeof (struct grub_mod_list));
425
modlist->mod_start = (grub_uint32_t) module;
426
modlist->mod_end = (grub_uint32_t) module + size;
427
modlist->cmdline = (grub_uint32_t) cmdline;
430
mbi->mods_addr = (grub_uint32_t) modlist;
431
mbi->flags |= MULTIBOOT_INFO_MODS;
436
grub_file_close (file);
438
if (grub_errno != GRUB_ERR_NONE)