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