ia64/linux-2.6.18-xen.hg

view arch/ia64/kernel/machine_kexec.c @ 450:b7f980c60a61

kexec: add xen_machine_kexec_register_resources() and machine_kexec_register_resources()

Add xen_machine_kexec_register_resources() and
machine_kexec_register_resources() to allow architecture specific
handling of iomem resources.

At this time xen_machine_kexec_register_resources() does the
same parenting of per-cpu resources on all architectures.
And machine_kexec_register_resources does nothing on all
architectures.

Signed-off-by: Simon Horman <horms@verge.net.au>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Feb 28 10:54:20 2008 +0000 (2008-02-28)
parents 35f418758a77
children 11371d0e841b
line source
1 /*
2 * arch/ia64/kernel/machine_kexec.c
3 *
4 * Handle transition of Linux booting another kernel
5 * Copyright (C) 2005 Hewlett-Packard Development Comapny, L.P.
6 * Copyright (C) 2005 Khalid Aziz <khalid.aziz@hp.com>
7 * Copyright (C) 2006 Intel Corp, Zou Nan hai <nanhai.zou@intel.com>
8 *
9 * This source code is licensed under the GNU General Public License,
10 * Version 2. See the file COPYING for more details.
11 */
13 #include <linux/mm.h>
14 #include <linux/kexec.h>
15 #include <linux/cpu.h>
16 #include <linux/irq.h>
17 #include <asm/mmu_context.h>
18 #include <asm/setup.h>
19 #include <asm/delay.h>
20 #include <asm/meminit.h>
21 #ifdef CONFIG_XEN
22 #include <xen/interface/kexec.h>
23 #include <asm/kexec.h>
24 #endif
26 typedef void (*relocate_new_kernel_t)(unsigned long, unsigned long,
27 struct ia64_boot_param *, unsigned long);
29 struct kimage *ia64_kimage;
31 struct resource efi_memmap_res = {
32 .name = "EFI Memory Map",
33 .start = 0,
34 .end = 0,
35 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
36 };
38 struct resource boot_param_res = {
39 .name = "Boot parameter",
40 .start = 0,
41 .end = 0,
42 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
43 };
46 /*
47 * Do what every setup is needed on image and the
48 * reboot code buffer to allow us to avoid allocations
49 * later.
50 */
51 int machine_kexec_prepare(struct kimage *image)
52 {
53 void *control_code_buffer;
54 const unsigned long *func;
56 func = (unsigned long *)&relocate_new_kernel;
57 /* Pre-load control code buffer to minimize work in kexec path */
58 control_code_buffer = page_address(image->control_code_page);
59 memcpy((void *)control_code_buffer, (const void *)func[0],
60 relocate_new_kernel_size);
61 flush_icache_range((unsigned long)control_code_buffer,
62 (unsigned long)control_code_buffer + relocate_new_kernel_size);
63 ia64_kimage = image;
65 return 0;
66 }
68 void machine_kexec_cleanup(struct kimage *image)
69 {
70 }
72 #ifndef CONFIG_XEN
73 void machine_shutdown(void)
74 {
75 int cpu;
77 for_each_online_cpu(cpu) {
78 if (cpu != smp_processor_id())
79 cpu_down(cpu);
80 }
81 kexec_disable_iosapic();
82 }
84 /*
85 * Do not allocate memory (or fail in any way) in machine_kexec().
86 * We are past the point of no return, committed to rebooting now.
87 */
88 extern void *efi_get_pal_addr(void);
89 static void ia64_machine_kexec(struct unw_frame_info *info, void *arg)
90 {
91 struct kimage *image = arg;
92 relocate_new_kernel_t rnk;
93 void *pal_addr = efi_get_pal_addr();
94 unsigned long code_addr = (unsigned long)page_address(image->control_code_page);
95 unsigned long vector;
96 int ii;
98 if (image->type == KEXEC_TYPE_CRASH) {
99 crash_save_this_cpu();
100 current->thread.ksp = (__u64)info->sw - 16;
101 }
103 /* Interrupts aren't acceptable while we reboot */
104 local_irq_disable();
106 /* Mask CMC and Performance Monitor interrupts */
107 ia64_setreg(_IA64_REG_CR_PMV, 1 << 16);
108 ia64_setreg(_IA64_REG_CR_CMCV, 1 << 16);
110 /* Mask ITV and Local Redirect Registers */
111 ia64_set_itv(1 << 16);
112 ia64_set_lrr0(1 << 16);
113 ia64_set_lrr1(1 << 16);
115 /* terminate possible nested in-service interrupts */
116 for (ii = 0; ii < 16; ii++)
117 ia64_eoi();
119 /* unmask TPR and clear any pending interrupts */
120 ia64_setreg(_IA64_REG_CR_TPR, 0);
121 ia64_srlz_d();
122 vector = ia64_get_ivr();
123 while (vector != IA64_SPURIOUS_INT_VECTOR) {
124 ia64_eoi();
125 vector = ia64_get_ivr();
126 }
127 platform_kernel_launch_event();
128 rnk = (relocate_new_kernel_t)&code_addr;
129 (*rnk)(image->head, image->start, ia64_boot_param,
130 GRANULEROUNDDOWN((unsigned long) pal_addr));
131 BUG();
132 }
134 void machine_kexec(struct kimage *image)
135 {
136 unw_init_running(ia64_machine_kexec, image);
137 for(;;);
138 }
139 #else /* CONFIG_XEN */
140 void machine_kexec_setup_load_arg(xen_kexec_image_t *xki,struct kimage *image)
141 {
142 xki->reboot_code_buffer =
143 kexec_page_to_pfn(image->control_code_page) << PAGE_SHIFT;
144 }
146 int __init machine_kexec_setup_resources(struct resource *hypervisor,
147 struct resource *phys_cpus,
148 int nr_phys_cpus)
149 {
150 int k;
152 /* The per-cpu crash note resources belong to the hypervisor resource */
153 for (k = 0; k < nr_phys_cpus; k++)
154 request_resource(hypervisor, phys_cpus + k);
156 return 0;
157 }
159 void machine_kexec_register_resources(struct resource *res) { ; }
160 #endif /* CONFIG_XEN */