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