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
21#include <asm/page.h>
22#include <asm/current.h>
23#include <asm/machdep.h>
24#include <asm/cacheflush.h>
25#include <asm/paca.h>
26#include <asm/mmu.h>
27#include <asm/sections.h>
28#include <asm/prom.h>
29#include <asm/smp.h>
30#include <asm/hw_breakpoint.h>
31
32int default_machine_kexec_prepare(struct kimage *image)
33{
34 int i;
35 unsigned long begin, end;
36 unsigned long low, high;
37 struct device_node *node;
38 const unsigned long *basep;
39 const unsigned int *sizep;
40
41 if (!ppc_md.hpte_clear_all)
42 return -ENOENT;
43
44
45
46
47
48
49 for (i = 0; i < image->nr_segments; i++)
50 if (image->segment[i].mem < __pa(_end))
51 return -ETXTBSY;
52
53
54
55
56
57
58
59
60
61
62
63 if (htab_address) {
64 low = __pa(htab_address);
65 high = low + htab_size_bytes;
66
67 for (i = 0; i < image->nr_segments; i++) {
68 begin = image->segment[i].mem;
69 end = begin + image->segment[i].memsz;
70
71 if ((begin < high) && (end > low))
72 return -ETXTBSY;
73 }
74 }
75
76
77 for_each_node_by_type(node, "pci") {
78 basep = of_get_property(node, "linux,tce-base", NULL);
79 sizep = of_get_property(node, "linux,tce-size", NULL);
80 if (basep == NULL || sizep == NULL)
81 continue;
82
83 low = *basep;
84 high = low + (*sizep);
85
86 for (i = 0; i < image->nr_segments; i++) {
87 begin = image->segment[i].mem;
88 end = begin + image->segment[i].memsz;
89
90 if ((begin < high) && (end > low))
91 return -ETXTBSY;
92 }
93 }
94
95 return 0;
96}
97
98#define IND_FLAGS (IND_DESTINATION | IND_INDIRECTION | IND_DONE | IND_SOURCE)
99
100static void copy_segments(unsigned long ind)
101{
102 unsigned long entry;
103 unsigned long *ptr;
104 void *dest;
105 void *addr;
106
107
108
109
110
111
112
113 ptr = NULL;
114 dest = NULL;
115
116 for (entry = ind; !(entry & IND_DONE); entry = *ptr++) {
117 addr = __va(entry & PAGE_MASK);
118
119 switch (entry & IND_FLAGS) {
120 case IND_DESTINATION:
121 dest = addr;
122 break;
123 case IND_INDIRECTION:
124 ptr = addr;
125 break;
126 case IND_SOURCE:
127 copy_page(dest, addr);
128 dest += PAGE_SIZE;
129 }
130 }
131}
132
133void kexec_copy_flush(struct kimage *image)
134{
135 long i, nr_segments = image->nr_segments;
136 struct kexec_segment ranges[KEXEC_SEGMENT_MAX];
137
138
139 memcpy(ranges, image->segment, sizeof(ranges));
140
141
142
143
144
145
146
147 copy_segments(image->head);
148
149
150
151
152
153 for (i = 0; i < nr_segments; i++)
154 flush_icache_range((unsigned long)__va(ranges[i].mem),
155 (unsigned long)__va(ranges[i].mem + ranges[i].memsz));
156}
157
158#ifdef CONFIG_SMP
159
160static int kexec_all_irq_disabled = 0;
161
162static void kexec_smp_down(void *arg)
163{
164 local_irq_disable();
165 mb();
166 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF;
167 while(kexec_all_irq_disabled == 0)
168 cpu_relax();
169 mb();
170 hw_breakpoint_disable();
171
172
173
174
175 if (ppc_md.kexec_cpu_down)
176 ppc_md.kexec_cpu_down(0, 1);
177
178 kexec_smp_wait();
179
180}
181
182static void kexec_prepare_cpus_wait(int wait_state)
183{
184 int my_cpu, i, notified=-1;
185
186 hw_breakpoint_disable();
187 my_cpu = get_cpu();
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202 for_each_online_cpu(i) {
203 if (i == my_cpu)
204 continue;
205
206 while (paca[i].kexec_state < wait_state) {
207 barrier();
208 if (i != notified) {
209 printk(KERN_INFO "kexec: waiting for cpu %d "
210 "(physical %d) to enter %i state\n",
211 i, paca[i].hw_cpu_id, wait_state);
212 notified = i;
213 }
214 }
215 }
216 mb();
217}
218
219
220
221
222
223
224
225
226
227
228
229static void wake_offline_cpus(void)
230{
231 int cpu = 0;
232
233 for_each_present_cpu(cpu) {
234 if (!cpu_online(cpu)) {
235 printk(KERN_INFO "kexec: Waking offline cpu %d.\n",
236 cpu);
237 cpu_up(cpu);
238 }
239 }
240}
241
242static void kexec_prepare_cpus(void)
243{
244 wake_offline_cpus();
245 smp_call_function(kexec_smp_down, NULL, 0);
246 local_irq_disable();
247 mb();
248 get_paca()->kexec_state = KEXEC_STATE_IRQS_OFF;
249
250 kexec_prepare_cpus_wait(KEXEC_STATE_IRQS_OFF);
251
252 kexec_all_irq_disabled = 1;
253
254
255 if (ppc_md.kexec_cpu_down)
256 ppc_md.kexec_cpu_down(0, 0);
257
258
259
260
261
262 kexec_prepare_cpus_wait(KEXEC_STATE_REAL_MODE);
263
264 put_cpu();
265}
266
267#else
268
269static void kexec_prepare_cpus(void)
270{
271
272
273
274
275
276
277
278
279
280 smp_release_cpus();
281 if (ppc_md.kexec_cpu_down)
282 ppc_md.kexec_cpu_down(0, 0);
283 local_irq_disable();
284}
285
286#endif
287
288
289
290
291
292
293
294
295
296
297
298
299
300static union thread_union kexec_stack __init_task_data =
301 { };
302
303
304
305
306
307struct paca_struct kexec_paca;
308
309
310extern NORET_TYPE void kexec_sequence(void *newstack, unsigned long start,
311 void *image, void *control,
312 void (*clear_all)(void)) ATTRIB_NORET;
313
314
315void default_machine_kexec(struct kimage *image)
316{
317
318
319
320
321
322
323
324
325
326
327 if (crashing_cpu == -1)
328 kexec_prepare_cpus();
329
330 pr_debug("kexec: Starting switchover sequence.\n");
331
332
333
334
335 kexec_stack.thread_info.task = current_thread_info()->task;
336 kexec_stack.thread_info.flags = 0;
337
338
339
340
341
342 memcpy(&kexec_paca, get_paca(), sizeof(struct paca_struct));
343 kexec_paca.data_offset = 0xedeaddeadeeeeeeeUL;
344 paca = (struct paca_struct *)RELOC_HIDE(&kexec_paca, 0) -
345 kexec_paca.paca_index;
346 setup_paca(&kexec_paca);
347
348
349
350
351
352
353
354
355 kexec_sequence(&kexec_stack, image->start, image,
356 page_address(image->control_code_page),
357 ppc_md.hpte_clear_all);
358
359}
360
361
362static unsigned long htab_base;
363
364static struct property htab_base_prop = {
365 .name = "linux,htab-base",
366 .length = sizeof(unsigned long),
367 .value = &htab_base,
368};
369
370static struct property htab_size_prop = {
371 .name = "linux,htab-size",
372 .length = sizeof(unsigned long),
373 .value = &htab_size_bytes,
374};
375
376static int __init export_htab_values(void)
377{
378 struct device_node *node;
379 struct property *prop;
380
381
382 if (!htab_address)
383 return -ENODEV;
384
385 node = of_find_node_by_path("/chosen");
386 if (!node)
387 return -ENODEV;
388
389
390 prop = of_find_property(node, htab_base_prop.name, NULL);
391 if (prop)
392 prom_remove_property(node, prop);
393 prop = of_find_property(node, htab_size_prop.name, NULL);
394 if (prop)
395 prom_remove_property(node, prop);
396
397 htab_base = __pa(htab_address);
398 prom_add_property(node, &htab_base_prop);
399 prom_add_property(node, &htab_size_prop);
400
401 of_node_put(node);
402 return 0;
403}
404late_initcall(export_htab_values);
405