#include <config.h>
#include <grub/types.h>
-#include <grub/machine/boot.h>
-#include <grub/machine/kernel.h>
-#include <grub/machine/memory.h>
#include <grub/elf.h>
#include <grub/aout.h>
#include <grub/i18n.h>
#include <grub/util/misc.h>
#include <grub/util/resolve.h>
#include <grub/misc.h>
+#include <grub/offsets.h>
#include <time.h>
#include <stdio.h>
#include "progname.h"
-#define ALIGN_ADDR(x) (ALIGN_UP((x), GRUB_TARGET_SIZEOF_VOID_P))
+#define ALIGN_ADDR(x) (ALIGN_UP((x), image_target->voidp_sizeof))
+
+#define TARGET_NO_FIELD 0xffffffff
+struct image_target_desc
+{
+ const char *name;
+ grub_size_t voidp_sizeof;
+ int bigendian;
+ enum {
+ IMAGE_I386_PC, IMAGE_EFI, IMAGE_COREBOOT,
+ IMAGE_SPARC64_AOUT, IMAGE_SPARC64_RAW, IMAGE_I386_IEEE1275,
+ IMAGE_YEELOONG_ELF, IMAGE_QEMU, IMAGE_PPC
+ } id;
+ enum {FORMAT_RAW, FORMAT_AOUT, FORMAT_ELF, FORMAT_PE} format;
+ enum
+ {
+ PLATFORM_FLAGS_NONE = 0,
+ PLATFORM_FLAGS_LZMA = 1
+ } flags;
+ unsigned prefix;
+ unsigned data_end;
+ unsigned raw_size;
+ unsigned total_module_size;
+ unsigned kernel_image_size;
+ unsigned compressed_size;
+ unsigned link_align;
+ grub_uint16_t elf_target;
+ unsigned section_align;
+ signed vaddr_offset;
+ unsigned install_dos_part, install_bsd_part;
+};
+
+struct image_target_desc image_targets[] =
+ {
+ {"i386-coreboot", 4, 0, IMAGE_COREBOOT, FORMAT_ELF, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0
+ },
+ {"i386-pc", 4, 0, IMAGE_I386_PC, FORMAT_RAW, PLATFORM_FLAGS_LZMA,
+ GRUB_KERNEL_I386_PC_PREFIX, GRUB_KERNEL_I386_PC_DATA_END,
+ GRUB_KERNEL_I386_PC_RAW_SIZE, GRUB_KERNEL_I386_PC_TOTAL_MODULE_SIZE,
+ GRUB_KERNEL_I386_PC_KERNEL_IMAGE_SIZE, GRUB_KERNEL_I386_PC_COMPRESSED_SIZE,
+ .section_align = 1,
+ .vaddr_offset = 0,
+ GRUB_KERNEL_I386_PC_INSTALL_DOS_PART, GRUB_KERNEL_I386_PC_INSTALL_BSD_PART
+ },
+ {"i386-efi", 4, 0, IMAGE_EFI, FORMAT_PE, PLATFORM_FLAGS_NONE,
+ .section_align = GRUB_PE32_SECTION_ALIGNMENT,
+ .vaddr_offset = ALIGN_UP (sizeof (struct grub_pe32_header)
+ + 5 * sizeof (struct grub_pe32_section_table),
+ GRUB_PE32_SECTION_ALIGNMENT)
+ },
+ {"i386-ieee1275", 4, 0, IMAGE_I386_IEEE1275, FORMAT_ELF, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ {"i386-qemu", 4, 0, IMAGE_QEMU, FORMAT_RAW, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ {"x86_64-efi", 8, 0, IMAGE_EFI, FORMAT_PE, PLATFORM_FLAGS_NONE,
+ .section_align = GRUB_PE32_SECTION_ALIGNMENT,
+ .vaddr_offset = ALIGN_UP (sizeof (struct grub_pe32_header)
+ + 5 * sizeof (struct grub_pe32_section_table),
+ GRUB_PE32_SECTION_ALIGNMENT)
+ },
+ {"mipsel-yeeloong-elf", 4, 0, IMAGE_YEELOONG_ELF, FORMAT_ELF, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ {"powerpc-ieee1275", 4, 1, IMAGE_PPC, FORMAT_ELF, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ {"sparc64-ieee1275-raw", 8, 1, IMAGE_SPARC64_RAW,
+ FORMAT_RAW, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ {"sparc64-ieee1275-aout", 8, 1, IMAGE_SPARC64_AOUT,
+ FORMAT_AOUT, PLATFORM_FLAGS_NONE,
+ .section_align = 1,
+ .vaddr_offset = 0},
+ };
+
+#define grub_target_to_host32(x) (grub_target_to_host32_real (image_target, (x)))
+#define grub_host_to_target32(x) (grub_host_to_target32_real (image_target, (x)))
+#define grub_target_to_host16(x) (grub_target_to_host16_real (image_target, (x)))
+#define grub_host_to_target16(x) (grub_host_to_target16_real (image_target, (x)))
+
+static inline grub_uint32_t
+grub_target_to_host32_real (struct image_target_desc *image_target, grub_uint32_t in)
+{
+ if (image_target->bigendian)
+ return grub_be_to_cpu32 (in);
+ else
+ return grub_le_to_cpu32 (in);
+}
+
+static inline grub_uint64_t
+grub_target_to_host64_real (struct image_target_desc *image_target, grub_uint64_t in)
+{
+ if (image_target->bigendian)
+ return grub_be_to_cpu64 (in);
+ else
+ return grub_le_to_cpu64 (in);
+}
+
+static inline grub_uint32_t
+grub_target_to_host_real (struct image_target_desc *image_target, grub_uint32_t in)
+{
+ if (image_target->voidp_sizeof == 8)
+ return grub_target_to_host64_real (image_target, in);
+ else
+ return grub_target_to_host32_real (image_target, in);
+}
+
+static inline grub_uint32_t
+grub_host_to_target32_real (struct image_target_desc *image_target, grub_uint32_t in)
+{
+ if (image_target->bigendian)
+ return grub_cpu_to_be32 (in);
+ else
+ return grub_cpu_to_le32 (in);
+}
+
+static inline grub_uint16_t
+grub_target_to_host16_real (struct image_target_desc *image_target, grub_uint16_t in)
+{
+ if (image_target->bigendian)
+ return grub_be_to_cpu16 (in);
+ else
+ return grub_le_to_cpu16 (in);
+}
+
+static inline grub_uint16_t
+grub_host_to_target16_real (struct image_target_desc *image_target, grub_uint16_t in)
+{
+ if (image_target->bigendian)
+ return grub_cpu_to_be16 (in);
+ else
+ return grub_cpu_to_le16 (in);
+}
#define GRUB_IEEE1275_NOTE_NAME "PowerPC"
#define GRUB_IEEE1275_NOTE_TYPE 0x1275
struct grub_ieee1275_note_desc descriptor;
};
-#ifdef GRUB_MACHINE_EFI
-#define SECTION_ALIGN GRUB_PE32_SECTION_ALIGNMENT
-#define VADDR_OFFSET ALIGN_UP (sizeof (struct grub_pe32_header) + 5 * sizeof (struct grub_pe32_section_table), SECTION_ALIGN)
-#else
-#define SECTION_ALIGN 1
-#define VADDR_OFFSET 0
-#endif
-
-#if GRUB_TARGET_WORDSIZE == 32
-# define grub_target_to_host(val) grub_target_to_host32(val)
-#elif GRUB_TARGET_WORDSIZE == 64
-# define grub_target_to_host(val) grub_target_to_host64(val)
-#endif
+#define grub_target_to_host(val) grub_target_to_host_real(image_target, (val))
-#ifdef ENABLE_LZMA
#include <grub/lib/LzmaEnc.h>
static void *SzAlloc(void *p, size_t size) { p = p; return xmalloc(size); }
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
static void
-compress_kernel (char *kernel_img, size_t kernel_size,
- char **core_img, size_t *core_size)
+compress_kernel_lzma (char *kernel_img, size_t kernel_size,
+ char **core_img, size_t *core_size, size_t raw_size)
{
CLzmaEncProps props;
unsigned char out_props[5];
props.pb = 2;
props.numThreads = 1;
- if (kernel_size < GRUB_KERNEL_MACHINE_RAW_SIZE)
+ if (kernel_size < raw_size)
grub_util_error (_("the core image is too small"));
*core_img = xmalloc (kernel_size);
- memcpy (*core_img, kernel_img, GRUB_KERNEL_MACHINE_RAW_SIZE);
-
- *core_size = kernel_size - GRUB_KERNEL_MACHINE_RAW_SIZE;
- if (LzmaEncode((unsigned char *) *core_img + GRUB_KERNEL_MACHINE_RAW_SIZE,
- core_size,
- (unsigned char *) kernel_img + GRUB_KERNEL_MACHINE_RAW_SIZE,
- kernel_size - GRUB_KERNEL_MACHINE_RAW_SIZE,
- &props, out_props, &out_props_size,
- 0, NULL, &g_Alloc, &g_Alloc) != SZ_OK)
+ memcpy (*core_img, kernel_img, raw_size);
+
+ *core_size = kernel_size - raw_size;
+ if (LzmaEncode ((unsigned char *) *core_img + raw_size, core_size,
+ (unsigned char *) kernel_img + raw_size,
+ kernel_size - raw_size,
+ &props, out_props, &out_props_size,
+ 0, NULL, &g_Alloc, &g_Alloc) != SZ_OK)
grub_util_error (_("cannot compress the kernel image"));
- *core_size += GRUB_KERNEL_MACHINE_RAW_SIZE;
+ *core_size += raw_size;
}
-#else /* No lzma compression */
-
static void
-compress_kernel (char *kernel_img, size_t kernel_size,
- char **core_img, size_t *core_size)
+compress_kernel (struct image_target_desc *image_target, char *kernel_img,
+ size_t kernel_size, char **core_img, size_t *core_size)
{
+ if (image_target->flags & PLATFORM_FLAGS_LZMA)
+ {
+ compress_kernel_lzma (kernel_img, kernel_size, core_img,
+ core_size, image_target->raw_size);
+ return;
+ }
+
*core_img = xmalloc (kernel_size);
memcpy (*core_img, kernel_img, kernel_size);
*core_size = kernel_size;
}
-#endif /* No lzma compression */
-
-#ifdef GRUB_MACHINE_EFI
/* Relocate symbols; note that this function overwrites the symbol table.
Return the address of a start symbol. */
static Elf_Addr
relocate_symbols (Elf_Ehdr *e, Elf_Shdr *sections,
Elf_Shdr *symtab_section, Elf_Addr *section_addresses,
- Elf_Half section_entsize, Elf_Half num_sections)
+ Elf_Half section_entsize, Elf_Half num_sections,
+ struct image_target_desc *image_target)
{
Elf_Word symtab_size, sym_size, num_syms;
Elf_Off symtab_offset;
/* Return the address of a symbol at the index I in the section S. */
static Elf_Addr
-get_symbol_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Word i)
+get_symbol_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Word i,
+ struct image_target_desc *image_target)
{
Elf_Sym *sym;
/* Return the address of a modified value. */
static Elf_Addr *
-get_target_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Addr offset)
+get_target_address (Elf_Ehdr *e, Elf_Shdr *s, Elf_Addr offset,
+ struct image_target_desc *image_target)
{
return (Elf_Addr *) ((char *) e + grub_target_to_host32 (s->sh_offset) + offset);
}
relocate_addresses (Elf_Ehdr *e, Elf_Shdr *sections,
Elf_Addr *section_addresses,
Elf_Half section_entsize, Elf_Half num_sections,
- const char *strtab)
+ const char *strtab, struct image_target_desc *image_target)
{
Elf_Half i;
Elf_Shdr *s;
Elf_Addr addend;
offset = grub_target_to_host (r->r_offset);
- target = get_target_address (e, target_section, offset);
+ target = get_target_address (e, target_section, offset, image_target);
info = grub_target_to_host (r->r_info);
sym_addr = get_symbol_address (e, symtab_section,
- ELF_R_SYM (info));
+ ELF_R_SYM (info), image_target);
addend = (s->sh_type == grub_target_to_host32 (SHT_RELA)) ?
r->r_addend : 0;
- switch (ELF_R_TYPE (info))
- {
-#if GRUB_TARGET_SIZEOF_VOID_P == 4
- case R_386_NONE:
- break;
-
- case R_386_32:
- /* This is absolute. */
- *target = grub_host_to_target32 (grub_target_to_host32 (*target)
- + addend + sym_addr);
- grub_util_info ("relocating an R_386_32 entry to 0x%x at the offset 0x%x",
- *target, offset);
- break;
-
- case R_386_PC32:
- /* This is relative. */
- *target = grub_host_to_target32 (grub_target_to_host32 (*target)
- + addend + sym_addr
- - target_section_addr - offset
- - VADDR_OFFSET);
- grub_util_info ("relocating an R_386_PC32 entry to 0x%x at the offset 0x%x",
- *target, offset);
- break;
-
-#else
-
- case R_X86_64_NONE:
- break;
-
- case R_X86_64_64:
- *target = grub_host_to_target64 (grub_target_to_host64 (*target)
- + addend + sym_addr);
- grub_util_info ("relocating an R_X86_64_64 entry to 0x%llx at the offset 0x%llx",
- *target, offset);
- break;
-
- case R_X86_64_PC32:
- {
- grub_uint32_t *t32 = (grub_uint32_t *) target;
- *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
- + addend + sym_addr
- - target_section_addr - offset
- - VADDR_OFFSET);
- grub_util_info ("relocating an R_X86_64_PC32 entry to 0x%x at the offset 0x%llx",
- *t32, offset);
- break;
- }
-
- case R_X86_64_32:
- case R_X86_64_32S:
- {
- grub_uint32_t *t32 = (grub_uint32_t *) target;
- *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
- + addend + sym_addr);
- grub_util_info ("relocating an R_X86_64_32(S) entry to 0x%x at the offset 0x%llx",
- *t32, offset);
- break;
- }
+ if (image_target->voidp_sizeof == 4)
+ switch (ELF_R_TYPE (info))
+ {
+ case R_386_NONE:
+ break;
+
+ case R_386_32:
+ /* This is absolute. */
+ *target = grub_host_to_target32 (grub_target_to_host32 (*target)
+ + addend + sym_addr);
+ grub_util_info ("relocating an R_386_32 entry to 0x%x at the offset 0x%x",
+ *target, offset);
+ break;
+
+ case R_386_PC32:
+ /* This is relative. */
+ *target = grub_host_to_target32 (grub_target_to_host32 (*target)
+ + addend + sym_addr
+ - target_section_addr - offset
+ - image_target->vaddr_offset);
+ grub_util_info ("relocating an R_386_PC32 entry to 0x%x at the offset 0x%x",
+ *target, offset);
+ break;
+ default:
+ grub_util_error ("unknown relocation type %d",
+ ELF_R_TYPE (info));
+ break;
+ }
+ else
+ switch (ELF_R_TYPE (info))
+ {
-#endif
- default:
- grub_util_error ("unknown relocation type %d",
- ELF_R_TYPE (info));
- break;
- }
+ case R_X86_64_NONE:
+ break;
+
+ case R_X86_64_64:
+ *target = grub_host_to_target64 (grub_target_to_host64 (*target)
+ + addend + sym_addr);
+ grub_util_info ("relocating an R_X86_64_64 entry to 0x%llx at the offset 0x%llx",
+ *target, offset);
+ break;
+
+ case R_X86_64_PC32:
+ {
+ grub_uint32_t *t32 = (grub_uint32_t *) target;
+ *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
+ + addend + sym_addr
+ - target_section_addr - offset
+ - image_target->vaddr_offset);
+ grub_util_info ("relocating an R_X86_64_PC32 entry to 0x%x at the offset 0x%llx",
+ *t32, offset);
+ break;
+ }
+
+ case R_X86_64_32:
+ case R_X86_64_32S:
+ {
+ grub_uint32_t *t32 = (grub_uint32_t *) target;
+ *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
+ + addend + sym_addr);
+ grub_util_info ("relocating an R_X86_64_32(S) entry to 0x%x at the offset 0x%llx",
+ *t32, offset);
+ break;
+ }
+
+ default:
+ grub_util_error ("unknown relocation type %d",
+ ELF_R_TYPE (info));
+ break;
+ }
}
}
}
after having written to the file OUT. */
Elf_Addr
add_fixup_entry (struct fixup_block_list **cblock, grub_uint16_t type,
- Elf_Addr addr, int flush, Elf_Addr current_address)
+ Elf_Addr addr, int flush, Elf_Addr current_address,
+ struct image_target_desc *image_target)
{
struct grub_pe32_fixup_block *b;
size_t index;
next_address = current_address + b->block_size;
- padding_size = ((ALIGN_UP (next_address, SECTION_ALIGN)
+ padding_size = ((ALIGN_UP (next_address, image_target->section_align)
- next_address)
>> 1);
index = ((b->block_size - sizeof (*b)) >> 1);
make_reloc_section (Elf_Ehdr *e, void **out,
Elf_Addr *section_addresses, Elf_Shdr *sections,
Elf_Half section_entsize, Elf_Half num_sections,
- const char *strtab)
+ const char *strtab, struct image_target_desc *image_target)
{
Elf_Half i;
Elf_Shdr *s;
info = grub_le_to_cpu32 (r->r_info);
/* Necessary to relocate only absolute addresses. */
-#if GRUB_TARGET_SIZEOF_VOID_P == 4
- if (ELF_R_TYPE (info) == R_386_32)
+ if (image_target->voidp_sizeof == 4)
{
- Elf_Addr addr;
-
- addr = section_address + offset;
- grub_util_info ("adding a relocation entry for 0x%x", addr);
- current_address = add_fixup_entry (&lst,
- GRUB_PE32_REL_BASED_HIGHLOW,
- addr, 0, current_address);
+ if (ELF_R_TYPE (info) == R_386_32)
+ {
+ Elf_Addr addr;
+
+ addr = section_address + offset;
+ grub_util_info ("adding a relocation entry for 0x%x", addr);
+ current_address = add_fixup_entry (&lst,
+ GRUB_PE32_REL_BASED_HIGHLOW,
+ addr, 0, current_address,
+ image_target);
+ }
}
-#else
- if ((ELF_R_TYPE (info) == R_X86_64_32) ||
- (ELF_R_TYPE (info) == R_X86_64_32S))
- {
- grub_util_error ("can\'t add fixup entry for R_X86_64_32(S)");
- }
- else if (ELF_R_TYPE (info) == R_X86_64_64)
+ else
{
- Elf_Addr addr;
-
- addr = section_address + offset;
- grub_util_info ("adding a relocation entry for 0x%llx", addr);
- current_address = add_fixup_entry (&lst,
- GRUB_PE32_REL_BASED_DIR64,
- addr,
- 0, current_address);
+ if ((ELF_R_TYPE (info) == R_X86_64_32) ||
+ (ELF_R_TYPE (info) == R_X86_64_32S))
+ {
+ grub_util_error ("can\'t add fixup entry for R_X86_64_32(S)");
+ }
+ else if (ELF_R_TYPE (info) == R_X86_64_64)
+ {
+ Elf_Addr addr;
+
+ addr = section_address + offset;
+ grub_util_info ("adding a relocation entry for 0x%llx", addr);
+ current_address = add_fixup_entry (&lst,
+ GRUB_PE32_REL_BASED_DIR64,
+ addr,
+ 0, current_address,
+ image_target);
+ }
}
-#endif
}
}
- current_address = add_fixup_entry (&lst, 0, 0, 1, current_address);
+ current_address = add_fixup_entry (&lst, 0, 0, 1, current_address, image_target);
{
grub_uint8_t *ptr;
return current_address;
}
-#endif
-
/* Determine if this section is a text section. Return false if this
section is not allocated. */
static int
-is_text_section (Elf_Shdr *s)
+is_text_section (Elf_Shdr *s, struct image_target_desc *image_target)
{
-#ifndef GRUB_MACHINE_EFI
- if (grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
+ if (image_target->id != IMAGE_EFI
+ && grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
return 0;
-#endif
return ((grub_target_to_host32 (s->sh_flags) & (SHF_EXECINSTR | SHF_ALLOC))
== (SHF_EXECINSTR | SHF_ALLOC));
}
BSS is also a data section, since the converter initializes BSS
when producing PE32 to avoid a bug in EFI implementations. */
static int
-is_data_section (Elf_Shdr *s)
+is_data_section (Elf_Shdr *s, struct image_target_desc *image_target)
{
-#ifndef GRUB_MACHINE_EFI
- if (grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
+ if (image_target->id != IMAGE_EFI
+ && grub_target_to_host32 (s->sh_type) != SHT_PROGBITS)
return 0;
-#endif
return ((grub_target_to_host32 (s->sh_flags) & (SHF_EXECINSTR | SHF_ALLOC))
== SHF_ALLOC);
}
static Elf_Addr *
locate_sections (Elf_Shdr *sections, Elf_Half section_entsize,
Elf_Half num_sections, const char *strtab,
- grub_size_t *exec_size, grub_size_t *kernel_sz)
+ grub_size_t *exec_size, grub_size_t *kernel_sz,
+ struct image_target_desc *image_target)
{
int i;
Elf_Addr current_address;
for (i = 0, s = sections;
i < num_sections;
i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
- if (is_text_section (s))
+ if (is_text_section (s, image_target))
{
Elf_Word align = grub_host_to_target32 (s->sh_addralign);
const char *name = strtab + grub_host_to_target32 (s->sh_name);
if (align)
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, align)
- - VADDR_OFFSET;
+ current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
+ align) - image_target->vaddr_offset;
grub_util_info ("locating the section %s at 0x%x",
name, current_address);
current_address += grub_host_to_target32 (s->sh_size);
}
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, SECTION_ALIGN)
- - VADDR_OFFSET;
+ current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
+ image_target->section_align)
+ - image_target->vaddr_offset;
*exec_size = current_address;
/* .data */
for (i = 0, s = sections;
i < num_sections;
i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
- if (is_data_section (s))
+ if (is_data_section (s, image_target))
{
Elf_Word align = grub_host_to_target32 (s->sh_addralign);
const char *name = strtab + grub_host_to_target32 (s->sh_name);
if (align)
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, align)
- - VADDR_OFFSET;
+ current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
+ align)
+ - image_target->vaddr_offset;
grub_util_info ("locating the section %s at 0x%x",
name, current_address);
current_address += grub_host_to_target32 (s->sh_size);
}
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, SECTION_ALIGN)
- - VADDR_OFFSET;
+ current_address = ALIGN_UP (current_address + image_target->vaddr_offset,
+ image_target->section_align) - image_target->vaddr_offset;
*kernel_sz = current_address;
return section_addresses;
}
/* Return if the ELF header is valid. */
static int
-check_elf_header (Elf_Ehdr *e, size_t size)
+check_elf_header (Elf_Ehdr *e, size_t size, struct image_target_desc *image_target)
{
if (size < sizeof (*e)
|| e->e_ident[EI_MAG0] != ELFMAG0
load_image (const char *kernel_path, grub_size_t *exec_size,
grub_size_t *kernel_sz, grub_size_t *bss_size,
grub_size_t total_module_size, Elf_Addr *start,
- void **reloc_section, grub_size_t *reloc_size)
+ void **reloc_section, grub_size_t *reloc_size,
+ struct image_target_desc *image_target)
{
char *kernel_img, *out_img;
const char *strtab;
grub_util_load_image (kernel_path, kernel_img);
e = (Elf_Ehdr *) kernel_img;
- if (! check_elf_header (e, kernel_size))
+ if (! check_elf_header (e, kernel_size, image_target))
grub_util_error ("invalid ELF header");
section_offset = grub_target_to_host32 (e->e_shoff);
section_addresses = locate_sections (sections, section_entsize,
num_sections, strtab,
- exec_size, kernel_sz);
+ exec_size, kernel_sz, image_target);
-#ifdef GRUB_MACHINE_EFI
- {
- section_vaddresses = xmalloc (sizeof (*section_addresses) * num_sections);
+ if (image_target->id == IMAGE_EFI)
+ {
+ section_vaddresses = xmalloc (sizeof (*section_addresses) * num_sections);
- for (i = 0; i < num_sections; i++)
- section_vaddresses[i] = section_addresses[i] + VADDR_OFFSET;
+ for (i = 0; i < num_sections; i++)
+ section_vaddresses[i] = section_addresses[i] + image_target->vaddr_offset;
#if 0
- {
- Elf_Addr current_address = *kernel_sz;
+ {
+ Elf_Addr current_address = *kernel_sz;
- for (i = 0, s = sections;
- i < num_sections;
- i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
- if (grub_target_to_host32 (s->sh_type) == SHT_NOBITS)
- {
- Elf_Word align = grub_host_to_target32 (s->sh_addralign);
- const char *name = strtab + grub_host_to_target32 (s->sh_name);
+ for (i = 0, s = sections;
+ i < num_sections;
+ i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+ if (grub_target_to_host32 (s->sh_type) == SHT_NOBITS)
+ {
+ Elf_Word align = grub_host_to_target32 (s->sh_addralign);
+ const char *name = strtab + grub_host_to_target32 (s->sh_name);
- if (align)
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, align)
- - VADDR_OFFSET;
+ if (align)
+ current_address = ALIGN_UP (current_address + VADDR_OFFSET, align)
+ - VADDR_OFFSET;
- grub_util_info ("locating the section %s at 0x%x",
- name, current_address);
- section_vaddresses[i] = current_address + VADDR_OFFSET;
- current_address += grub_host_to_target32 (s->sh_size);
- }
- current_address = ALIGN_UP (current_address + VADDR_OFFSET, SECTION_ALIGN)
- - VADDR_OFFSET;
- *bss_size = current_address - *kernel_sz;
- }
+ grub_util_info ("locating the section %s at 0x%x",
+ name, current_address);
+ section_vaddresses[i] = current_address + VADDR_OFFSET;
+ current_address += grub_host_to_target32 (s->sh_size);
+ }
+ current_address = ALIGN_UP (current_address + VADDR_OFFSET, SECTION_ALIGN)
+ - VADDR_OFFSET;
+ *bss_size = current_address - *kernel_sz;
+ }
#else
- *bss_size = 0;
+ *bss_size = 0;
#endif
- symtab_section = NULL;
- for (i = 0, s = sections;
- i < num_sections;
- i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
- if (s->sh_type == grub_host_to_target32 (SHT_SYMTAB))
- {
- symtab_section = s;
- break;
- }
+ symtab_section = NULL;
+ for (i = 0, s = sections;
+ i < num_sections;
+ i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
+ if (s->sh_type == grub_host_to_target32 (SHT_SYMTAB))
+ {
+ symtab_section = s;
+ break;
+ }
- if (! symtab_section)
- grub_util_error ("no symbol table");
+ if (! symtab_section)
+ grub_util_error ("no symbol table");
- *start = relocate_symbols (e, sections, symtab_section,
- section_vaddresses, section_entsize,
- num_sections);
- if (*start == 0)
- grub_util_error ("start symbol is not defined");
+ *start = relocate_symbols (e, sections, symtab_section,
+ section_vaddresses, section_entsize,
+ num_sections, image_target);
+ if (*start == 0)
+ grub_util_error ("start symbol is not defined");
- /* Resolve addresses in the virtual address space. */
- relocate_addresses (e, sections, section_addresses, section_entsize,
- num_sections, strtab);
+ /* Resolve addresses in the virtual address space. */
+ relocate_addresses (e, sections, section_addresses, section_entsize,
+ num_sections, strtab, image_target);
- *reloc_size = make_reloc_section (e, reloc_section,
- section_vaddresses, sections,
- section_entsize, num_sections,
- strtab);
+ *reloc_size = make_reloc_section (e, reloc_section,
+ section_vaddresses, sections,
+ section_entsize, num_sections,
+ strtab, image_target);
- }
-#else
- *bss_size = 0;
- *reloc_size = 0;
- *reloc_section = NULL;
-#endif
+ }
+ else
+ {
+ *bss_size = 0;
+ *reloc_size = 0;
+ *reloc_section = NULL;
+ }
out_img = xmalloc (*kernel_sz + total_module_size);
for (i = 0, s = sections;
i < num_sections;
i++, s = (Elf_Shdr *) ((char *) s + section_entsize))
- if (is_data_section (s) || is_text_section (s))
+ if (is_data_section (s, image_target) || is_text_section (s, image_target))
{
if (grub_target_to_host32 (s->sh_type) == SHT_NOBITS)
memset (out_img + section_addresses[i], 0,
static void
generate_image (const char *dir, char *prefix, FILE *out, char *mods[],
char *memdisk_path, char *font_path, char *config_path,
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
- grub_platform_image_format_t format,
-#else
- int dummy __attribute__ ((unused)),
-#endif
- int note
-)
+ struct image_target_desc *image_target, int note)
{
char *kernel_img, *core_img;
size_t kernel_size, total_module_size, core_size, exec_size;
kernel_img = load_image (kernel_path, &exec_size, &kernel_size, &bss_size,
total_module_size, &start_address, &rel_section,
- &reloc_size);
+ &reloc_size, image_target);
- if (GRUB_KERNEL_MACHINE_PREFIX + strlen (prefix) + 1 > GRUB_KERNEL_MACHINE_DATA_END)
+ if (image_target->prefix + strlen (prefix) + 1 > image_target->data_end)
grub_util_error (_("prefix is too long"));
- strcpy (kernel_img + GRUB_KERNEL_MACHINE_PREFIX, prefix);
+ strcpy (kernel_img + image_target->prefix, prefix);
/* Fill in the grub_module_info structure. */
modinfo = (struct grub_module_info *) (kernel_img + kernel_size);
}
grub_util_info ("kernel_img=%p, kernel_size=0x%x", kernel_img, kernel_size);
- compress_kernel (kernel_img, kernel_size + total_module_size,
+ compress_kernel (image_target, kernel_img, kernel_size + total_module_size,
&core_img, &core_size);
grub_util_info ("the core size is 0x%x", core_size);
-#ifdef GRUB_KERNEL_MACHINE_TOTAL_MODULE_SIZE
- *((grub_uint32_t *) (core_img + GRUB_KERNEL_MACHINE_TOTAL_MODULE_SIZE))
- = grub_host_to_target32 (total_module_size);
-#endif
-#ifdef GRUB_KERNEL_MACHINE_KERNEL_IMAGE_SIZE
- *((grub_uint32_t *) (core_img + GRUB_KERNEL_MACHINE_KERNEL_IMAGE_SIZE))
- = grub_host_to_target32 (kernel_size);
-#endif
-#ifdef GRUB_KERNEL_MACHINE_COMPRESSED_SIZE
- *((grub_uint32_t *) (core_img + GRUB_KERNEL_MACHINE_COMPRESSED_SIZE))
- = grub_host_to_target32 (core_size - GRUB_KERNEL_MACHINE_RAW_SIZE);
-#endif
+ if (image_target->total_module_size != TARGET_NO_FIELD)
+ *((grub_uint32_t *) (core_img + image_target->total_module_size))
+ = grub_host_to_target32 (total_module_size);
+ if (image_target->kernel_image_size != TARGET_NO_FIELD)
+ *((grub_uint32_t *) (core_img + image_target->kernel_image_size))
+ = grub_host_to_target32 (kernel_size);
+ if (image_target->compressed_size != TARGET_NO_FIELD)
+ *((grub_uint32_t *) (core_img + image_target->compressed_size))
+ = grub_host_to_target32 (core_size - image_target->raw_size);
-#if defined(GRUB_KERNEL_MACHINE_INSTALL_DOS_PART) && defined(GRUB_KERNEL_MACHINE_INSTALL_BSD_PART)
/* If we included a drive in our prefix, let GRUB know it doesn't have to
prepend the drive told by BIOS. */
- if (prefix[0] == '(')
+ if (image_target->install_dos_part != TARGET_NO_FIELD
+ && image_target->install_bsd_part != TARGET_NO_FIELD && prefix[0] == '(')
{
- *((grub_int32_t *) (core_img + GRUB_KERNEL_MACHINE_INSTALL_DOS_PART))
+ *((grub_int32_t *) (core_img + image_target->install_dos_part))
= grub_host_to_target32 (-2);
- *((grub_int32_t *) (core_img + GRUB_KERNEL_MACHINE_INSTALL_BSD_PART))
+ *((grub_int32_t *) (core_img + image_target->install_bsd_part))
= grub_host_to_target32 (-2);
}
-#endif
-#ifdef GRUB_MACHINE_PCBIOS
- if (GRUB_KERNEL_MACHINE_LINK_ADDR + core_size > GRUB_MEMORY_MACHINE_UPPER)
- grub_util_error (_("core image is too big (%p > %p)"),
- GRUB_KERNEL_MACHINE_LINK_ADDR + core_size,
- GRUB_MEMORY_MACHINE_UPPER);
-#endif
+ switch (image_target->id)
+ {
+ case IMAGE_I386_PC:
+ {
+ unsigned num;
+ char *boot_path, *boot_img;
+ size_t boot_size;
-#if defined(GRUB_MACHINE_PCBIOS)
- {
- unsigned num;
- char *boot_path, *boot_img;
- size_t boot_size;
- num = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
- if (num > 0xffff)
- grub_util_error (_("the core image is too big"));
+ if (GRUB_KERNEL_MACHINE_LINK_ADDR + core_size > GRUB_MEMORY_I386_PC_UPPER)
+ grub_util_error (_("core image is too big (%p > %p)"),
+ GRUB_KERNEL_MACHINE_LINK_ADDR + core_size,
+ GRUB_MEMORY_I386_PC_UPPER);
- boot_path = grub_util_get_path (dir, "diskboot.img");
- boot_size = grub_util_get_image_size (boot_path);
- if (boot_size != GRUB_DISK_SECTOR_SIZE)
- grub_util_error (_("diskboot.img size must be %u bytes"),
- GRUB_DISK_SECTOR_SIZE);
+ num = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
+ if (num > 0xffff)
+ grub_util_error (_("the core image is too big"));
- boot_img = grub_util_read_image (boot_path);
+ boot_path = grub_util_get_path (dir, "diskboot.img");
+ boot_size = grub_util_get_image_size (boot_path);
+ if (boot_size != GRUB_DISK_SECTOR_SIZE)
+ grub_util_error (_("diskboot.img size must be %u bytes"),
+ GRUB_DISK_SECTOR_SIZE);
- {
- struct grub_boot_blocklist *block;
- block = (struct grub_boot_blocklist *) (boot_img
- + GRUB_DISK_SECTOR_SIZE
- - sizeof (*block));
- block->len = grub_host_to_target16 (num);
-
- /* This is filled elsewhere. Verify it just in case. */
- assert (block->segment
- == grub_host_to_target16 (GRUB_BOOT_MACHINE_KERNEL_SEG
- + (GRUB_DISK_SECTOR_SIZE >> 4)));
- }
+ boot_img = grub_util_read_image (boot_path);
- grub_util_write_image (boot_img, boot_size, out);
- free (boot_img);
- free (boot_path);
- }
-#elif defined(GRUB_MACHINE_EFI)
- {
- void *pe_img;
- size_t pe_size;
- struct grub_pe32_header *header;
- struct grub_pe32_coff_header *c;
- struct grub_pe32_optional_header *o;
- struct grub_pe32_section_table *text_section, *data_section;
- struct grub_pe32_section_table *mods_section, *reloc_section;
- static const grub_uint8_t stub[] = GRUB_PE32_MSDOS_STUB;
- int header_size = ALIGN_UP (sizeof (struct grub_pe32_header)
- + 5 * sizeof (struct grub_pe32_section_table),
- SECTION_ALIGN);
- int reloc_addr = ALIGN_UP (header_size + core_size, SECTION_ALIGN);
-
- pe_size = ALIGN_UP (reloc_addr + reloc_size, SECTION_ALIGN);
- pe_img = xmalloc (reloc_addr + reloc_size);
- memset (pe_img, 0, header_size);
- memcpy (pe_img + header_size, core_img, core_size);
- memcpy (pe_img + reloc_addr, rel_section, reloc_size);
- header = pe_img;
-
- /* The magic. */
- memcpy (header->msdos_stub, stub, sizeof (header->msdos_stub));
- memcpy (header->signature, "PE\0\0", sizeof (header->signature));
-
- /* The COFF file header. */
- c = &header->coff_header;
-#if GRUB_TARGET_SIZEOF_VOID_P == 4
- c->machine = grub_host_to_target16 (GRUB_PE32_MACHINE_I386);
-#else
- c->machine = grub_host_to_target16 (GRUB_PE32_MACHINE_X86_64);
-#endif
+ {
+ struct grub_pc_bios_boot_blocklist *block;
+ block = (struct grub_pc_bios_boot_blocklist *) (boot_img
+ + GRUB_DISK_SECTOR_SIZE
+ - sizeof (*block));
+ block->len = grub_host_to_target16 (num);
+
+ /* This is filled elsewhere. Verify it just in case. */
+ assert (block->segment
+ == grub_host_to_target16 (GRUB_BOOT_I386_PC_KERNEL_SEG
+ + (GRUB_DISK_SECTOR_SIZE >> 4)));
+ }
- c->num_sections = grub_host_to_target16 (4);
- c->time = grub_host_to_target32 (time (0));
- c->optional_header_size = grub_host_to_target16 (sizeof (header->optional_header));
- c->characteristics = grub_host_to_target16 (GRUB_PE32_EXECUTABLE_IMAGE
- | GRUB_PE32_LINE_NUMS_STRIPPED
-#if GRUB_TARGET_SIZEOF_VOID_P == 4
- | GRUB_PE32_32BIT_MACHINE
-#endif
- | GRUB_PE32_LOCAL_SYMS_STRIPPED
- | GRUB_PE32_DEBUG_STRIPPED);
-
- /* The PE Optional header. */
- o = &header->optional_header;
- o->magic = grub_host_to_target16 (GRUB_PE32_PE32_MAGIC);
- o->code_size = grub_host_to_target32 (exec_size);
- o->data_size = grub_cpu_to_le32 (reloc_addr - exec_size);
- o->bss_size = grub_cpu_to_le32 (bss_size);
- o->entry_addr = grub_cpu_to_le32 (start_address);
- o->code_base = grub_cpu_to_le32 (header_size);
-#if GRUB_TARGET_SIZEOF_VOID_P == 4
- o->data_base = grub_host_to_target32 (header_size + exec_size);
-#endif
- o->image_base = 0;
- o->section_alignment = grub_host_to_target32 (SECTION_ALIGN);
- o->file_alignment = grub_host_to_target32 (SECTION_ALIGN);
- o->image_size = grub_host_to_target32 (pe_size);
- o->header_size = grub_host_to_target32 (header_size);
- o->subsystem = grub_host_to_target16 (GRUB_PE32_SUBSYSTEM_EFI_APPLICATION);
-
- /* Do these really matter? */
- o->stack_reserve_size = grub_host_to_target32 (0x10000);
- o->stack_commit_size = grub_host_to_target32 (0x10000);
- o->heap_reserve_size = grub_host_to_target32 (0x10000);
- o->heap_commit_size = grub_host_to_target32 (0x10000);
+ grub_util_write_image (boot_img, boot_size, out);
+ free (boot_img);
+ free (boot_path);
+ }
+ break;
+ case IMAGE_EFI:
+ {
+ void *pe_img;
+ size_t pe_size;
+ struct grub_pe32_header *header;
+ struct grub_pe32_coff_header *c;
+ struct grub_pe32_optional_header *o;
+ struct grub_pe32_section_table *text_section, *data_section;
+ struct grub_pe32_section_table *mods_section, *reloc_section;
+ static const grub_uint8_t stub[] = GRUB_PE32_MSDOS_STUB;
+ int header_size = ALIGN_UP (sizeof (struct grub_pe32_header)
+ + 5 * sizeof (struct grub_pe32_section_table),
+ image_target->section_align);
+ int reloc_addr = ALIGN_UP (header_size + core_size, image_target->section_align);
+
+ pe_size = ALIGN_UP (reloc_addr + reloc_size, image_target->section_align);
+ pe_img = xmalloc (reloc_addr + reloc_size);
+ memset (pe_img, 0, header_size);
+ memcpy (pe_img + header_size, core_img, core_size);
+ memcpy (pe_img + reloc_addr, rel_section, reloc_size);
+ header = pe_img;
+
+ /* The magic. */
+ memcpy (header->msdos_stub, stub, sizeof (header->msdos_stub));
+ memcpy (header->signature, "PE\0\0", sizeof (header->signature));
+
+ /* The COFF file header. */
+ c = &header->coff_header;
+ if (image_target->voidp_sizeof == 4)
+ c->machine = grub_host_to_target16 (GRUB_PE32_MACHINE_I386);
+ else
+ c->machine = grub_host_to_target16 (GRUB_PE32_MACHINE_X86_64);
+
+ c->num_sections = grub_host_to_target16 (4);
+ c->time = grub_host_to_target32 (time (0));
+ c->optional_header_size = grub_host_to_target16 (sizeof (header->optional_header));
+ c->characteristics = grub_host_to_target16 (GRUB_PE32_EXECUTABLE_IMAGE
+ | GRUB_PE32_LINE_NUMS_STRIPPED
+ | ((image_target->voidp_sizeof == 4)
+ ? GRUB_PE32_32BIT_MACHINE
+ : 0)
+ | GRUB_PE32_LOCAL_SYMS_STRIPPED
+ | GRUB_PE32_DEBUG_STRIPPED);
+
+ /* The PE Optional header. */
+ o = &header->optional_header;
+ o->magic = grub_host_to_target16 (GRUB_PE32_PE32_MAGIC);
+ o->code_size = grub_host_to_target32 (exec_size);
+ o->data_size = grub_cpu_to_le32 (reloc_addr - exec_size);
+ o->bss_size = grub_cpu_to_le32 (bss_size);
+ o->entry_addr = grub_cpu_to_le32 (start_address);
+ o->code_base = grub_cpu_to_le32 (header_size);
+ if (image_target->voidp_sizeof == 4)
+ o->data_base = grub_host_to_target32 (header_size + exec_size);
+ o->image_base = 0;
+ o->section_alignment = grub_host_to_target32 (image_target->section_align);
+ o->file_alignment = grub_host_to_target32 (image_target->section_align);
+ o->image_size = grub_host_to_target32 (pe_size);
+ o->header_size = grub_host_to_target32 (header_size);
+ o->subsystem = grub_host_to_target16 (GRUB_PE32_SUBSYSTEM_EFI_APPLICATION);
+
+ /* Do these really matter? */
+ o->stack_reserve_size = grub_host_to_target32 (0x10000);
+ o->stack_commit_size = grub_host_to_target32 (0x10000);
+ o->heap_reserve_size = grub_host_to_target32 (0x10000);
+ o->heap_commit_size = grub_host_to_target32 (0x10000);
- o->num_data_directories = grub_host_to_target32 (GRUB_PE32_NUM_DATA_DIRECTORIES);
-
- o->base_relocation_table.rva = grub_host_to_target32 (reloc_addr);
- o->base_relocation_table.size = grub_host_to_target32 (reloc_size);
-
- /* The sections. */
- text_section = (struct grub_pe32_section_table *) (header + 1);
- strcpy (text_section->name, ".text");
- text_section->virtual_size = grub_cpu_to_le32 (exec_size);
- text_section->virtual_address = grub_cpu_to_le32 (header_size);
- text_section->raw_data_size = grub_cpu_to_le32 (exec_size);
- text_section->raw_data_offset = grub_cpu_to_le32 (header_size);
- text_section->characteristics = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_CODE
- | GRUB_PE32_SCN_MEM_EXECUTE
- | GRUB_PE32_SCN_MEM_READ
- | GRUB_PE32_SCN_ALIGN_64BYTES);
-
- data_section = text_section + 1;
- strcpy (data_section->name, ".data");
- data_section->virtual_size = grub_cpu_to_le32 (kernel_size - exec_size);
- data_section->virtual_address = grub_cpu_to_le32 (header_size + exec_size);
- data_section->raw_data_size = grub_cpu_to_le32 (kernel_size - exec_size);
- data_section->raw_data_offset = grub_cpu_to_le32 (header_size + exec_size);
- data_section->characteristics
- = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
- | GRUB_PE32_SCN_MEM_READ
- | GRUB_PE32_SCN_MEM_WRITE
- | GRUB_PE32_SCN_ALIGN_64BYTES);
+ o->num_data_directories = grub_host_to_target32 (GRUB_PE32_NUM_DATA_DIRECTORIES);
+
+ o->base_relocation_table.rva = grub_host_to_target32 (reloc_addr);
+ o->base_relocation_table.size = grub_host_to_target32 (reloc_size);
+
+ /* The sections. */
+ text_section = (struct grub_pe32_section_table *) (header + 1);
+ strcpy (text_section->name, ".text");
+ text_section->virtual_size = grub_cpu_to_le32 (exec_size);
+ text_section->virtual_address = grub_cpu_to_le32 (header_size);
+ text_section->raw_data_size = grub_cpu_to_le32 (exec_size);
+ text_section->raw_data_offset = grub_cpu_to_le32 (header_size);
+ text_section->characteristics = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_CODE
+ | GRUB_PE32_SCN_MEM_EXECUTE
+ | GRUB_PE32_SCN_MEM_READ
+ | GRUB_PE32_SCN_ALIGN_64BYTES);
+
+ data_section = text_section + 1;
+ strcpy (data_section->name, ".data");
+ data_section->virtual_size = grub_cpu_to_le32 (kernel_size - exec_size);
+ data_section->virtual_address = grub_cpu_to_le32 (header_size + exec_size);
+ data_section->raw_data_size = grub_cpu_to_le32 (kernel_size - exec_size);
+ data_section->raw_data_offset = grub_cpu_to_le32 (header_size + exec_size);
+ data_section->characteristics
+ = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
+ | GRUB_PE32_SCN_MEM_READ
+ | GRUB_PE32_SCN_MEM_WRITE
+ | GRUB_PE32_SCN_ALIGN_64BYTES);
#if 0
- bss_section = data_section + 1;
- strcpy (bss_section->name, ".bss");
- bss_section->virtual_size = grub_cpu_to_le32 (bss_size);
- bss_section->virtual_address = grub_cpu_to_le32 (header_size + kernel_size);
- bss_section->raw_data_size = 0;
- bss_section->raw_data_offset = 0;
- bss_section->characteristics
- = grub_cpu_to_le32 (GRUB_PE32_SCN_MEM_READ
- | GRUB_PE32_SCN_MEM_WRITE
- | GRUB_PE32_SCN_ALIGN_64BYTES
- | GRUB_PE32_SCN_CNT_INITIALIZED_DATA
- | 0x80);
+ bss_section = data_section + 1;
+ strcpy (bss_section->name, ".bss");
+ bss_section->virtual_size = grub_cpu_to_le32 (bss_size);
+ bss_section->virtual_address = grub_cpu_to_le32 (header_size + kernel_size);
+ bss_section->raw_data_size = 0;
+ bss_section->raw_data_offset = 0;
+ bss_section->characteristics
+ = grub_cpu_to_le32 (GRUB_PE32_SCN_MEM_READ
+ | GRUB_PE32_SCN_MEM_WRITE
+ | GRUB_PE32_SCN_ALIGN_64BYTES
+ | GRUB_PE32_SCN_CNT_INITIALIZED_DATA
+ | 0x80);
#endif
- mods_section = data_section + 1;
- strcpy (mods_section->name, "mods");
- mods_section->virtual_size = grub_cpu_to_le32 (reloc_addr - kernel_size - header_size);
- mods_section->virtual_address = grub_cpu_to_le32 (header_size + kernel_size + bss_size);
- mods_section->raw_data_size = grub_cpu_to_le32 (reloc_addr - kernel_size - header_size);
- mods_section->raw_data_offset = grub_cpu_to_le32 (header_size + kernel_size);
- mods_section->characteristics
- = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
- | GRUB_PE32_SCN_MEM_READ
- | GRUB_PE32_SCN_MEM_WRITE
- | GRUB_PE32_SCN_ALIGN_64BYTES);
-
- reloc_section = mods_section + 1;
- strcpy (reloc_section->name, ".reloc");
- reloc_section->virtual_size = grub_cpu_to_le32 (reloc_size);
- reloc_section->virtual_address = grub_cpu_to_le32 (reloc_addr + bss_size);
- reloc_section->raw_data_size = grub_cpu_to_le32 (reloc_size);
- reloc_section->raw_data_offset = grub_cpu_to_le32 (reloc_addr);
- reloc_section->characteristics
- = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
- | GRUB_PE32_SCN_MEM_DISCARDABLE
- | GRUB_PE32_SCN_MEM_READ);
- free (core_img);
- core_img = pe_img;
- core_size = pe_size;
- }
-#elif defined(GRUB_MACHINE_QEMU)
- {
- char *rom_img;
- size_t rom_size;
- char *boot_path, *boot_img;
- size_t boot_size;
+ mods_section = data_section + 1;
+ strcpy (mods_section->name, "mods");
+ mods_section->virtual_size = grub_cpu_to_le32 (reloc_addr - kernel_size - header_size);
+ mods_section->virtual_address = grub_cpu_to_le32 (header_size + kernel_size + bss_size);
+ mods_section->raw_data_size = grub_cpu_to_le32 (reloc_addr - kernel_size - header_size);
+ mods_section->raw_data_offset = grub_cpu_to_le32 (header_size + kernel_size);
+ mods_section->characteristics
+ = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
+ | GRUB_PE32_SCN_MEM_READ
+ | GRUB_PE32_SCN_MEM_WRITE
+ | GRUB_PE32_SCN_ALIGN_64BYTES);
+
+ reloc_section = mods_section + 1;
+ strcpy (reloc_section->name, ".reloc");
+ reloc_section->virtual_size = grub_cpu_to_le32 (reloc_size);
+ reloc_section->virtual_address = grub_cpu_to_le32 (reloc_addr + bss_size);
+ reloc_section->raw_data_size = grub_cpu_to_le32 (reloc_size);
+ reloc_section->raw_data_offset = grub_cpu_to_le32 (reloc_addr);
+ reloc_section->characteristics
+ = grub_cpu_to_le32 (GRUB_PE32_SCN_CNT_INITIALIZED_DATA
+ | GRUB_PE32_SCN_MEM_DISCARDABLE
+ | GRUB_PE32_SCN_MEM_READ);
+ free (core_img);
+ core_img = pe_img;
+ core_size = pe_size;
+ }
+ break;
+ case IMAGE_QEMU:
+ {
+ char *rom_img;
+ size_t rom_size;
+ char *boot_path, *boot_img;
+ size_t boot_size;
- boot_path = grub_util_get_path (dir, "boot.img");
- boot_size = grub_util_get_image_size (boot_path);
- boot_img = grub_util_read_image (boot_path);
+ boot_path = grub_util_get_path (dir, "boot.img");
+ boot_size = grub_util_get_image_size (boot_path);
+ boot_img = grub_util_read_image (boot_path);
- /* Rom sizes must be 64k-aligned. */
- rom_size = ALIGN_UP (core_size + boot_size, 64 * 1024);
+ /* Rom sizes must be 64k-aligned. */
+ rom_size = ALIGN_UP (core_size + boot_size, 64 * 1024);
- rom_img = xmalloc (rom_size);
- memset (rom_img, 0, rom_size);
+ rom_img = xmalloc (rom_size);
+ memset (rom_img, 0, rom_size);
- *((grub_int32_t *) (core_img + GRUB_KERNEL_MACHINE_CORE_ENTRY_ADDR))
- = grub_host_to_target32 ((grub_uint32_t) -rom_size);
+ *((grub_int32_t *) (core_img + GRUB_KERNEL_I386_QEMU_CORE_ENTRY_ADDR))
+ = grub_host_to_target32 ((grub_uint32_t) -rom_size);
- memcpy (rom_img, core_img, core_size);
+ memcpy (rom_img, core_img, core_size);
- *((grub_int32_t *) (boot_img + GRUB_BOOT_MACHINE_CORE_ENTRY_ADDR))
- = grub_host_to_target32 ((grub_uint32_t) -rom_size);
+ *((grub_int32_t *) (boot_img + GRUB_BOOT_I386_QEMU_CORE_ENTRY_ADDR))
+ = grub_host_to_target32 ((grub_uint32_t) -rom_size);
- memcpy (rom_img + rom_size - boot_size, boot_img, boot_size);
+ memcpy (rom_img + rom_size - boot_size, boot_img, boot_size);
- free (core_img);
- core_img = rom_img;
- core_size = rom_size;
+ free (core_img);
+ core_img = rom_img;
+ core_size = rom_size;
- free (boot_img);
- free (boot_path);
- }
-#elif defined (GRUB_MACHINE_SPARC64)
- if (format == GRUB_PLATFORM_IMAGE_AOUT)
- {
- void *aout_img;
- size_t aout_size;
- struct grub_aout32_header *aout_head;
-
- aout_size = core_size + sizeof (*aout_head);
- aout_img = xmalloc (aout_size);
- aout_head = aout_img;
- aout_head->a_midmag = grub_host_to_target32 ((AOUT_MID_SUN << 16)
- | AOUT32_OMAGIC);
- aout_head->a_text = grub_host_to_target32 (core_size);
- aout_head->a_entry
- = grub_host_to_target32 (GRUB_BOOT_MACHINE_IMAGE_ADDRESS);
- memcpy (aout_img + sizeof (*aout_head), core_img, core_size);
-
- free (core_img);
- core_img = aout_img;
- core_size = aout_size;
- }
- else
- {
- unsigned int num;
- char *boot_path, *boot_img;
- size_t boot_size;
+ free (boot_img);
+ free (boot_path);
+ }
+ break;
+ case IMAGE_SPARC64_AOUT:
+ {
+ void *aout_img;
+ size_t aout_size;
+ struct grub_aout32_header *aout_head;
+
+ aout_size = core_size + sizeof (*aout_head);
+ aout_img = xmalloc (aout_size);
+ aout_head = aout_img;
+ aout_head->a_midmag = grub_host_to_target32 ((AOUT_MID_SUN << 16)
+ | AOUT32_OMAGIC);
+ aout_head->a_text = grub_host_to_target32 (core_size);
+ aout_head->a_entry
+ = grub_host_to_target32 (GRUB_BOOT_SPARC64_IEEE1275_IMAGE_ADDRESS);
+ memcpy (aout_img + sizeof (*aout_head), core_img, core_size);
+
+ free (core_img);
+ core_img = aout_img;
+ core_size = aout_size;
+ }
+ break;
+ case IMAGE_SPARC64_RAW:
+ {
+ unsigned int num;
+ char *boot_path, *boot_img;
+ size_t boot_size;
- num = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
- num <<= GRUB_DISK_SECTOR_BITS;
+ num = ((core_size + GRUB_DISK_SECTOR_SIZE - 1) >> GRUB_DISK_SECTOR_BITS);
+ num <<= GRUB_DISK_SECTOR_BITS;
- boot_path = grub_util_get_path (dir, "diskboot.img");
- boot_size = grub_util_get_image_size (boot_path);
- if (boot_size != GRUB_DISK_SECTOR_SIZE)
- grub_util_error ("diskboot.img is not one sector size");
+ boot_path = grub_util_get_path (dir, "diskboot.img");
+ boot_size = grub_util_get_image_size (boot_path);
+ if (boot_size != GRUB_DISK_SECTOR_SIZE)
+ grub_util_error ("diskboot.img is not one sector size");
- boot_img = grub_util_read_image (boot_path);
+ boot_img = grub_util_read_image (boot_path);
- *((grub_uint32_t *) (boot_img + GRUB_DISK_SECTOR_SIZE
- - GRUB_BOOT_MACHINE_LIST_SIZE + 8))
- = grub_host_to_target32 (num);
+ *((grub_uint32_t *) (boot_img + GRUB_DISK_SECTOR_SIZE
+ - GRUB_BOOT_SPARC64_IEEE1275_LIST_SIZE + 8))
+ = grub_host_to_target32 (num);
- grub_util_write_image (boot_img, boot_size, out);
- free (boot_img);
- free (boot_path);
- }
-#elif defined(GRUB_MACHINE_MIPS) || defined (GRUB_MACHINE_IEEE1275)
- if (format == GRUB_PLATFORM_IMAGE_ELF)
- {
- char *elf_img;
- size_t program_size;
- Elf32_Ehdr *ehdr;
- Elf32_Phdr *phdr;
- grub_uint32_t target_addr;
- int header_size, footer_size = 0;
- int phnum = 1;
-
- if (note)
- {
- phnum++;
- footer_size += sizeof (struct grub_ieee1275_note);
- }
- header_size = ALIGN_ADDR (sizeof (*ehdr) + phnum * sizeof (*phdr));
-
- program_size = ALIGN_ADDR (core_size);
-
- elf_img = xmalloc (program_size + header_size + footer_size);
- memset (elf_img, 0, program_size + header_size);
- memcpy (elf_img + header_size, core_img, core_size);
- ehdr = (void *) elf_img;
- phdr = (void *) (elf_img + sizeof (*ehdr));
- memcpy (ehdr->e_ident, ELFMAG, SELFMAG);
- ehdr->e_ident[EI_CLASS] = ELFCLASS32;
-#ifdef GRUB_CPU_MIPSEL
- ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
-#else
- ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
-#endif
- ehdr->e_ident[EI_VERSION] = EV_CURRENT;
- ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
- ehdr->e_type = grub_host_to_target16 (ET_EXEC);
- ehdr->e_machine = grub_host_to_target16 (EM_TARGET);
- ehdr->e_version = grub_host_to_target32 (EV_CURRENT);
-
- ehdr->e_phoff = grub_host_to_target32 ((char *) phdr - (char *) ehdr);
- ehdr->e_phentsize = grub_host_to_target16 (sizeof (*phdr));
- ehdr->e_phnum = grub_host_to_target16 (phnum);
-
- /* No section headers. */
- ehdr->e_shoff = grub_host_to_target32 (0);
- ehdr->e_shentsize = grub_host_to_target16 (0);
- ehdr->e_shnum = grub_host_to_target16 (0);
- ehdr->e_shstrndx = grub_host_to_target16 (0);
-
- ehdr->e_ehsize = grub_host_to_target16 (sizeof (*ehdr));
-
- phdr->p_type = grub_host_to_target32 (PT_LOAD);
- phdr->p_offset = grub_host_to_target32 (header_size);
- phdr->p_flags = grub_host_to_target32 (PF_R | PF_W | PF_X);
-
-#if defined(GRUB_MACHINE_MIPS)
- target_addr = ALIGN_UP (GRUB_KERNEL_MACHINE_LINK_ADDR
- + kernel_size + total_module_size, 32);
-#else
- target_addr = GRUB_KERNEL_MACHINE_LINK_ADDR;
-#endif
- ehdr->e_entry = grub_host_to_target32 (target_addr);
- phdr->p_vaddr = grub_host_to_target32 (target_addr);
- phdr->p_paddr = grub_host_to_target32 (target_addr);
- phdr->p_align = grub_host_to_target32 (GRUB_KERNEL_MACHINE_LINK_ALIGN);
-#if defined(GRUB_MACHINE_MIPS)
- ehdr->e_flags = grub_host_to_target32 (0x1000 | EF_MIPS_NOREORDER
- | EF_MIPS_PIC | EF_MIPS_CPIC);
-#else
- ehdr->e_flags = 0;
-#endif
- phdr->p_filesz = grub_host_to_target32 (core_size);
- phdr->p_memsz = grub_host_to_target32 (core_size);
+ grub_util_write_image (boot_img, boot_size, out);
+ free (boot_img);
+ free (boot_path);
+ }
+ break;
+ case IMAGE_YEELOONG_ELF:
+ case IMAGE_PPC:
+ case IMAGE_COREBOOT:
+ case IMAGE_I386_IEEE1275:
+ {
+ char *elf_img;
+ size_t program_size;
+ Elf32_Ehdr *ehdr;
+ Elf32_Phdr *phdr;
+ grub_uint32_t target_addr;
+ int header_size, footer_size = 0;
+ int phnum = 1;
+
+ if (note)
+ {
+ phnum++;
+ footer_size += sizeof (struct grub_ieee1275_note);
+ }
+ header_size = ALIGN_ADDR (sizeof (*ehdr) + phnum * sizeof (*phdr));
+
+ program_size = ALIGN_ADDR (core_size);
+
+ elf_img = xmalloc (program_size + header_size + footer_size);
+ memset (elf_img, 0, program_size + header_size);
+ memcpy (elf_img + header_size, core_img, core_size);
+ ehdr = (void *) elf_img;
+ phdr = (void *) (elf_img + sizeof (*ehdr));
+ memcpy (ehdr->e_ident, ELFMAG, SELFMAG);
+ ehdr->e_ident[EI_CLASS] = ELFCLASS32;
+ if (!image_target->bigendian)
+ ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
+ else
+ ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
+ ehdr->e_ident[EI_VERSION] = EV_CURRENT;
+ ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;
+ ehdr->e_type = grub_host_to_target16 (ET_EXEC);
+ ehdr->e_machine = grub_host_to_target16 (image_target->elf_target);
+ ehdr->e_version = grub_host_to_target32 (EV_CURRENT);
+
+ ehdr->e_phoff = grub_host_to_target32 ((char *) phdr - (char *) ehdr);
+ ehdr->e_phentsize = grub_host_to_target16 (sizeof (*phdr));
+ ehdr->e_phnum = grub_host_to_target16 (phnum);
+
+ /* No section headers. */
+ ehdr->e_shoff = grub_host_to_target32 (0);
+ ehdr->e_shentsize = grub_host_to_target16 (0);
+ ehdr->e_shnum = grub_host_to_target16 (0);
+ ehdr->e_shstrndx = grub_host_to_target16 (0);
+
+ ehdr->e_ehsize = grub_host_to_target16 (sizeof (*ehdr));
+
+ phdr->p_type = grub_host_to_target32 (PT_LOAD);
+ phdr->p_offset = grub_host_to_target32 (header_size);
+ phdr->p_flags = grub_host_to_target32 (PF_R | PF_W | PF_X);
+
+ if (image_target->id == IMAGE_YEELOONG_ELF)
+ target_addr = ALIGN_UP (GRUB_KERNEL_MACHINE_LINK_ADDR
+ + kernel_size + total_module_size, 32);
+ else
+ target_addr = GRUB_KERNEL_MACHINE_LINK_ADDR;
+ ehdr->e_entry = grub_host_to_target32 (target_addr);
+ phdr->p_vaddr = grub_host_to_target32 (target_addr);
+ phdr->p_paddr = grub_host_to_target32 (target_addr);
+ phdr->p_align = grub_host_to_target32 (image_target->link_align);
+ if (image_target->id == IMAGE_YEELOONG_ELF)
+ ehdr->e_flags = grub_host_to_target32 (0x1000 | EF_MIPS_NOREORDER
+ | EF_MIPS_PIC | EF_MIPS_CPIC);
+ else
+ ehdr->e_flags = 0;
+ phdr->p_filesz = grub_host_to_target32 (core_size);
+ phdr->p_memsz = grub_host_to_target32 (core_size);
- if (note)
- {
- int note_size = sizeof (struct grub_ieee1275_note);
- struct grub_ieee1275_note *note = (struct grub_ieee1275_note *)
- (elf_img + program_size + header_size);
-
- grub_util_info ("adding CHRP NOTE segment");
-
- note->header.namesz = grub_host_to_target32 (sizeof (GRUB_IEEE1275_NOTE_NAME));
- note->header.descsz = grub_host_to_target32 (note_size);
- note->header.type = grub_host_to_target32 (GRUB_IEEE1275_NOTE_TYPE);
- strcpy (note->header.name, GRUB_IEEE1275_NOTE_NAME);
- note->descriptor.real_mode = grub_host_to_target32 (0xffffffff);
- note->descriptor.real_base = grub_host_to_target32 (0x00c00000);
- note->descriptor.real_size = grub_host_to_target32 (0xffffffff);
- note->descriptor.virt_base = grub_host_to_target32 (0xffffffff);
- note->descriptor.virt_size = grub_host_to_target32 (0xffffffff);
- note->descriptor.load_base = grub_host_to_target32 (0x00004000);
-
- phdr[1].p_type = grub_host_to_target32 (PT_NOTE);
- phdr[1].p_flags = grub_host_to_target32 (PF_R);
- phdr[1].p_align = grub_host_to_target32 (GRUB_TARGET_SIZEOF_LONG);
- phdr[1].p_vaddr = 0;
- phdr[1].p_paddr = 0;
- phdr[1].p_filesz = grub_host_to_target32 (note_size);
- phdr[1].p_memsz = 0;
- phdr[1].p_offset = grub_host_to_target32 (header_size + program_size);
- }
+ if (note)
+ {
+ int note_size = sizeof (struct grub_ieee1275_note);
+ struct grub_ieee1275_note *note = (struct grub_ieee1275_note *)
+ (elf_img + program_size + header_size);
+
+ grub_util_info ("adding CHRP NOTE segment");
+
+ note->header.namesz = grub_host_to_target32 (sizeof (GRUB_IEEE1275_NOTE_NAME));
+ note->header.descsz = grub_host_to_target32 (note_size);
+ note->header.type = grub_host_to_target32 (GRUB_IEEE1275_NOTE_TYPE);
+ strcpy (note->header.name, GRUB_IEEE1275_NOTE_NAME);
+ note->descriptor.real_mode = grub_host_to_target32 (0xffffffff);
+ note->descriptor.real_base = grub_host_to_target32 (0x00c00000);
+ note->descriptor.real_size = grub_host_to_target32 (0xffffffff);
+ note->descriptor.virt_base = grub_host_to_target32 (0xffffffff);
+ note->descriptor.virt_size = grub_host_to_target32 (0xffffffff);
+ note->descriptor.load_base = grub_host_to_target32 (0x00004000);
+
+ phdr[1].p_type = grub_host_to_target32 (PT_NOTE);
+ phdr[1].p_flags = grub_host_to_target32 (PF_R);
+ phdr[1].p_align = grub_host_to_target32 (GRUB_TARGET_SIZEOF_LONG);
+ phdr[1].p_vaddr = 0;
+ phdr[1].p_paddr = 0;
+ phdr[1].p_filesz = grub_host_to_target32 (note_size);
+ phdr[1].p_memsz = 0;
+ phdr[1].p_offset = grub_host_to_target32 (header_size + program_size);
+ }
- free (core_img);
- core_img = elf_img;
- core_size = program_size + header_size + footer_size;
- }
-#endif
+ free (core_img);
+ core_img = elf_img;
+ core_size = program_size + header_size + footer_size;
+ }
+ break;
+ }
grub_util_write_image (core_img, core_size, out);
free (kernel_img);
{"config", required_argument, 0, 'c'},
{"output", required_argument, 0, 'o'},
{"note", no_argument, 0, 'n'},
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
{"format", required_argument, 0, 'O'},
-#endif
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"verbose", no_argument, 0, 'v'},
if (status)
fprintf (stderr, _("Try `%s --help' for more information.\n"), program_name);
else
- printf (_("\
+ {
+ int format_len = 0;
+ char *formats;
+ char *ptr;
+ unsigned i;
+ for (i = 0; i < ARRAY_SIZE (image_targets); i++)
+ format_len += strlen (image_targets[i].name) + 2;
+ ptr = formats = xmalloc (format_len);
+ for (i = 0; i < ARRAY_SIZE (image_targets); i++)
+ {
+ strcpy (ptr, image_targets[i].name);
+ ptr += strlen (image_targets[i].name);
+ *ptr++ = ',';
+ *ptr++ = ' ';
+ }
+ ptr[-2] = 0;
+
+ printf (_("\
Usage: %s [OPTION]... [MODULES]\n\
\n\
Make a bootable image of GRUB.\n\
-f, --font=FILE embed FILE as a boot font\n\
-c, --config=FILE embed FILE as boot config\n\
-n, --note add NOTE segment for CHRP Open Firmware\n\
- -o, --output=FILE output a generated image to FILE [default=stdout]\n"
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
- "\
- -O, --format=FORMAT generate an image in format [default=%s]\n\
- available formats: %s\n"
-#endif
- "\
+ -o, --output=FILE output a generated image to FILE [default=stdout]\n\
+ -O, --format=FORMAT generate an image in format\n\
+ available formats: %s\n\
-h, --help display this message and exit\n\
-V, --version print version information and exit\n\
-v, --verbose print verbose messages\n\
\n\
Report bugs to <%s>.\n\
"),
-program_name, GRUB_LIBDIR, DEFAULT_DIRECTORY,
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
- GRUB_PLATFORM_IMAGE_DEFAULT_FORMAT, GRUB_PLATFORM_IMAGE_FORMATS,
-#endif
-PACKAGE_BUGREPORT);
-
+ program_name, GRUB_LIBDIR, DEFAULT_DIRECTORY,
+ formats,
+ PACKAGE_BUGREPORT);
+ free (formats);
+ }
exit (status);
}
char *config = NULL;
FILE *fp = stdout;
int note = 0;
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
- grub_platform_image_format_t format = GRUB_PLATFORM_IMAGE_DEFAULT;
-#endif
+ struct image_target_desc *image_target = NULL;
set_program_name (argv[0]);
output = xstrdup (optarg);
break;
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
case 'O':
-#ifdef GRUB_PLATFORM_IMAGE_RAW
- if (strcmp (optarg, "raw") == 0)
- format = GRUB_PLATFORM_IMAGE_RAW;
- else
-#endif
-#ifdef GRUB_PLATFORM_IMAGE_ELF
- if (strcmp (optarg, "elf") == 0)
- format = GRUB_PLATFORM_IMAGE_ELF;
- else
-#endif
-#ifdef GRUB_PLATFORM_IMAGE_AOUT
- if (strcmp (optarg, "aout") == 0)
- format = GRUB_PLATFORM_IMAGE_AOUT;
- else
-#endif
- usage (1);
- break;
-#endif
-
+ {
+ unsigned i;
+ for (i = 0; i < ARRAY_SIZE (image_targets); i++)
+ if (strcmp (optarg, image_targets[i].name) == 0)
+ image_target = &image_targets[i];
+ if (!image_target)
+ {
+ printf ("unknown target %s\n", optarg);
+ usage (1);
+ }
+ break;
+ }
case 'd':
if (dir)
free (dir);
}
}
+ if (!image_target)
+ {
+ printf ("Target not specified.\n");
+ usage (1);
+ }
+
if (output)
{
fp = fopen (output, "wb");
generate_image (dir ? : GRUB_LIBDIR, prefix ? : DEFAULT_DIRECTORY, fp,
argv + optind, memdisk, font, config,
-#ifdef GRUB_PLATFORM_IMAGE_DEFAULT
- format,
-#else
- 0,
-#endif
- note);
+ image_target, note);
fclose (fp);
projects / grub2.git / commitdiff