1/* 2 * PPC64 code to handle Linux booting another kernel. 3 * 4 * Copyright (C) 2004-2005, IBM Corp. 5 * 6 * Created by: Milton D Miller II 7 * 8 * This source code is licensed under the GNU General Public License, 9 * Version 2. See the file COPYING for more details. 10 */ 11 12 13#include <linux/kexec.h> 14#include <linux/smp.h> 15#include <linux/thread_info.h> 16#include <linux/init_task.h> 17#include <linux/errno.h> 18#include <linux/kernel.h> 19#include <linux/cpu.h> 20#include <linux/hardirq.h> 21 22#include <asm/page.h> 23#include <asm/current.h> 24#include <asm/machdep.h> 25#include <asm/cacheflush.h> 26#include <asm/paca.h> 27#include <asm/mmu.h> 28#include <asm/sections.h> /* _end */ 29#include <asm/prom.h> 30#include <asm/smp.h> 31#include <asm/hw_breakpoint.h> 32 33int default_machine_kexec_prepare(struct kimage *image) 34{ 35 int i; 36 unsigned long begin, end; /* limits of segment */ 37 unsigned long low, high; /* limits of blocked memory range */ 38 struct device_node *node; 39 const unsigned long *basep; 40 const unsigned int *sizep; 41 42 if (!ppc_md.hpte_clear_all) 43 return -ENOENT; 44 45 /* 46 * Since we use the kernel fault handlers and paging code to 47 * handle the virtual mode, we must make sure no destination 48 * overlaps kernel static data or bss. 49 */ 50 for (i = 0; i < image->nr_segments; i++) 51 if (image->segment[i].mem < __pa(_end)) 52 return -ETXTBSY; 53 54 /* 55 * For non-LPAR, we absolutely can not overwrite the mmu hash 56 * table, since we are still using the bolted entries in it to 57 * do the copy. Check that here. 58 * 59 * It is safe if the end is below the start of the blocked 60 * region (end <= low), or if the beginning is after the 61 * end of the blocked region (begin >= high). Use the 62 * boolean identity !(a || b) === (!a && !b). 63 */ 64 if (htab_address) { 65 low = __pa(htab_address); 66 high = low + htab_size_bytes; 67 68 for (i = 0; i < image->nr_segments; i++) { 69 begin = image->segment[i].mem; 70 end = begin + image->segment[i].memsz; 71 72 if ((begin < high) && (end > low)) 73 return -ETXTBSY; 74 } 75 } 76 77 /* We also should not overwrite the tce tables */ 78 for_each_node_by_type(node, "pci") { 79 basep = of_get_property(node, "linux,tce-base", NULL); 80 sizep = of_get_property(node, "linux,tce-size", NULL); 81 if (basep == NULL || sizep == NULL) 82 continue; 83 84 low = *basep; 85 high = low + (*sizep); 86 87 for (i = 0; i < image->nr_segments; i++) { 88 begin = image->segment[i].mem; 89 end = begin + image->segment[i].memsz; 90 91 if ((begin < high) && (end > low)) 92 return -ETXTBSY; 93 } 94 } 95 96 return 0; 97} 98 99static void copy_segments(unsigned long ind) 100{ 101 unsigned long entry; 102 unsigned long *ptr; 103 void *dest; 104 void *addr; 105 106 /* 107 * We rely on kexec_load to create a lists that properly 108 * initializes these pointers before they are used. 109 * We will still crash if the list is wrong, but at least 110 * the compiler will be quiet. 111 */ 112 ptr = NULL; 113 dest = NULL; 114 115 for (entry = ind; !(entry & IND_DONE); entry = *ptr++) { 116 addr = __va(entry & PAGE_MASK); 117 118 switch (entry & IND_FLAGS) { 119 case IND_DESTINATION: 120 dest = addr; 121 break; 122 case IND_INDIRECTION: 123 ptr = addr; 124 break; 125 case IND_SOURCE: 126 copy_page(dest, addr); 127 dest += PAGE_SIZE; 128 } 129 } 130} 131 132void kexec_copy_flush(struct kimage *image) 133{ 134 long i, nr_segments = image->nr_segments; 135 struct kexec_segment ranges[KEXEC_SEGMENT_MAX]; 136 137 /* save the ranges on the stack to efficiently flush the icache */ 138 memcpy(ranges, image->segment, sizeof(ranges)); 139 140 /* 141 * After this call we may not use anything allocated in dynamic 142 * memory, including *image. 143 * 144 * Only globals and the stack are allowed. 145 */ 146 copy_segments(image->head); 147 148 /* 149 * we need to clear the icache for all dest pages sometime, 150 * including ones that were in place on the original copy 151 */ 152 for (i = 0; i < nr_segments; i++) 153 flush_icache_range((unsigned long)__va(ranges[i].mem), 154 (unsigned long)__va(ranges[i].mem + ranges[i].memsz)); 155} 156 157#ifdef CONFIG_SMP 158 159static int kexec_all_irq_disabled = 0; 160 161static void kexec_smp_down(void *arg) 162{ 163 local_irq_disable(); 164 hard_irq_disable(); 165 166 mb(); /* make sure our irqs are disabled before we say they are */ 167 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF; 168 while(kexec_all_irq_disabled == 0) 169 cpu_relax(); 170 mb(); /* make sure all irqs are disabled before this */ 171 hw_breakpoint_disable(); 172 /* 173 * Now every CPU has IRQs off, we can clear out any pending 174 * IPIs and be sure that no more will come in after this. 175 */ 176 if (ppc_md.kexec_cpu_down) 177 ppc_md.kexec_cpu_down(0, 1); 178 179 kexec_smp_wait(); 180 /* NOTREACHED */ 181} 182 183static void kexec_prepare_cpus_wait(int wait_state) 184{ 185 int my_cpu, i, notified=-1; 186 187 hw_breakpoint_disable(); 188 my_cpu = get_cpu(); 189 /* Make sure each CPU has at least made it to the state we need. 190 * 191 * FIXME: There is a (slim) chance of a problem if not all of the CPUs 192 * are correctly onlined. If somehow we start a CPU on boot with RTAS 193 * start-cpu, but somehow that CPU doesn't write callin_cpu_map[] in 194 * time, the boot CPU will timeout. If it does eventually execute 195 * stuff, the secondary will start up (paca[].cpu_start was written) and 196 * get into a peculiar state. If the platform supports 197 * smp_ops->take_timebase(), the secondary CPU will probably be spinning 198 * in there. If not (i.e. pseries), the secondary will continue on and 199 * try to online itself/idle/etc. If it survives that, we need to find 200 * these possible-but-not-online-but-should-be CPUs and chaperone them 201 * into kexec_smp_wait(). 202 */ 203 for_each_online_cpu(i) { 204 if (i == my_cpu) 205 continue; 206 207 while (paca[i].kexec_state < wait_state) { 208 barrier(); 209 if (i != notified) { 210 printk(KERN_INFO "kexec: waiting for cpu %d " 211 "(physical %d) to enter %i state\n", 212 i, paca[i].hw_cpu_id, wait_state); 213 notified = i; 214 } 215 } 216 } 217 mb(); 218} 219 220/* 221 * We need to make sure each present CPU is online. The next kernel will scan 222 * the device tree and assume primary threads are online and query secondary 223 * threads via RTAS to online them if required. If we don't online primary 224 * threads, they will be stuck. However, we also online secondary threads as we 225 * may be using 'cede offline'. In this case RTAS doesn't see the secondary 226 * threads as offline -- and again, these CPUs will be stuck. 227 * 228 * So, we online all CPUs that should be running, including secondary threads. 229 */ 230static void wake_offline_cpus(void) 231{ 232 int cpu = 0; 233 234 for_each_present_cpu(cpu) { 235 if (!cpu_online(cpu)) { 236 printk(KERN_INFO "kexec: Waking offline cpu %d.\n", 237 cpu); 238 WARN_ON(cpu_up(cpu)); 239 } 240 } 241} 242 243static void kexec_prepare_cpus(void) 244{ 245 wake_offline_cpus(); 246 smp_call_function(kexec_smp_down, NULL, /* wait */0); 247 local_irq_disable(); 248 hard_irq_disable(); 249 250 mb(); /* make sure IRQs are disabled before we say they are */ 251 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF; 252 253 kexec_prepare_cpus_wait(KEXEC_STATE_IRQS_OFF); 254 /* we are sure every CPU has IRQs off at this point */ 255 kexec_all_irq_disabled = 1; 256 257 /* after we tell the others to go down */ 258 if (ppc_md.kexec_cpu_down) 259 ppc_md.kexec_cpu_down(0, 0); 260 261 /* 262 * Before removing MMU mappings make sure all CPUs have entered real 263 * mode: 264 */ 265 kexec_prepare_cpus_wait(KEXEC_STATE_REAL_MODE); 266 267 put_cpu(); 268} 269 270#else /* ! SMP */ 271 272static void kexec_prepare_cpus(void) 273{ 274 /* 275 * move the secondarys to us so that we can copy 276 * the new kernel 0-0x100 safely 277 * 278 * do this if kexec in setup.c ? 279 * 280 * We need to release the cpus if we are ever going from an 281 * UP to an SMP kernel. 282 */ 283 smp_release_cpus(); 284 if (ppc_md.kexec_cpu_down) 285 ppc_md.kexec_cpu_down(0, 0); 286 local_irq_disable(); 287 hard_irq_disable(); 288} 289 290#endif /* SMP */ 291 292/* 293 * kexec thread structure and stack. 294 * 295 * We need to make sure that this is 16384-byte aligned due to the 296 * way process stacks are handled. It also must be statically allocated 297 * or allocated as part of the kimage, because everything else may be 298 * overwritten when we copy the kexec image. We piggyback on the 299 * "init_task" linker section here to statically allocate a stack. 300 * 301 * We could use a smaller stack if we don't care about anything using 302 * current, but that audit has not been performed. 303 */ 304static union thread_union kexec_stack __init_task_data = 305 { }; 306 307/* 308 * For similar reasons to the stack above, the kexecing CPU needs to be on a 309 * static PACA; we switch to kexec_paca. 310 */ 311struct paca_struct kexec_paca; 312 313/* Our assembly helper, in misc_64.S */ 314extern void kexec_sequence(void *newstack, unsigned long start, 315 void *image, void *control, 316 void (*clear_all)(void)) __noreturn; 317 318/* too late to fail here */ 319void default_machine_kexec(struct kimage *image) 320{ 321 /* prepare control code if any */ 322 323 /* 324 * If the kexec boot is the normal one, need to shutdown other cpus 325 * into our wait loop and quiesce interrupts. 326 * Otherwise, in the case of crashed mode (crashing_cpu >= 0), 327 * stopping other CPUs and collecting their pt_regs is done before 328 * using debugger IPI. 329 */ 330 331 if (!kdump_in_progress()) 332 kexec_prepare_cpus(); 333 334 pr_debug("kexec: Starting switchover sequence.\n"); 335 336 /* switch to a staticly allocated stack. Based on irq stack code. 337 * We setup preempt_count to avoid using VMX in memcpy. 338 * XXX: the task struct will likely be invalid once we do the copy! 339 */ 340 kexec_stack.thread_info.task = current_thread_info()->task; 341 kexec_stack.thread_info.flags = 0; 342 kexec_stack.thread_info.preempt_count = HARDIRQ_OFFSET; 343 kexec_stack.thread_info.cpu = current_thread_info()->cpu; 344 345 /* We need a static PACA, too; copy this CPU's PACA over and switch to 346 * it. Also poison per_cpu_offset to catch anyone using non-static 347 * data. 348 */ 349 memcpy(&kexec_paca, get_paca(), sizeof(struct paca_struct)); 350 kexec_paca.data_offset = 0xedeaddeadeeeeeeeUL; 351 paca = (struct paca_struct *)RELOC_HIDE(&kexec_paca, 0) - 352 kexec_paca.paca_index; 353 setup_paca(&kexec_paca); 354 355 /* XXX: If anyone does 'dynamic lppacas' this will also need to be 356 * switched to a static version! 357 */ 358 359 /* Some things are best done in assembly. Finding globals with 360 * a toc is easier in C, so pass in what we can. 361 */ 362 kexec_sequence(&kexec_stack, image->start, image, 363 page_address(image->control_code_page), 364 ppc_md.hpte_clear_all); 365 /* NOTREACHED */ 366} 367 368/* Values we need to export to the second kernel via the device tree. */ 369static unsigned long htab_base; 370static unsigned long htab_size; 371 372static struct property htab_base_prop = { 373 .name = "linux,htab-base", 374 .length = sizeof(unsigned long), 375 .value = &htab_base, 376}; 377 378static struct property htab_size_prop = { 379 .name = "linux,htab-size", 380 .length = sizeof(unsigned long), 381 .value = &htab_size, 382}; 383 384static int __init export_htab_values(void) 385{ 386 struct device_node *node; 387 struct property *prop; 388 389 /* On machines with no htab htab_address is NULL */ 390 if (!htab_address) 391 return -ENODEV; 392 393 node = of_find_node_by_path("/chosen"); 394 if (!node) 395 return -ENODEV; 396 397 /* remove any stale propertys so ours can be found */ 398 prop = of_find_property(node, htab_base_prop.name, NULL); 399 if (prop) 400 of_remove_property(node, prop); 401 prop = of_find_property(node, htab_size_prop.name, NULL); 402 if (prop) 403 of_remove_property(node, prop); 404 405 htab_base = cpu_to_be64(__pa(htab_address)); 406 of_add_property(node, &htab_base_prop); 407 htab_size = cpu_to_be64(htab_size_bytes); 408 of_add_property(node, &htab_size_prop); 409 410 of_node_put(node); 411 return 0; 412} 413late_initcall(export_htab_values); 414