Adding upstream version 1:2.0.27.upstream/1%2.0.27upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 1110 insertions, 0 deletions

diff --git a/kexec/arch/ia64/Makefile b/kexec/arch/ia64/Makefile
new file mode 100644
index 0000000..f5b212b
--- /dev/null
+++ b/kexec/arch/ia64/Makefile
@@ -0,0 +1,16 @@
+#
+# kexec ia64 (linux booting linux)
+#
+ia64_KEXEC_SRCS =  kexec/arch/ia64/kexec-iomem.c
+ia64_KEXEC_SRCS += kexec/arch/ia64/kexec-ia64.c
+ia64_KEXEC_SRCS += kexec/arch/ia64/kexec-elf-ia64.c
+ia64_KEXEC_SRCS += kexec/arch/ia64/kexec-elf-rel-ia64.c
+ia64_KEXEC_SRCS += kexec/arch/ia64/crashdump-ia64.c
+
+ia64_PROC_IOMEM =
+
+dist += kexec/arch/ia64/Makefile $(ia64_KEXEC_SRCS)			\
+	kexec/arch/ia64/kexec-ia64.h kexec/arch/ia64/crashdump-ia64.h	\
+	kexec/arch/ia64/include/arch/options.h
+
+
diff --git a/kexec/arch/ia64/crashdump-ia64.c b/kexec/arch/ia64/crashdump-ia64.c
new file mode 100644
index 0000000..755ee5e
--- /dev/null
+++ b/kexec/arch/ia64/crashdump-ia64.c
@@ -0,0 +1,293 @@
+/*
+ * kexec: crashdump support
+ * Copyright (C) 2005-2006 Zou Nan hai <nanhai.zou@intel.com> Intel Corp
+ *
+ * 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 (version 2 of the License).
+ *
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+#include <elf.h>
+#include "../../kexec.h"
+#include "../../kexec-elf.h"
+#include "../../kexec-syscall.h"
+#include "kexec-ia64.h"
+#include "crashdump-ia64.h"
+#include "../kexec/crashdump.h"
+
+int memory_ranges = 0;
+#define LOAD_OFFSET 	(0xa000000000000000UL + 0x100000000UL -		\
+			 kernel_code_start)
+
+static struct crash_elf_info elf_info =
+{
+	class: ELFCLASS64,
+	data: ELFDATA2LSB,
+	machine: EM_IA_64,
+	page_offset: PAGE_OFFSET,
+};
+
+/* Stores a sorted list of RAM memory ranges for which to create elf headers.
+ * A separate program header is created for backup region.
+ * The number of entries in memory_range array is always smaller than
+ * the number of entries in the file returned by proc_iomem(),
+ * stored in max_memory_ranges. */
+static struct memory_range *crash_memory_range;
+/* Memory region reserved for storing panic kernel and other data. */
+static struct memory_range crash_reserved_mem;
+unsigned long elfcorehdr;
+static unsigned long kernel_code_start;
+static unsigned long kernel_code_end;
+struct loaded_segment {
+        unsigned long start;
+        unsigned long end;
+};
+
+#define MAX_LOAD_SEGMENTS	128
+struct loaded_segment loaded_segments[MAX_LOAD_SEGMENTS];
+
+unsigned long loaded_segments_num, loaded_segments_base;
+static int seg_comp(const void *a, const void *b)
+{
+        const struct loaded_segment *x = a, *y = b;
+        /* avoid overflow */
+        if (x->start > y->start) return 1;
+	if (x->start < y->start) return -1;
+	return 0;
+}
+
+/* purgatory code need this info to patch the EFI memmap
+ */
+static void add_loaded_segments_info(struct mem_ehdr *ehdr)
+{
+	unsigned i = 0;
+	while(i < ehdr->e_phnum) {
+                struct mem_phdr *phdr;
+                phdr = &ehdr->e_phdr[i];
+		if (phdr->p_type != PT_LOAD) {
+			i++;
+                        continue;
+		}
+
+		loaded_segments[loaded_segments_num].start =
+			_ALIGN_DOWN(phdr->p_paddr, ELF_PAGE_SIZE);
+                loaded_segments[loaded_segments_num].end =
+			loaded_segments[loaded_segments_num].start;
+
+		/* Consolidate consecutive PL_LOAD segments into one.
+		 * The end addr of the last PL_LOAD segment, calculated by
+		 * adding p_memsz to p_paddr & rounded up to ELF_PAGE_SIZE,
+		 * will be the end address of this loaded_segments entry.
+		 */
+		while (i < ehdr->e_phnum) {
+			phdr = &ehdr->e_phdr[i];
+	                if (phdr->p_type != PT_LOAD)
+	                        break;
+			loaded_segments[loaded_segments_num].end =
+				_ALIGN(phdr->p_paddr + phdr->p_memsz,
+				       ELF_PAGE_SIZE);
+			i++;
+		}
+		loaded_segments_num++;
+	}
+}
+
+/* Removes crash reserve region from list of memory chunks for whom elf program
+ * headers have to be created. Assuming crash reserve region to be a single
+ * continuous area fully contained inside one of the memory chunks */
+static int exclude_crash_reserve_region(int *nr_ranges)
+{
+	int i, j, tidx = -1;
+	unsigned long cstart, cend;
+	struct memory_range temp_region;
+
+	/* Crash reserved region. */
+	cstart = crash_reserved_mem.start;
+	cend = crash_reserved_mem.end;
+
+	for (i = 0; i < (*nr_ranges); i++) {
+		unsigned long mstart, mend;
+		mstart = crash_memory_range[i].start;
+		mend = crash_memory_range[i].end;
+		if (cstart < mend && cend > mstart) {
+			if (cstart != mstart && cend != mend) {
+				/* Split memory region */
+				crash_memory_range[i].end = cstart - 1;
+				temp_region.start = cend + 1;
+				temp_region.end = mend;
+				temp_region.type = RANGE_RAM;
+				tidx = i+1;
+			} else if (cstart != mstart)
+				crash_memory_range[i].end = cstart - 1;
+			else
+				crash_memory_range[i].start = cend + 1;
+		}
+	}
+	/* Insert split memory region, if any. */
+	if (tidx >= 0) {
+		if (*nr_ranges == max_memory_ranges) {
+			/* No space to insert another element. */
+			fprintf(stderr, "Error: Number of crash memory ranges"
+					" excedeed the max limit\n");
+			return -1;
+		}
+		for (j = (*nr_ranges - 1); j >= tidx; j--)
+			crash_memory_range[j+1] = crash_memory_range[j];
+		crash_memory_range[tidx].start = temp_region.start;
+		crash_memory_range[tidx].end = temp_region.end;
+		crash_memory_range[tidx].type = temp_region.type;
+		(*nr_ranges)++;
+	}
+	return 0;
+}
+
+static int get_crash_memory_ranges(int *ranges)
+{
+	const char *iomem = proc_iomem();
+        char line[MAX_LINE];
+        FILE *fp;
+        unsigned long start, end;
+
+	crash_memory_range = xmalloc(sizeof(struct memory_range) *
+				max_memory_ranges);
+        fp = fopen(iomem, "r");
+        if (!fp) {
+                fprintf(stderr, "Cannot open %s: %s\n",
+                        iomem, strerror(errno));
+                return -1;
+        }
+	while(fgets(line, sizeof(line), fp) != 0) {
+		char *str;
+		int type, consumed, count;
+		if (memory_ranges >= max_memory_ranges)
+			break;
+		count = sscanf(line, "%lx-%lx : %n",
+				&start, &end, &consumed);
+		str = line + consumed;
+		if (count != 2)
+			continue;
+
+		if (memcmp(str, "System RAM\n", 11) == 0) {
+			type = RANGE_RAM;
+		} else if (memcmp(str, "Crash kernel\n", 13) == 0) {
+			/* Reserved memory region. New kernel can
+			 * use this region to boot into. */
+			crash_reserved_mem.start = start;
+			crash_reserved_mem.end = end;
+			crash_reserved_mem.type = RANGE_RAM;
+			continue;
+		}
+		else if (memcmp(str, "Kernel code\n", 12) == 0) {
+			kernel_code_start = start;
+			kernel_code_end = end;
+			continue;
+		} else if (memcmp(str, "Uncached RAM\n", 13) == 0) {
+			type = RANGE_UNCACHED;
+		} else {
+			continue;
+		}
+		crash_memory_range[memory_ranges].start = start;
+		crash_memory_range[memory_ranges].end = end;
+		crash_memory_range[memory_ranges].type = type;
+		memory_ranges++;
+	}
+        fclose(fp);
+	if (exclude_crash_reserve_region(&memory_ranges) < 0)
+		return -1;
+	*ranges = memory_ranges;
+	return 0;
+}
+
+/*
+ * Note that this assignes a malloced pointer to *cmdline,
+ * which is likely never freed by the caller
+ */
+static void
+cmdline_add_elfcorehdr(const char **cmdline, unsigned long addr)
+{
+	char *str;
+	char buf[64];
+	size_t len;
+	sprintf(buf, " elfcorehdr=%ldK", addr/1024);
+	len = strlen(*cmdline) + strlen(buf) + 1;
+	str = xmalloc(len);
+	sprintf(str, "%s%s", *cmdline, buf);
+	*cmdline = str;
+}
+
+int load_crashdump_segments(struct kexec_info *info, struct mem_ehdr *ehdr,
+                            unsigned long max_addr, unsigned long min_base,
+			    const char **cmdline)
+{
+	int nr_ranges;
+	unsigned long sz;
+	size_t size;
+	void *tmp;
+	if (info->kexec_flags & KEXEC_ON_CRASH &&
+	    get_crash_memory_ranges(&nr_ranges) == 0) {
+		int i;
+
+		elf_info.kern_paddr_start = kernel_code_start;
+		for (i=0; i < nr_ranges; i++) {
+			unsigned long long mstart = crash_memory_range[i].start;
+			unsigned long long mend = crash_memory_range[i].end;
+			if (!mstart && !mend)
+				continue;
+			if (kernel_code_start >= mstart &&
+			    kernel_code_start < mend) {
+				elf_info.kern_vaddr_start = mstart + LOAD_OFFSET;
+				break;
+			}
+		}
+		elf_info.kern_size = kernel_code_end - kernel_code_start + 1;
+		if (crash_create_elf64_headers(info, &elf_info,
+					       crash_memory_range, nr_ranges,
+					       &tmp, &sz, EFI_PAGE_SIZE) < 0)
+			return -1;
+
+		elfcorehdr = add_buffer(info, tmp, sz, sz, EFI_PAGE_SIZE,
+					min_base, max_addr, -1);
+		loaded_segments[loaded_segments_num].start = elfcorehdr;
+		loaded_segments[loaded_segments_num].end = elfcorehdr + sz;
+		loaded_segments_num++;
+		cmdline_add_elfcorehdr(cmdline, elfcorehdr);
+	}
+	add_loaded_segments_info(ehdr);
+	size = sizeof(struct loaded_segment) * loaded_segments_num;
+	qsort(loaded_segments, loaded_segments_num,
+                        sizeof(struct loaded_segment), seg_comp);
+        loaded_segments_base = add_buffer(info, loaded_segments,
+                        size, size, 16, 0, max_addr, -1);
+
+        elf_rel_set_symbol(&info->rhdr, "__loaded_segments",
+                        &loaded_segments_base, sizeof(long));
+        elf_rel_set_symbol(&info->rhdr, "__loaded_segments_num",
+                         &loaded_segments_num, sizeof(long));
+	return 0;
+}
+
+int is_crashkernel_mem_reserved(void)
+{
+	uint64_t start, end;
+
+	return parse_iomem_single("Crash kernel\n", &start,
+				  &end) == 0 ?  (start != end) : 0;
+}
+
+int get_crash_kernel_load_range(uint64_t *start, uint64_t *end)
+{
+	return parse_iomem_single("Crash kernel\n", start, end);
+}
diff --git a/kexec/arch/ia64/crashdump-ia64.h b/kexec/arch/ia64/crashdump-ia64.h
new file mode 100644
index 0000000..72ba054
--- /dev/null
+++ b/kexec/arch/ia64/crashdump-ia64.h
@@ -0,0 +1,12 @@
+#ifndef CRASHDUMP_IA64_H
+#define CRASHDUMP_IA64_H
+
+#define PAGE_OFFSET             0xe000000000000000UL
+#define __pa(x)			((unsigned long)(x)-PAGE_OFFSET)
+extern int load_crashdump_segments(struct kexec_info *info,
+		struct mem_ehdr *ehdr, unsigned long max_addr,
+		unsigned long min_base, const char **cmdline);
+
+#define CRASH_MAX_MEMMAP_NR     (KEXEC_MAX_SEGMENTS + 1)
+
+#endif
diff --git a/kexec/arch/ia64/include/arch/options.h b/kexec/arch/ia64/include/arch/options.h
new file mode 100644
index 0000000..e8754ad
--- /dev/null
+++ b/kexec/arch/ia64/include/arch/options.h
@@ -0,0 +1,42 @@
+#ifndef KEXEC_ARCH_IA64_OPTIONS_H
+#define KEXEC_ARCH_IA64_OPTIONS_H
+
+#define OPT_ARCH_MAX	(OPT_MAX+0)
+#define OPT_APPEND	(OPT_ARCH_MAX+0)
+#define OPT_RAMDISK	(OPT_ARCH_MAX+1)
+#define OPT_NOIO	(OPT_ARCH_MAX+2)
+#define OPT_VMM		(OPT_ARCH_MAX+3)
+
+/* Options relevant to the architecture (excluding loader-specific ones),
+ * in this case none:
+ */
+#define KEXEC_ARCH_OPTIONS \
+	KEXEC_OPTIONS \
+
+#define KEXEC_ARCH_OPT_STR KEXEC_OPT_STR ""
+
+/* The following two #defines list ALL of the options added by all of the
+ * architecture's loaders.
+ * o	main() uses this complete list to scan for its options, ignoring
+ *	arch-specific/loader-specific ones.
+ * o	Then, arch_process_options() uses this complete list to scan for its
+ *	options, ignoring general/loader-specific ones.
+ * o	Then, the file_type[n].load re-scans for options, using
+ *	KEXEC_ARCH_OPTIONS plus its loader-specific options subset.
+ *	Any unrecognised options cause an error here.
+ *
+ * This is done so that main()'s/arch_process_options()'s getopt_long() calls
+ * don't choose a kernel filename from random arguments to options they don't
+ * recognise -- as they now recognise (if not act upon) all possible options.
+ */
+#define KEXEC_ALL_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},	\
+
+#define KEXEC_ALL_OPT_STR KEXEC_OPT_STR
+
+#endif /* KEXEC_ARCH_IA64_OPTIONS_H */
diff --git a/kexec/arch/ia64/kexec-elf-ia64.c b/kexec/arch/ia64/kexec-elf-ia64.c
new file mode 100644
index 0000000..142dee3
--- /dev/null
+++ b/kexec/arch/ia64/kexec-elf-ia64.c
@@ -0,0 +1,303 @@
+/*
+ * kexec: Linux boots Linux
+ *
+ * Copyright (C) 2003,2004  Eric Biederman (ebiederm@xmission.com)
+ * Copyright (C) 2004 Albert Herranz
+ * Copyright (C) 2004 Silicon Graphics, Inc.
+ *   Jesse Barnes <jbarnes@sgi.com>
+ * Copyright (C) 2004 Khalid Aziz <khalid.aziz@hp.com> Hewlett Packard Co
+ * Copyright (C) 2005 Zou Nan hai <nanhai.zou@intel.com> Intel Corp
+ *
+ * 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 (version 2 of the License).
+ *
+ * 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.
+ */
+
+#define _GNU_SOURCE
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <limits.h>
+#include <elf.h>
+#include <boot/elf_boot.h>
+#include <ip_checksum.h>
+#include "../../kexec.h"
+#include "../../kexec-syscall.h"
+#include "../../kexec-elf.h"
+#include "kexec-ia64.h"
+#include "crashdump-ia64.h"
+#include <arch/options.h>
+
+static const int probe_debug = 0;
+extern unsigned long saved_efi_memmap_size;
+
+/*
+ * elf_ia64_probe - sanity check the elf image
+ *
+ * Make sure that the file image has a reasonable chance of working.
+ */
+int elf_ia64_probe(const char *buf, off_t len)
+{
+	struct mem_ehdr ehdr;
+	int result;
+	result = build_elf_exec_info(buf, len, &ehdr, 0);
+	if (result < 0) {
+		if (probe_debug) {
+			fprintf(stderr, "Not an ELF executable\n");
+		}
+		return -1;
+	}
+	/* Verify the architecuture specific bits */
+	if (ehdr.e_machine != EM_IA_64) {
+		/* for a different architecture */
+		if (probe_debug) {
+			fprintf(stderr, "Not for this architecture.\n");
+		}
+		return -1;
+	}
+	return 0;
+}
+
+void elf_ia64_usage(void)
+{
+	printf("    --command-line=STRING Set the kernel command line to "
+			"STRING.\n"
+	       "    --append=STRING       Set the kernel command line to "
+			"STRING.\n"
+	       "    --initrd=FILE         Use FILE as the kernel's initial "
+			"ramdisk.\n"
+	       "    --noio                Disable I/O in purgatory code.\n"
+	       "    --vmm=FILE            Use FILE as the kernel image for a\n"
+	       "                          virtual machine monitor "
+			"(aka hypervisor)\n");
+}
+
+/* Move the crash kerenl physical offset to reserved region
+ */
+void move_loaded_segments(struct mem_ehdr *ehdr, unsigned long addr)
+{
+	unsigned i;
+	long offset = 0;
+	int found = 0;
+	struct mem_phdr *phdr;
+	for(i = 0; i < ehdr->e_phnum; i++) {
+		phdr = &ehdr->e_phdr[i];
+		if (phdr->p_type == PT_LOAD) {
+			offset = addr - phdr->p_paddr;
+			found++;
+			break;
+		}
+	}
+	if (!found)
+		die("move_loaded_segments: no PT_LOAD region 0x%016x\n", addr);
+	ehdr->e_entry += offset;
+	for(i = 0; i < ehdr->e_phnum; i++) {
+		phdr = &ehdr->e_phdr[i];
+		if (phdr->p_type == PT_LOAD)
+			phdr->p_paddr += offset;
+	}
+}
+
+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;
+
+	/* See options.h -- add any more there, too. */
+	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 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(&ehdr, mem_min);
+	} else if (update_loaded_segments(&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);
+		}
+
+		command_line_len = _ALIGN(command_line_len, 16);
+		command_line_base = add_buffer(info, cmdline,
+				command_line_len, command_line_len,
+				getpagesize(), 0UL,
+				max_addr, -1);
+		elf_rel_set_symbol(&info->rhdr, "__command_line_len",
+				&command_line_len, sizeof(long));
+		elf_rel_set_symbol(&info->rhdr, "__command_line",
+				&command_line_base, sizeof(long));
+	}
+	
+	if (ramdisk) {
+		ramdisk_buf = slurp_file(ramdisk, &ramdisk_size);
+		ramdisk_base = add_buffer(info, ramdisk_buf, ramdisk_size,
+				ramdisk_size,
+				getpagesize(), 0, max_addr, -1);
+		elf_rel_set_symbol(&info->rhdr, "__ramdisk_base",
+				&ramdisk_base, sizeof(long));
+		elf_rel_set_symbol(&info->rhdr, "__ramdisk_size",
+				&ramdisk_size, sizeof(long));
+	}
+
+	if (vmm) {
+		image_base = add_buffer(info, buf, len, len,
+				getpagesize(), 0, max_addr, -1);
+		elf_rel_set_symbol(&info->rhdr, "__vmcode_base",
+				&image_base, sizeof(long));
+		elf_rel_set_symbol(&info->rhdr, "__vmcode_size",
+				&len, sizeof(long));
+	}
+
+	gp_value = info->rhdr.rel_addr + 0x200000;
+        elf_rel_set_symbol(&info->rhdr, "__gp_value", &gp_value,
+                        sizeof(gp_value));
+
+	elf_rel_set_symbol(&info->rhdr, "__kernel_entry", &entry,
+			   sizeof(entry));
+	free_elf_info(&ehdr);
+	return 0;
+}
diff --git a/kexec/arch/ia64/kexec-elf-rel-ia64.c b/kexec/arch/ia64/kexec-elf-rel-ia64.c
new file mode 100644
index 0000000..500f247
--- /dev/null
+++ b/kexec/arch/ia64/kexec-elf-rel-ia64.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2005-2006  Zou Nan hai (nanhai.zou@intel.com)
+ *
+ * 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 (version 2 of the License).
+ *
+ * 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.
+ */
+
+/*  pugatory relocation code
+ *  Most of the code in this file is
+ *  based on arch/ia64/kernel/module.c in Linux kernel
+ */
+
+
+/*  Most of the code in this file is
+ *  based on arch/ia64/kernel/module.c in Linux kernel
+ */
+
+#include <stdio.h>
+#include <elf.h>
+#include "../../kexec.h"
+#include "../../kexec-elf.h"
+
+#define MAX_LTOFF       ((uint64_t) (1 << 22))
+
+int machine_verify_elf_rel(struct mem_ehdr *ehdr)
+{
+	if (ehdr->ei_data != ELFDATA2LSB) {
+		return 0;
+	}
+	if (ehdr->ei_class != ELFCLASS64) {
+		return 0;
+	}
+	if (ehdr->e_machine != EM_IA_64) {
+		return 0;
+	}
+	return 1;
+}
+
+static void
+ia64_patch (uint64_t insn_addr, uint64_t mask, uint64_t val)
+{
+        uint64_t m0, m1, v0, v1, b0, b1, *b = (uint64_t *) (insn_addr & -16);
+#       define insn_mask ((1UL << 41) - 1)
+        unsigned long shift;
+
+        b0 = b[0]; b1 = b[1];
+        shift = 5 + 41 * (insn_addr % 16); /* 5 bits of template, then 3 x 41-bit instructions */
+        if (shift >= 64) {
+                m1 = mask << (shift - 64);
+                v1 = val << (shift - 64);
+        } else {
+                m0 = mask << shift; m1 = mask >> (64 - shift);
+                v0 = val  << shift; v1 = val >> (64 - shift);
+                b[0] = (b0 & ~m0) | (v0 & m0);
+        }
+        b[1] = (b1 & ~m1) | (v1 & m1);
+}
+
+static inline uint64_t
+bundle (const uint64_t insn)
+{
+        return insn & ~0xfUL;
+}
+
+void machine_apply_elf_rel(struct mem_ehdr *ehdr,
+	struct mem_sym *UNUSED(sym), unsigned long r_type, void *location,
+	unsigned long address, unsigned long value)
+{
+	uint64_t gp_value = ehdr->rel_addr + 0x200000;
+	switch(r_type) {
+	case R_IA64_NONE:
+		break;
+	case R_IA64_SEGREL64LSB:
+	case R_IA64_DIR64LSB:
+		*((uint64_t *)location) = value;
+		break;
+	case R_IA64_DIR32LSB:
+		*((uint32_t *)location) = value;
+		if (value != *((uint32_t *)location))
+			goto overflow;
+		break;
+	case R_IA64_IMM64:
+		ia64_patch((uint64_t)location, 0x01fffefe000UL,
+				/* bit 63 -> 36 */
+				(((value & 0x8000000000000000UL) >> 27)
+				/* bit 21 -> 21 */
+				  | ((value & 0x0000000000200000UL) <<  0)
+				/* bit 16 -> 22 */
+				  | ((value & 0x00000000001f0000UL) <<  6)
+				/* bit 7 -> 27 */
+				  | ((value & 0x000000000000ff80UL) << 20)
+				/* bit 0 -> 13 */
+				  | ((value & 0x000000000000007fUL) << 13)));
+		ia64_patch((uint64_t)location - 1, 0x1ffffffffffUL, value>>22);
+		break;
+	case R_IA64_IMM22:
+		if (value + (1 << 21) >= (1 << 22))
+                	die("value out of IMM22 range\n");
+		ia64_patch((uint64_t)location, 0x01fffcfe000UL,
+				/* bit 21 -> 36 */
+				(((value & 0x200000UL) << 15)
+				/* bit 16 -> 22 */
+				 | ((value & 0x1f0000UL) <<  6)
+				/* bit  7 -> 27 */
+				 | ((value & 0x00ff80UL) << 20)
+				/* bit  0 -> 13 */
+				 | ((value & 0x00007fUL) << 13) ));
+		break;
+	case R_IA64_PCREL21B: {
+		uint64_t delta = ((int64_t)value - (int64_t)address)/16;
+		if (delta + (1 << 20) >= (1 << 21))
+			die("value out of IMM21B range\n");
+		value = ((int64_t)(value - bundle(address)))/16;
+		ia64_patch((uint64_t)location, 0x11ffffe000UL,
+				(((value & 0x100000UL) << 16) /* bit 20 -> 36 */
+				 | ((value & 0x0fffffUL) << 13) /* bit  0 -> 13 */));
+		}
+		break;
+	case R_IA64_PCREL64LSB: {
+		value = value - address;
+		put_unaligned(value, (uint64_t *)location);
+	} break;
+	case R_IA64_GPREL22:
+	case R_IA64_LTOFF22X:
+		if (value - gp_value + MAX_LTOFF/2 >= MAX_LTOFF)
+			die("value out of gp relative range");
+		value -= gp_value;
+		ia64_patch((uint64_t)location, 0x01fffcfe000UL,
+				(((value & 0x200000UL) << 15) /* bit 21 -> 36 */
+				   |((value & 0x1f0000UL) <<  6) /* bit 16 -> 22 */
+				   |((value & 0x00ff80UL) << 20) /* bit  7 -> 27 */
+				   |((value & 0x00007fUL) << 13) /* bit  0 -> 13 */));
+		break;
+	case R_IA64_LDXMOV:
+		if (value - gp_value + MAX_LTOFF/2 >= MAX_LTOFF)
+			die("value out of gp relative range");
+		ia64_patch((uint64_t)location, 0x1fff80fe000UL, 0x10000000000UL);
+	        break;
+	case R_IA64_LTOFF22:
+
+	default:
+		die("Unknown rela relocation: 0x%lx 0x%lx\n",
+				r_type, address);
+		break;
+	}
+	return;
+overflow:
+	die("overflow in relocation type %lu val %llx\n",
+			r_type, value);
+}
diff --git a/kexec/arch/ia64/kexec-ia64.c b/kexec/arch/ia64/kexec-ia64.c
new file mode 100644
index 0000000..418d997
--- /dev/null
+++ b/kexec/arch/ia64/kexec-ia64.c
@@ -0,0 +1,247 @@
+/*
+ * kexec: Linux boots Linux
+ *
+ * Copyright (C) 2003-2005  Eric Biederman (ebiederm@xmission.com)
+ * Copyright (C) 2004 Albert Herranz
+ * Copyright (C) 2004 Silicon Graphics, Inc.
+ *   Jesse Barnes <jbarnes@sgi.com>
+ *
+ * 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 (version 2 of the License).
+ *
+ * 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.
+ */
+
+#define _GNU_SOURCE
+#include <stddef.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdint.h>
+#include <string.h>
+#include <getopt.h>
+#include <sched.h>
+#include <limits.h>
+#include "../../kexec.h"
+#include "../../kexec-syscall.h"
+#include "elf.h"
+#include "kexec-ia64.h"
+#include <arch/options.h>
+
+/* The number of entries in memory_range array is always smaller than
+ * the number of entries in the file returned by proc_iomem(),
+ * stored in max_memory_ranges. */
+static struct memory_range *memory_range;
+int max_memory_ranges;
+static int memory_ranges;
+unsigned long saved_efi_memmap_size;
+
+/* Reserve range for EFI memmap and Boot parameter */
+static int split_range(int range, unsigned long start, unsigned long end)
+{
+	unsigned long ram_end = memory_range[range - 1].end;
+	unsigned int type = memory_range[range - 1].type;
+	int i;
+	//align end and start to page size of EFI
+	start = _ALIGN_DOWN(start, 1UL<<12);
+	end = _ALIGN(end, 1UL<<12);
+	for (i = 0; i < range; i++)
+		if(memory_range[i].start <= start && memory_range[i].end >=end)
+			break;
+	if (i >= range)
+		return range;
+	range = i;
+	if (memory_range[range].start < start) {
+		memory_range[range].end = start;
+		range++;
+	}
+	memory_range[range].start = start;
+	memory_range[range].end = end;
+	memory_range[range].type = RANGE_RESERVED;
+	range++;
+	if (end < ram_end) {
+		memory_range[range].start = end;
+		memory_range[range].end = ram_end;
+		memory_range[range].type = type;
+		range++;
+	}
+	return range;
+}
+
+/* Return a sorted list of available memory ranges. */
+int get_memory_ranges(struct memory_range **range, int *ranges,
+				unsigned long kexec_flags)
+{
+	const char *iomem = proc_iomem();
+	char line[MAX_LINE];
+	FILE *fp;
+	fp = fopen(iomem, "r");
+	if (!fp) {
+		fprintf(stderr, "Cannot open %s: %s\n",
+			iomem, strerror(errno));
+		return -1;
+	}
+
+	/* allocate memory_range dynamically */
+	max_memory_ranges = 0;
+	while(fgets(line, sizeof(line), fp) != 0) {
+		max_memory_ranges++;
+	}
+	memory_range = xmalloc(sizeof(struct memory_range) *
+			max_memory_ranges);
+	rewind(fp);
+
+	while(fgets(line, sizeof(line), fp) != 0) {
+		unsigned long start, end;
+		char *str;
+		unsigned type;
+		int consumed;
+		int count;
+		if (memory_ranges >= max_memory_ranges)
+			break;
+		count = sscanf(line, "%lx-%lx : %n",
+				&start, &end, &consumed);
+		if (count != 2)
+			continue;
+		str = line + consumed;
+		end = end + 1;
+		if (memcmp(str, "System RAM\n", 11) == 0) {
+			type = RANGE_RAM;
+		}
+		else if (memcmp(str, "reserved\n", 9) == 0) {
+			type = RANGE_RESERVED;
+		}
+		else if (memcmp(str, "Crash kernel\n", 13) == 0) {
+			/* Redefine the memory region boundaries if kernel
+			 * exports the limits and if it is panic kernel.
+			 * Override user values only if kernel exported
+			 * values are subset of user defined values.
+			 */
+
+			if (kexec_flags & KEXEC_ON_CRASH) {
+				if (start > mem_min)
+					mem_min = start;
+				if (end < mem_max)
+					mem_max = end;
+			}
+			continue;
+		} else if (memcmp(str, "Boot parameter\n", 14) == 0) {
+			memory_ranges = split_range(memory_ranges, start, end);
+			continue;
+		} else if (memcmp(str, "EFI Memory Map\n", 14) == 0) {
+			memory_ranges = split_range(memory_ranges, start, end);
+			saved_efi_memmap_size = end - start;
+			continue;
+		} else if (memcmp(str, "Uncached RAM\n", 13) == 0) {
+			type = RANGE_UNCACHED;
+		} else {
+			continue;
+		}
+		/*
+		 * Check if this memory range can be coalesced with
+		 * the previous range
+		 */
+		if ((memory_ranges > 0) &&
+			(start == memory_range[memory_ranges-1].end) &&
+			(type == memory_range[memory_ranges-1].type)) {
+			memory_range[memory_ranges-1].end = end;
+		}
+		else {
+			memory_range[memory_ranges].start = start;
+			memory_range[memory_ranges].end = end;
+			memory_range[memory_ranges].type = type;
+			memory_ranges++;
+		}
+	}
+	fclose(fp);
+ 	*range = memory_range;
+ 	*ranges = memory_ranges;
+
+ 	return 0;
+}
+
+/* Supported file types and callbacks */
+struct file_type file_type[] = {
+       {"elf-ia64", elf_ia64_probe, elf_ia64_load, elf_ia64_usage},
+};
+int file_types = sizeof(file_type) / sizeof(file_type[0]);
+
+
+void arch_usage(void)
+{
+}
+
+int arch_process_options(int argc, char **argv)
+{
+	/* This doesn't belong here!  Some sort of arch_init() ? */
+
+	/* execute from monarch processor */
+	cpu_set_t affinity;
+	CPU_ZERO(&affinity);
+	CPU_SET(0, &affinity);
+	sched_setaffinity(0, sizeof(affinity), &affinity);
+
+	return 0;
+}
+
+const struct arch_map_entry arches[] = {
+	{ "ia64", KEXEC_ARCH_IA_64 },
+	{ NULL, 0 },
+};
+
+int arch_compat_trampoline(struct kexec_info *UNUSED(info))
+{
+	return 0;
+}
+
+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 = _ALIGN(memory_range[i].start, align);
+		end = memory_range[i].end;
+		if (end > start && (end - start) > (end_addr - start_addr)) {
+		    move_loaded_segments(ehdr, start);
+			return 0;
+		}
+	}
+
+	return -1;
+}
+
+void arch_update_purgatory(struct kexec_info *UNUSED(info))
+{
+}
+
diff --git a/kexec/arch/ia64/kexec-ia64.h b/kexec/arch/ia64/kexec-ia64.h
new file mode 100644
index 0000000..31e4041
--- /dev/null
+++ b/kexec/arch/ia64/kexec-ia64.h
@@ -0,0 +1,14 @@
+#ifndef KEXEC_IA64_H
+#define KEXEC_IA64_H
+
+extern int max_memory_ranges;
+int elf_ia64_probe(const char *buf, off_t len);
+int elf_ia64_load(int argc, char **argv, const char *buf, off_t len,
+	struct kexec_info *info);
+void elf_ia64_usage(void);
+int update_loaded_segments(struct mem_ehdr *ehdr);
+void move_loaded_segments(struct mem_ehdr *ehdr, unsigned long addr);
+
+#define EFI_PAGE_SIZE	  (1UL<<12)
+#define ELF_PAGE_SIZE	  (1UL<<16)
+#endif /* KEXEC_IA64_H */
diff --git a/kexec/arch/ia64/kexec-iomem.c b/kexec/arch/ia64/kexec-iomem.c
new file mode 100644
index 0000000..7fd50cd
--- /dev/null
+++ b/kexec/arch/ia64/kexec-iomem.c
@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include <stdio.h>
+#include "../../kexec.h"
+#include "../../crashdump.h"
+
+static const char proc_iomem_str[]= "/proc/iomem";
+static const char proc_iomem_machine_str[]= "/proc/iomem_machine";
+
+/*
+ * On IA64 XEN the EFI tables are virtualised.
+ * For this reason on such systems /proc/iomem_machine is provided,
+ * which is based on the hypervisor's (machine's) EFI tables.
+ * If Xen is in use, then /proc/iomem is used for memory regions relating
+ * to the currently running dom0 kernel, and /proc/iomem_machine is used
+ * for regions relating to the machine itself or the hypervisor.
+ * If Xen is not in used, then /proc/iomem used.
+ */
+const char *proc_iomem(void)
+{
+	if (xen_present())
+		return proc_iomem_machine_str;
+	return proc_iomem_str;
+}