1
2
3
4
5
6
7
8
9
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>
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;
37 unsigned long low, high;
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
47
48
49
50 for (i = 0; i < image->nr_segments; i++)
51 if (image->segment[i].mem < __pa(_end))
52 return -ETXTBSY;
53
54
55
56
57
58
59
60
61
62
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
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
108
109
110
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
138 memcpy(ranges, image->segment, sizeof(ranges));
139
140
141
142
143
144
145
146 copy_segments(image->head);
147
148
149
150
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();
167 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF;
168 while(kexec_all_irq_disabled == 0)
169 cpu_relax();
170 mb();
171 hw_breakpoint_disable();
172
173
174
175
176 if (ppc_md.kexec_cpu_down)
177 ppc_md.kexec_cpu_down(0, 1);
178
179 kexec_smp_wait();
180
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
190
191
192
193
194
195
196
197
198
199
200
201
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
222
223
224
225
226
227
228
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, 0);
247 local_irq_disable();
248 hard_irq_disable();
249
250 mb();
251 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF;
252
253 kexec_prepare_cpus_wait(KEXEC_STATE_IRQS_OFF);
254
255 kexec_all_irq_disabled = 1;
256
257
258 if (ppc_md.kexec_cpu_down)
259 ppc_md.kexec_cpu_down(0, 0);
260
261
262
263
264
265 kexec_prepare_cpus_wait(KEXEC_STATE_REAL_MODE);
266
267 put_cpu();
268}
269
270#else
271
272static void kexec_prepare_cpus(void)
273{
274
275
276
277
278
279
280
281
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
291
292
293
294
295
296
297
298
299
300
301
302
303
304static union thread_union kexec_stack __init_task_data =
305 { };
306
307
308
309
310
311struct paca_struct kexec_paca;
312
313
314extern void kexec_sequence(void *newstack, unsigned long start,
315 void *image, void *control,
316 void (*clear_all)(void)) __noreturn;
317
318
319void default_machine_kexec(struct kimage *image)
320{
321
322
323
324
325
326
327
328
329
330
331 if (!kdump_in_progress())
332 kexec_prepare_cpus();
333
334 pr_debug("kexec: Starting switchover sequence.\n");
335
336
337
338
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
346
347
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
356
357
358
359
360
361
362 kexec_sequence(&kexec_stack, image->start, image,
363 page_address(image->control_code_page),
364 ppc_md.hpte_clear_all);
365
366}
367
368
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
390 if (!htab_address)
391 return -ENODEV;
392
393 node = of_find_node_by_path("/chosen");
394 if (!node)
395 return -ENODEV;
396
397
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