1 /* 2 * handle transition of Linux booting another kernel 3 * Copyright (C) 2002-2005 Eric Biederman <ebiederm@xmission.com> 4 * 5 * This source code is licensed under the GNU General Public License, 6 * Version 2. See the file COPYING for more details. 7 */ 8 9 #include <linux/mm.h> 10 #include <linux/kexec.h> 11 #include <linux/delay.h> 12 #include <linux/init.h> 13 #include <linux/numa.h> 14 #include <linux/ftrace.h> 15 16 #include <asm/pgtable.h> 17 #include <asm/pgalloc.h> 18 #include <asm/tlbflush.h> 19 #include <asm/mmu_context.h> 20 #include <asm/io.h> 21 #include <asm/apic.h> 22 #include <asm/cpufeature.h> 23 #include <asm/desc.h> 24 #include <asm/system.h> 25 #include <asm/cacheflush.h> 26 27 #define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE))) 28 static u32 kexec_pgd[1024] PAGE_ALIGNED; 29 #ifdef CONFIG_X86_PAE 30 static u32 kexec_pmd0[1024] PAGE_ALIGNED; 31 static u32 kexec_pmd1[1024] PAGE_ALIGNED; 32 #endif 33 static u32 kexec_pte0[1024] PAGE_ALIGNED; 34 static u32 kexec_pte1[1024] PAGE_ALIGNED; 35 36 static void set_idt(void *newidt, __u16 limit) 37 { 38 struct desc_ptr curidt; 39 40 /* ia32 supports unaliged loads & stores */ 41 curidt.size = limit; 42 curidt.address = (unsigned long)newidt; 43 44 load_idt(&curidt); 45 } 46 47 48 static void set_gdt(void *newgdt, __u16 limit) 49 { 50 struct desc_ptr curgdt; 51 52 /* ia32 supports unaligned loads & stores */ 53 curgdt.size = limit; 54 curgdt.address = (unsigned long)newgdt; 55 56 load_gdt(&curgdt); 57 } 58 59 static void load_segments(void) 60 { 61 #define __STR(X) #X 62 #define STR(X) __STR(X) 63 64 __asm__ __volatile__ ( 65 "\tljmp $"STR(__KERNEL_CS)",$1f\n" 66 "\t1:\n" 67 "\tmovl $"STR(__KERNEL_DS)",%%eax\n" 68 "\tmovl %%eax,%%ds\n" 69 "\tmovl %%eax,%%es\n" 70 "\tmovl %%eax,%%fs\n" 71 "\tmovl %%eax,%%gs\n" 72 "\tmovl %%eax,%%ss\n" 73 ::: "eax", "memory"); 74 #undef STR 75 #undef __STR 76 } 77 78 /* 79 * A architecture hook called to validate the 80 * proposed image and prepare the control pages 81 * as needed. The pages for KEXEC_CONTROL_CODE_SIZE 82 * have been allocated, but the segments have yet 83 * been copied into the kernel. 84 * 85 * Do what every setup is needed on image and the 86 * reboot code buffer to allow us to avoid allocations 87 * later. 88 * 89 * Make control page executable. 90 */ 91 int machine_kexec_prepare(struct kimage *image) 92 { 93 if (nx_enabled) 94 set_pages_x(image->control_code_page, 1); 95 return 0; 96 } 97 98 /* 99 * Undo anything leftover by machine_kexec_prepare 100 * when an image is freed. 101 */ 102 void machine_kexec_cleanup(struct kimage *image) 103 { 104 if (nx_enabled) 105 set_pages_nx(image->control_code_page, 1); 106 } 107 108 /* 109 * Do not allocate memory (or fail in any way) in machine_kexec(). 110 * We are past the point of no return, committed to rebooting now. 111 */ 112 void machine_kexec(struct kimage *image) 113 { 114 unsigned long page_list[PAGES_NR]; 115 void *control_page; 116 asmlinkage unsigned long 117 (*relocate_kernel_ptr)(unsigned long indirection_page, 118 unsigned long control_page, 119 unsigned long start_address, 120 unsigned int has_pae, 121 unsigned int preserve_context); 122 123 tracer_disable(); 124 125 /* Interrupts aren't acceptable while we reboot */ 126 local_irq_disable(); 127 128 if (image->preserve_context) { 129 #ifdef CONFIG_X86_IO_APIC 130 /* We need to put APICs in legacy mode so that we can 131 * get timer interrupts in second kernel. kexec/kdump 132 * paths already have calls to disable_IO_APIC() in 133 * one form or other. kexec jump path also need 134 * one. 135 */ 136 disable_IO_APIC(); 137 #endif 138 } 139 140 control_page = page_address(image->control_code_page); 141 memcpy(control_page, relocate_kernel, PAGE_SIZE/2); 142 143 relocate_kernel_ptr = control_page; 144 page_list[PA_CONTROL_PAGE] = __pa(control_page); 145 page_list[VA_CONTROL_PAGE] = (unsigned long)control_page; 146 page_list[PA_PGD] = __pa(kexec_pgd); 147 page_list[VA_PGD] = (unsigned long)kexec_pgd; 148 #ifdef CONFIG_X86_PAE 149 page_list[PA_PMD_0] = __pa(kexec_pmd0); 150 page_list[VA_PMD_0] = (unsigned long)kexec_pmd0; 151 page_list[PA_PMD_1] = __pa(kexec_pmd1); 152 page_list[VA_PMD_1] = (unsigned long)kexec_pmd1; 153 #endif 154 page_list[PA_PTE_0] = __pa(kexec_pte0); 155 page_list[VA_PTE_0] = (unsigned long)kexec_pte0; 156 page_list[PA_PTE_1] = __pa(kexec_pte1); 157 page_list[VA_PTE_1] = (unsigned long)kexec_pte1; 158 page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page) << PAGE_SHIFT); 159 160 /* The segment registers are funny things, they have both a 161 * visible and an invisible part. Whenever the visible part is 162 * set to a specific selector, the invisible part is loaded 163 * with from a table in memory. At no other time is the 164 * descriptor table in memory accessed. 165 * 166 * I take advantage of this here by force loading the 167 * segments, before I zap the gdt with an invalid value. 168 */ 169 load_segments(); 170 /* The gdt & idt are now invalid. 171 * If you want to load them you must set up your own idt & gdt. 172 */ 173 set_gdt(phys_to_virt(0),0); 174 set_idt(phys_to_virt(0),0); 175 176 /* now call it */ 177 image->start = relocate_kernel_ptr((unsigned long)image->head, 178 (unsigned long)page_list, 179 image->start, cpu_has_pae, 180 image->preserve_context); 181 } 182 183 void arch_crash_save_vmcoreinfo(void) 184 { 185 #ifdef CONFIG_NUMA 186 VMCOREINFO_SYMBOL(node_data); 187 VMCOREINFO_LENGTH(node_data, MAX_NUMNODES); 188 #endif 189 #ifdef CONFIG_X86_PAE 190 VMCOREINFO_CONFIG(X86_PAE); 191 #endif 192 } 193 194