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