int update_loaded_segments(struct mem_ehdr *ehdr)
{
int i;
unsigned u;
struct mem_phdr *phdr;
unsigned long start_addr = ULONG_MAX, end_addr = 0;
unsigned long align = 1UL<<26; /* 64M */
unsigned long start, end;
for (u = 0; u < ehdr->e_phnum; u++) {
phdr = &ehdr->e_phdr[u];
if (phdr->p_type != PT_LOAD)
continue;
if (phdr->p_paddr < start_addr)
start_addr = phdr->p_paddr;
if ((phdr->p_paddr + phdr->p_memsz) > end_addr)
end_addr = phdr->p_paddr + phdr->p_memsz;
}
for (i = 0; i < memory_ranges && memory_range[i].start <= start_addr;
i++) {
if (memory_range[i].type == RANGE_RAM &&
memory_range[i].end > end_addr)
return 0;
}
for (i = 0; i < memory_ranges; i++) {
if (memory_range[i].type != RANGE_RAM)
continue;
start = (memory_range[i].start + align - 1) & ~(align - 1);
end = memory_range[i].end;
if (end > start && (end - start) > (end_addr - start_addr)) {
move_loaded_segments(ehdr, start);
return 0;
}
}
return -1;
}
int elf_ia64_load(int argc, char **argv, const char *buf, off_t len,
struct kexec_info *info)
{
struct mem_ehdr ehdr;
const char *command_line, *ramdisk=0, *vmm=0, *kernel_buf;
char *ramdisk_buf = NULL;
off_t ramdisk_size = 0, kernel_size;
unsigned long command_line_len;
unsigned long entry, max_addr, gp_value;
unsigned long command_line_base, ramdisk_base, image_base;
unsigned long efi_memmap_base, efi_memmap_size;
unsigned long boot_param_base;
unsigned long noio=0;
int result;
int opt;
char *efi_memmap_buf, *boot_param;
static const struct option options[] = {
KEXEC_ARCH_OPTIONS
{"command-line", 1, 0, OPT_APPEND},
{"append", 1, 0, OPT_APPEND},
{"initrd", 1, 0, OPT_RAMDISK},
{"noio", 0, 0, OPT_NOIO},
{"vmm", 1, 0, OPT_VMM},
{0, 0, 0, 0},
};
static const char short_options[] = KEXEC_ARCH_OPT_STR "";
command_line = 0;
while ((opt = getopt_long(argc, argv, short_options,
options, 0)) != -1) {
switch (opt) {
default:
/* Ignore core options */
if (opt < OPT_ARCH_MAX) {
break;
}
case '?':
usage();
return -1;
case OPT_APPEND:
command_line = optarg;
break;
case OPT_RAMDISK:
ramdisk = optarg;
break;
case OPT_NOIO: /* disable PIO and MMIO in purgatory code*/
noio = 1;
break;
case OPT_VMM:
vmm = optarg;
break;
}
}
command_line_len = 0;
if (command_line) {
command_line_len = strlen(command_line) + 16;
}
if (vmm)
kernel_buf = slurp_decompress_file(vmm, &kernel_size);
else {
kernel_buf = buf;
kernel_size = len;
}
/* Parse the Elf file */
result = build_elf_exec_info(kernel_buf, kernel_size, &ehdr, 0);
if (result < 0) {
fprintf(stderr, "ELF parse failed\n");
free_elf_info(&ehdr);
return result;
}
if (info->kexec_flags & KEXEC_ON_CRASH ) {
if ((mem_min == 0x00) && (mem_max == ULONG_MAX)) {
fprintf(stderr, "Failed to find crash kernel region "
"in %s\n", proc_iomem());
free_elf_info(&ehdr);
return -1;
}
move_loaded_segments(info, &ehdr, mem_min);
} else if (update_loaded_segments(info, &ehdr) < 0) {
fprintf(stderr, "Failed to place kernel\n");
return -1;
}
entry = ehdr.e_entry;
max_addr = elf_max_addr(&ehdr);
/* Load the Elf data */
result = elf_exec_load(&ehdr, info);
if (result < 0) {
fprintf(stderr, "ELF load failed\n");
free_elf_info(&ehdr);
return result;
}
/* Load the setup code */
elf_rel_build_load(info, &info->rhdr, purgatory, purgatory_size,
0x0, ULONG_MAX, -1, 0);
if (load_crashdump_segments(info, &ehdr, max_addr, 0,
&command_line) < 0)
return -1;
// reverve 4k for ia64_boot_param
boot_param = xmalloc(4096);
boot_param_base = add_buffer(info, boot_param, 4096, 4096, 4096, 0,
max_addr, -1);
elf_rel_set_symbol(&info->rhdr, "__noio",
&noio, sizeof(long));
elf_rel_set_symbol(&info->rhdr, "__boot_param_base",
&boot_param_base, sizeof(long));
// reserve efi_memmap of actual size allocated in production kernel
efi_memmap_size = saved_efi_memmap_size;
efi_memmap_buf = xmalloc(efi_memmap_size);
efi_memmap_base = add_buffer(info, efi_memmap_buf,
efi_memmap_size, efi_memmap_size, 4096, 0,
max_addr, -1);
elf_rel_set_symbol(&info->rhdr, "__efi_memmap_base",
&efi_memmap_base, sizeof(long));
elf_rel_set_symbol(&info->rhdr, "__efi_memmap_size",
&efi_memmap_size, sizeof(long));
if (command_line) {
command_line_len = strlen(command_line) + 1;
}
if (command_line_len || (info->kexec_flags & KEXEC_ON_CRASH )) {
char *cmdline = xmalloc(command_line_len);
strcpy(cmdline, command_line);
if (info->kexec_flags & KEXEC_ON_CRASH) {
char buf[128];
sprintf(buf," max_addr=%lluM min_addr=%lluM",
mem_max>>20, mem_min>>20);
command_line_len = strlen(cmdline) + strlen(buf) + 1;
cmdline = xrealloc(cmdline, command_line_len);
strcat(cmdline, buf);
}
