Merge branch 'linus' into timers/hpet
[linux-2.6] / arch / powerpc / platforms / pseries / phyp_dump.c
1 /*
2  * Hypervisor-assisted dump
3  *
4  * Linas Vepstas, Manish Ahuja 2008
5  * Copyright 2008 IBM Corp.
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License
9  *      as published by the Free Software Foundation; either version
10  *      2 of the License, or (at your option) any later version.
11  *
12  */
13
14 #include <linux/init.h>
15 #include <linux/kobject.h>
16 #include <linux/mm.h>
17 #include <linux/of.h>
18 #include <linux/pfn.h>
19 #include <linux/swap.h>
20 #include <linux/sysfs.h>
21
22 #include <asm/page.h>
23 #include <asm/phyp_dump.h>
24 #include <asm/machdep.h>
25 #include <asm/prom.h>
26 #include <asm/rtas.h>
27
28 /* Variables, used to communicate data between early boot and late boot */
29 static struct phyp_dump phyp_dump_vars;
30 struct phyp_dump *phyp_dump_info = &phyp_dump_vars;
31
32 static int ibm_configure_kernel_dump;
33 /* ------------------------------------------------- */
34 /* RTAS interfaces to declare the dump regions */
35
36 struct dump_section {
37         u32 dump_flags;
38         u16 source_type;
39         u16 error_flags;
40         u64 source_address;
41         u64 source_length;
42         u64 length_copied;
43         u64 destination_address;
44 };
45
46 struct phyp_dump_header {
47         u32 version;
48         u16 num_of_sections;
49         u16 status;
50
51         u32 first_offset_section;
52         u32 dump_disk_section;
53         u64 block_num_dd;
54         u64 num_of_blocks_dd;
55         u32 offset_dd;
56         u32 maxtime_to_auto;
57         /* No dump disk path string used */
58
59         struct dump_section cpu_data;
60         struct dump_section hpte_data;
61         struct dump_section kernel_data;
62 };
63
64 /* The dump header *must be* in low memory, so .bss it */
65 static struct phyp_dump_header phdr;
66
67 #define NUM_DUMP_SECTIONS       3
68 #define DUMP_HEADER_VERSION     0x1
69 #define DUMP_REQUEST_FLAG       0x1
70 #define DUMP_SOURCE_CPU         0x0001
71 #define DUMP_SOURCE_HPTE        0x0002
72 #define DUMP_SOURCE_RMO         0x0011
73 #define DUMP_ERROR_FLAG         0x2000
74 #define DUMP_TRIGGERED          0x4000
75 #define DUMP_PERFORMED          0x8000
76
77
78 /**
79  * init_dump_header() - initialize the header declaring a dump
80  * Returns: length of dump save area.
81  *
82  * When the hypervisor saves crashed state, it needs to put
83  * it somewhere. The dump header tells the hypervisor where
84  * the data can be saved.
85  */
86 static unsigned long init_dump_header(struct phyp_dump_header *ph)
87 {
88         unsigned long addr_offset = 0;
89
90         /* Set up the dump header */
91         ph->version = DUMP_HEADER_VERSION;
92         ph->num_of_sections = NUM_DUMP_SECTIONS;
93         ph->status = 0;
94
95         ph->first_offset_section =
96                 (u32)offsetof(struct phyp_dump_header, cpu_data);
97         ph->dump_disk_section = 0;
98         ph->block_num_dd = 0;
99         ph->num_of_blocks_dd = 0;
100         ph->offset_dd = 0;
101
102         ph->maxtime_to_auto = 0; /* disabled */
103
104         /* The first two sections are mandatory */
105         ph->cpu_data.dump_flags = DUMP_REQUEST_FLAG;
106         ph->cpu_data.source_type = DUMP_SOURCE_CPU;
107         ph->cpu_data.source_address = 0;
108         ph->cpu_data.source_length = phyp_dump_info->cpu_state_size;
109         ph->cpu_data.destination_address = addr_offset;
110         addr_offset += phyp_dump_info->cpu_state_size;
111
112         ph->hpte_data.dump_flags = DUMP_REQUEST_FLAG;
113         ph->hpte_data.source_type = DUMP_SOURCE_HPTE;
114         ph->hpte_data.source_address = 0;
115         ph->hpte_data.source_length = phyp_dump_info->hpte_region_size;
116         ph->hpte_data.destination_address = addr_offset;
117         addr_offset += phyp_dump_info->hpte_region_size;
118
119         /* This section describes the low kernel region */
120         ph->kernel_data.dump_flags = DUMP_REQUEST_FLAG;
121         ph->kernel_data.source_type = DUMP_SOURCE_RMO;
122         ph->kernel_data.source_address = PHYP_DUMP_RMR_START;
123         ph->kernel_data.source_length = PHYP_DUMP_RMR_END;
124         ph->kernel_data.destination_address = addr_offset;
125         addr_offset += ph->kernel_data.source_length;
126
127         return addr_offset;
128 }
129
130 static void print_dump_header(const struct phyp_dump_header *ph)
131 {
132 #ifdef DEBUG
133         if (ph == NULL)
134                 return;
135
136         printk(KERN_INFO "dump header:\n");
137         /* setup some ph->sections required */
138         printk(KERN_INFO "version = %d\n", ph->version);
139         printk(KERN_INFO "Sections = %d\n", ph->num_of_sections);
140         printk(KERN_INFO "Status = 0x%x\n", ph->status);
141
142         /* No ph->disk, so all should be set to 0 */
143         printk(KERN_INFO "Offset to first section 0x%x\n",
144                 ph->first_offset_section);
145         printk(KERN_INFO "dump disk sections should be zero\n");
146         printk(KERN_INFO "dump disk section = %d\n", ph->dump_disk_section);
147         printk(KERN_INFO "block num = %lld\n", ph->block_num_dd);
148         printk(KERN_INFO "number of blocks = %lld\n", ph->num_of_blocks_dd);
149         printk(KERN_INFO "dump disk offset = %d\n", ph->offset_dd);
150         printk(KERN_INFO "Max auto time= %d\n", ph->maxtime_to_auto);
151
152         /*set cpu state and hpte states as well scratch pad area */
153         printk(KERN_INFO " CPU AREA \n");
154         printk(KERN_INFO "cpu dump_flags =%d\n", ph->cpu_data.dump_flags);
155         printk(KERN_INFO "cpu source_type =%d\n", ph->cpu_data.source_type);
156         printk(KERN_INFO "cpu error_flags =%d\n", ph->cpu_data.error_flags);
157         printk(KERN_INFO "cpu source_address =%llx\n",
158                 ph->cpu_data.source_address);
159         printk(KERN_INFO "cpu source_length =%llx\n",
160                 ph->cpu_data.source_length);
161         printk(KERN_INFO "cpu length_copied =%llx\n",
162                 ph->cpu_data.length_copied);
163
164         printk(KERN_INFO " HPTE AREA \n");
165         printk(KERN_INFO "HPTE dump_flags =%d\n", ph->hpte_data.dump_flags);
166         printk(KERN_INFO "HPTE source_type =%d\n", ph->hpte_data.source_type);
167         printk(KERN_INFO "HPTE error_flags =%d\n", ph->hpte_data.error_flags);
168         printk(KERN_INFO "HPTE source_address =%llx\n",
169                 ph->hpte_data.source_address);
170         printk(KERN_INFO "HPTE source_length =%llx\n",
171                 ph->hpte_data.source_length);
172         printk(KERN_INFO "HPTE length_copied =%llx\n",
173                 ph->hpte_data.length_copied);
174
175         printk(KERN_INFO " SRSD AREA \n");
176         printk(KERN_INFO "SRSD dump_flags =%d\n", ph->kernel_data.dump_flags);
177         printk(KERN_INFO "SRSD source_type =%d\n", ph->kernel_data.source_type);
178         printk(KERN_INFO "SRSD error_flags =%d\n", ph->kernel_data.error_flags);
179         printk(KERN_INFO "SRSD source_address =%llx\n",
180                 ph->kernel_data.source_address);
181         printk(KERN_INFO "SRSD source_length =%llx\n",
182                 ph->kernel_data.source_length);
183         printk(KERN_INFO "SRSD length_copied =%llx\n",
184                 ph->kernel_data.length_copied);
185 #endif
186 }
187
188 static ssize_t show_phyp_dump_active(struct kobject *kobj,
189                         struct kobj_attribute *attr, char *buf)
190 {
191
192         /* create filesystem entry so kdump is phyp-dump aware */
193         return sprintf(buf, "%lx\n", phyp_dump_info->phyp_dump_at_boot);
194 }
195
196 static struct kobj_attribute pdl = __ATTR(phyp_dump_active, 0600,
197                                         show_phyp_dump_active,
198                                         NULL);
199
200 static void register_dump_area(struct phyp_dump_header *ph, unsigned long addr)
201 {
202         int rc;
203
204         /* Add addr value if not initialized before */
205         if (ph->cpu_data.destination_address == 0) {
206                 ph->cpu_data.destination_address += addr;
207                 ph->hpte_data.destination_address += addr;
208                 ph->kernel_data.destination_address += addr;
209         }
210
211         /* ToDo Invalidate kdump and free memory range. */
212
213         do {
214                 rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
215                                 1, ph, sizeof(struct phyp_dump_header));
216         } while (rtas_busy_delay(rc));
217
218         if (rc) {
219                 printk(KERN_ERR "phyp-dump: unexpected error (%d) on "
220                                                 "register\n", rc);
221                 print_dump_header(ph);
222                 return;
223         }
224
225         rc = sysfs_create_file(kernel_kobj, &pdl.attr);
226         if (rc)
227                 printk(KERN_ERR "phyp-dump: unable to create sysfs"
228                                 " file (%d)\n", rc);
229 }
230
231 static
232 void invalidate_last_dump(struct phyp_dump_header *ph, unsigned long addr)
233 {
234         int rc;
235
236         /* Add addr value if not initialized before */
237         if (ph->cpu_data.destination_address == 0) {
238                 ph->cpu_data.destination_address += addr;
239                 ph->hpte_data.destination_address += addr;
240                 ph->kernel_data.destination_address += addr;
241         }
242
243         do {
244                 rc = rtas_call(ibm_configure_kernel_dump, 3, 1, NULL,
245                                 2, ph, sizeof(struct phyp_dump_header));
246         } while (rtas_busy_delay(rc));
247
248         if (rc) {
249                 printk(KERN_ERR "phyp-dump: unexpected error (%d) "
250                                                 "on invalidate\n", rc);
251                 print_dump_header(ph);
252         }
253 }
254
255 /* ------------------------------------------------- */
256 /**
257  * release_memory_range -- release memory previously lmb_reserved
258  * @start_pfn: starting physical frame number
259  * @nr_pages: number of pages to free.
260  *
261  * This routine will release memory that had been previously
262  * lmb_reserved in early boot. The released memory becomes
263  * available for genreal use.
264  */
265 static void release_memory_range(unsigned long start_pfn,
266                         unsigned long nr_pages)
267 {
268         struct page *rpage;
269         unsigned long end_pfn;
270         long i;
271
272         end_pfn = start_pfn + nr_pages;
273
274         for (i = start_pfn; i <= end_pfn; i++) {
275                 rpage = pfn_to_page(i);
276                 if (PageReserved(rpage)) {
277                         ClearPageReserved(rpage);
278                         init_page_count(rpage);
279                         __free_page(rpage);
280                         totalram_pages++;
281                 }
282         }
283 }
284
285 /**
286  * track_freed_range -- Counts the range being freed.
287  * Once the counter goes to zero, it re-registers dump for
288  * future use.
289  */
290 static void
291 track_freed_range(unsigned long addr, unsigned long length)
292 {
293         static unsigned long scratch_area_size, reserved_area_size;
294
295         if (addr < phyp_dump_info->init_reserve_start)
296                 return;
297
298         if ((addr >= phyp_dump_info->init_reserve_start) &&
299             (addr <= phyp_dump_info->init_reserve_start +
300              phyp_dump_info->init_reserve_size))
301                 reserved_area_size += length;
302
303         if ((addr >= phyp_dump_info->reserved_scratch_addr) &&
304             (addr <= phyp_dump_info->reserved_scratch_addr +
305              phyp_dump_info->reserved_scratch_size))
306                 scratch_area_size += length;
307
308         if ((reserved_area_size == phyp_dump_info->init_reserve_size) &&
309             (scratch_area_size == phyp_dump_info->reserved_scratch_size)) {
310
311                 invalidate_last_dump(&phdr,
312                                 phyp_dump_info->reserved_scratch_addr);
313                 register_dump_area(&phdr,
314                                 phyp_dump_info->reserved_scratch_addr);
315         }
316 }
317
318 /* ------------------------------------------------- */
319 /**
320  * sysfs_release_region -- sysfs interface to release memory range.
321  *
322  * Usage:
323  *   "echo <start addr> <length> > /sys/kernel/release_region"
324  *
325  * Example:
326  *   "echo 0x40000000 0x10000000 > /sys/kernel/release_region"
327  *
328  * will release 256MB starting at 1GB.
329  */
330 static ssize_t store_release_region(struct kobject *kobj,
331                                 struct kobj_attribute *attr,
332                                 const char *buf, size_t count)
333 {
334         unsigned long start_addr, length, end_addr;
335         unsigned long start_pfn, nr_pages;
336         ssize_t ret;
337
338         ret = sscanf(buf, "%lx %lx", &start_addr, &length);
339         if (ret != 2)
340                 return -EINVAL;
341
342         track_freed_range(start_addr, length);
343
344         /* Range-check - don't free any reserved memory that
345          * wasn't reserved for phyp-dump */
346         if (start_addr < phyp_dump_info->init_reserve_start)
347                 start_addr = phyp_dump_info->init_reserve_start;
348
349         end_addr = phyp_dump_info->init_reserve_start +
350                         phyp_dump_info->init_reserve_size;
351         if (start_addr+length > end_addr)
352                 length = end_addr - start_addr;
353
354         /* Release the region of memory assed in by user */
355         start_pfn = PFN_DOWN(start_addr);
356         nr_pages = PFN_DOWN(length);
357         release_memory_range(start_pfn, nr_pages);
358
359         return count;
360 }
361
362 static ssize_t show_release_region(struct kobject *kobj,
363                         struct kobj_attribute *attr, char *buf)
364 {
365         u64 second_addr_range;
366
367         /* total reserved size - start of scratch area */
368         second_addr_range = phyp_dump_info->init_reserve_size -
369                                 phyp_dump_info->reserved_scratch_size;
370         return sprintf(buf, "CPU:0x%llx-0x%llx: HPTE:0x%llx-0x%llx:"
371                             " DUMP:0x%llx-0x%llx, 0x%lx-0x%llx:\n",
372                 phdr.cpu_data.destination_address,
373                 phdr.cpu_data.length_copied,
374                 phdr.hpte_data.destination_address,
375                 phdr.hpte_data.length_copied,
376                 phdr.kernel_data.destination_address,
377                 phdr.kernel_data.length_copied,
378                 phyp_dump_info->init_reserve_start,
379                 second_addr_range);
380 }
381
382 static struct kobj_attribute rr = __ATTR(release_region, 0600,
383                                         show_release_region,
384                                         store_release_region);
385
386 static int __init phyp_dump_setup(void)
387 {
388         struct device_node *rtas;
389         const struct phyp_dump_header *dump_header = NULL;
390         unsigned long dump_area_start;
391         unsigned long dump_area_length;
392         int header_len = 0;
393         int rc;
394
395         /* If no memory was reserved in early boot, there is nothing to do */
396         if (phyp_dump_info->init_reserve_size == 0)
397                 return 0;
398
399         /* Return if phyp dump not supported */
400         if (!phyp_dump_info->phyp_dump_configured)
401                 return -ENOSYS;
402
403         /* Is there dump data waiting for us? If there isn't,
404          * then register a new dump area, and release all of
405          * the rest of the reserved ram.
406          *
407          * The /rtas/ibm,kernel-dump rtas node is present only
408          * if there is dump data waiting for us.
409          */
410         rtas = of_find_node_by_path("/rtas");
411         if (rtas) {
412                 dump_header = of_get_property(rtas, "ibm,kernel-dump",
413                                                 &header_len);
414                 of_node_put(rtas);
415         }
416
417         ibm_configure_kernel_dump = rtas_token("ibm,configure-kernel-dump");
418
419         print_dump_header(dump_header);
420         dump_area_length = init_dump_header(&phdr);
421         /* align down */
422         dump_area_start = phyp_dump_info->init_reserve_start & PAGE_MASK;
423
424         if (dump_header == NULL) {
425                 register_dump_area(&phdr, dump_area_start);
426                 return 0;
427         }
428
429         /* re-register the dump area, if old dump was invalid */
430         if ((dump_header) && (dump_header->status & DUMP_ERROR_FLAG)) {
431                 invalidate_last_dump(&phdr, dump_area_start);
432                 register_dump_area(&phdr, dump_area_start);
433                 return 0;
434         }
435
436         if (dump_header) {
437                 phyp_dump_info->reserved_scratch_addr =
438                                 dump_header->cpu_data.destination_address;
439                 phyp_dump_info->reserved_scratch_size =
440                                 dump_header->cpu_data.source_length +
441                                 dump_header->hpte_data.source_length +
442                                 dump_header->kernel_data.source_length;
443         }
444
445         /* Should we create a dump_subsys, analogous to s390/ipl.c ? */
446         rc = sysfs_create_file(kernel_kobj, &rr.attr);
447         if (rc)
448                 printk(KERN_ERR "phyp-dump: unable to create sysfs file (%d)\n",
449                                                                         rc);
450
451         /* ToDo: re-register the dump area, for next time. */
452         return 0;
453 }
454 machine_subsys_initcall(pseries, phyp_dump_setup);
455
456 int __init early_init_dt_scan_phyp_dump(unsigned long node,
457                 const char *uname, int depth, void *data)
458 {
459         const unsigned int *sizes;
460
461         phyp_dump_info->phyp_dump_configured = 0;
462         phyp_dump_info->phyp_dump_is_active = 0;
463
464         if (depth != 1 || strcmp(uname, "rtas") != 0)
465                 return 0;
466
467         if (of_get_flat_dt_prop(node, "ibm,configure-kernel-dump", NULL))
468                 phyp_dump_info->phyp_dump_configured++;
469
470         if (of_get_flat_dt_prop(node, "ibm,dump-kernel", NULL))
471                 phyp_dump_info->phyp_dump_is_active++;
472
473         sizes = of_get_flat_dt_prop(node, "ibm,configure-kernel-dump-sizes",
474                                     NULL);
475         if (!sizes)
476                 return 0;
477
478         if (sizes[0] == 1)
479                 phyp_dump_info->cpu_state_size = *((unsigned long *)&sizes[1]);
480
481         if (sizes[3] == 2)
482                 phyp_dump_info->hpte_region_size =
483                                                 *((unsigned long *)&sizes[4]);
484         return 1;
485 }
486
487 /* Look for phyp_dump= cmdline option */
488 static int __init early_phyp_dump_enabled(char *p)
489 {
490         phyp_dump_info->phyp_dump_at_boot = 1;
491
492         if (!p)
493                 return 0;
494
495         if (strncmp(p, "1", 1) == 0)
496                 phyp_dump_info->phyp_dump_at_boot = 1;
497         else if (strncmp(p, "0", 1) == 0)
498                 phyp_dump_info->phyp_dump_at_boot = 0;
499
500         return 0;
501 }
502 early_param("phyp_dump", early_phyp_dump_enabled);
503
504 /* Look for phyp_dump_reserve_size= cmdline option */
505 static int __init early_phyp_dump_reserve_size(char *p)
506 {
507         if (p)
508                 phyp_dump_info->reserve_bootvar = memparse(p, &p);
509
510         return 0;
511 }
512 early_param("phyp_dump_reserve_size", early_phyp_dump_reserve_size);