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/numa.h> 13 #include <linux/ftrace.h> 14 #include <linux/suspend.h> 15 #include <linux/gfp.h> 16 #include <linux/io.h> 17 18 #include <asm/pgtable.h> 19 #include <asm/pgalloc.h> 20 #include <asm/tlbflush.h> 21 #include <asm/mmu_context.h> 22 #include <asm/apic.h> 23 #include <asm/io_apic.h> 24 #include <asm/cpufeature.h> 25 #include <asm/desc.h> 26 #include <asm/cacheflush.h> 27 #include <asm/debugreg.h> 28 29 static void set_idt(void *newidt, __u16 limit) 30 { 31 struct desc_ptr curidt; 32 33 /* ia32 supports unaliged loads & stores */ 34 curidt.size = limit; 35 curidt.address = (unsigned long)newidt; 36 37 load_idt(&curidt); 38 } 39 40 41 static void set_gdt(void *newgdt, __u16 limit) 42 { 43 struct desc_ptr curgdt; 44 45 /* ia32 supports unaligned loads & stores */ 46 curgdt.size = limit; 47 curgdt.address = (unsigned long)newgdt; 48 49 load_gdt(&curgdt); 50 } 51 52 static void load_segments(void) 53 { 54 #define __STR(X) #X 55 #define STR(X) __STR(X) 56 57 __asm__ __volatile__ ( 58 "\tljmp $"STR(__KERNEL_CS)",$1f\n" 59 "\t1:\n" 60 "\tmovl $"STR(__KERNEL_DS)",%%eax\n" 61 "\tmovl %%eax,%%ds\n" 62 "\tmovl %%eax,%%es\n" 63 "\tmovl %%eax,%%fs\n" 64 "\tmovl %%eax,%%gs\n" 65 "\tmovl %%eax,%%ss\n" 66 : : : "eax", "memory"); 67 #undef STR 68 #undef __STR 69 } 70 71 static void machine_kexec_free_page_tables(struct kimage *image) 72 { 73 free_page((unsigned long)image->arch.pgd); 74 #ifdef CONFIG_X86_PAE 75 free_page((unsigned long)image->arch.pmd0); 76 free_page((unsigned long)image->arch.pmd1); 77 #endif 78 free_page((unsigned long)image->arch.pte0); 79 free_page((unsigned long)image->arch.pte1); 80 } 81 82 static int machine_kexec_alloc_page_tables(struct kimage *image) 83 { 84 image->arch.pgd = (pgd_t *)get_zeroed_page(GFP_KERNEL); 85 #ifdef CONFIG_X86_PAE 86 image->arch.pmd0 = (pmd_t *)get_zeroed_page(GFP_KERNEL); 87 image->arch.pmd1 = (pmd_t *)get_zeroed_page(GFP_KERNEL); 88 #endif 89 image->arch.pte0 = (pte_t *)get_zeroed_page(GFP_KERNEL); 90 image->arch.pte1 = (pte_t *)get_zeroed_page(GFP_KERNEL); 91 if (!image->arch.pgd || 92 #ifdef CONFIG_X86_PAE 93 !image->arch.pmd0 || !image->arch.pmd1 || 94 #endif 95 !image->arch.pte0 || !image->arch.pte1) { 96 machine_kexec_free_page_tables(image); 97 return -ENOMEM; 98 } 99 return 0; 100 } 101 102 static void machine_kexec_page_table_set_one( 103 pgd_t *pgd, pmd_t *pmd, pte_t *pte, 104 unsigned long vaddr, unsigned long paddr) 105 { 106 pud_t *pud; 107 108 pgd += pgd_index(vaddr); 109 #ifdef CONFIG_X86_PAE 110 if (!(pgd_val(*pgd) & _PAGE_PRESENT)) 111 set_pgd(pgd, __pgd(__pa(pmd) | _PAGE_PRESENT)); 112 #endif 113 pud = pud_offset(pgd, vaddr); 114 pmd = pmd_offset(pud, vaddr); 115 if (!(pmd_val(*pmd) & _PAGE_PRESENT)) 116 set_pmd(pmd, __pmd(__pa(pte) | _PAGE_TABLE)); 117 pte = pte_offset_kernel(pmd, vaddr); 118 set_pte(pte, pfn_pte(paddr >> PAGE_SHIFT, PAGE_KERNEL_EXEC)); 119 } 120 121 static void machine_kexec_prepare_page_tables(struct kimage *image) 122 { 123 void *control_page; 124 pmd_t *pmd = NULL; 125 126 control_page = page_address(image->control_code_page); 127 #ifdef CONFIG_X86_PAE 128 pmd = image->arch.pmd0; 129 #endif 130 machine_kexec_page_table_set_one( 131 image->arch.pgd, pmd, image->arch.pte0, 132 (unsigned long)control_page, __pa(control_page)); 133 #ifdef CONFIG_X86_PAE 134 pmd = image->arch.pmd1; 135 #endif 136 machine_kexec_page_table_set_one( 137 image->arch.pgd, pmd, image->arch.pte1, 138 __pa(control_page), __pa(control_page)); 139 } 140 141 /* 142 * A architecture hook called to validate the 143 * proposed image and prepare the control pages 144 * as needed. The pages for KEXEC_CONTROL_PAGE_SIZE 145 * have been allocated, but the segments have yet 146 * been copied into the kernel. 147 * 148 * Do what every setup is needed on image and the 149 * reboot code buffer to allow us to avoid allocations 150 * later. 151 * 152 * - Make control page executable. 153 * - Allocate page tables 154 * - Setup page tables 155 */ 156 int machine_kexec_prepare(struct kimage *image) 157 { 158 int error; 159 160 set_pages_x(image->control_code_page, 1); 161 error = machine_kexec_alloc_page_tables(image); 162 if (error) 163 return error; 164 machine_kexec_prepare_page_tables(image); 165 return 0; 166 } 167 168 /* 169 * Undo anything leftover by machine_kexec_prepare 170 * when an image is freed. 171 */ 172 void machine_kexec_cleanup(struct kimage *image) 173 { 174 set_pages_nx(image->control_code_page, 1); 175 machine_kexec_free_page_tables(image); 176 } 177 178 /* 179 * Do not allocate memory (or fail in any way) in machine_kexec(). 180 * We are past the point of no return, committed to rebooting now. 181 */ 182 void machine_kexec(struct kimage *image) 183 { 184 unsigned long page_list[PAGES_NR]; 185 void *control_page; 186 int save_ftrace_enabled; 187 asmlinkage unsigned long 188 (*relocate_kernel_ptr)(unsigned long indirection_page, 189 unsigned long control_page, 190 unsigned long start_address, 191 unsigned int has_pae, 192 unsigned int preserve_context); 193 194 #ifdef CONFIG_KEXEC_JUMP 195 if (image->preserve_context) 196 save_processor_state(); 197 #endif 198 199 save_ftrace_enabled = __ftrace_enabled_save(); 200 201 /* Interrupts aren't acceptable while we reboot */ 202 local_irq_disable(); 203 hw_breakpoint_disable(); 204 205 if (image->preserve_context) { 206 #ifdef CONFIG_X86_IO_APIC 207 /* 208 * We need to put APICs in legacy mode so that we can 209 * get timer interrupts in second kernel. kexec/kdump 210 * paths already have calls to disable_IO_APIC() in 211 * one form or other. kexec jump path also need 212 * one. 213 */ 214 disable_IO_APIC(); 215 #endif 216 } 217 218 control_page = page_address(image->control_code_page); 219 memcpy(control_page, relocate_kernel, KEXEC_CONTROL_CODE_MAX_SIZE); 220 221 relocate_kernel_ptr = control_page; 222 page_list[PA_CONTROL_PAGE] = __pa(control_page); 223 page_list[VA_CONTROL_PAGE] = (unsigned long)control_page; 224 page_list[PA_PGD] = __pa(image->arch.pgd); 225 226 if (image->type == KEXEC_TYPE_DEFAULT) 227 page_list[PA_SWAP_PAGE] = (page_to_pfn(image->swap_page) 228 << PAGE_SHIFT); 229 230 /* 231 * The segment registers are funny things, they have both a 232 * visible and an invisible part. Whenever the visible part is 233 * set to a specific selector, the invisible part is loaded 234 * with from a table in memory. At no other time is the 235 * descriptor table in memory accessed. 236 * 237 * I take advantage of this here by force loading the 238 * segments, before I zap the gdt with an invalid value. 239 */ 240 load_segments(); 241 /* 242 * The gdt & idt are now invalid. 243 * If you want to load them you must set up your own idt & gdt. 244 */ 245 set_gdt(phys_to_virt(0), 0); 246 set_idt(phys_to_virt(0), 0); 247 248 /* now call it */ 249 image->start = relocate_kernel_ptr((unsigned long)image->head, 250 (unsigned long)page_list, 251 image->start, 252 boot_cpu_has(X86_FEATURE_PAE), 253 image->preserve_context); 254 255 #ifdef CONFIG_KEXEC_JUMP 256 if (image->preserve_context) 257 restore_processor_state(); 258 #endif 259 260 __ftrace_enabled_restore(save_ftrace_enabled); 261 } 262 263 void arch_crash_save_vmcoreinfo(void) 264 { 265 #ifdef CONFIG_NUMA 266 VMCOREINFO_SYMBOL(node_data); 267 VMCOREINFO_LENGTH(node_data, MAX_NUMNODES); 268 #endif 269 #ifdef CONFIG_X86_PAE 270 VMCOREINFO_CONFIG(X86_PAE); 271 #endif 272 } 273 274