Commit | Line | Data |
---|---|---|
666bfddb VG |
1 | /* |
2 | * fs/proc/vmcore.c Interface for accessing the crash | |
3 | * dump from the system's previous life. | |
4 | * Heavily borrowed from fs/proc/kcore.c | |
5 | * Created by: Hariprasad Nellitheertha (hari@in.ibm.com) | |
6 | * Copyright (C) IBM Corporation, 2004. All rights reserved | |
7 | * | |
8 | */ | |
9 | ||
666bfddb | 10 | #include <linux/mm.h> |
2f96b8c1 | 11 | #include <linux/kcore.h> |
666bfddb | 12 | #include <linux/user.h> |
666bfddb VG |
13 | #include <linux/elf.h> |
14 | #include <linux/elfcore.h> | |
afeacc8c | 15 | #include <linux/export.h> |
5a0e3ad6 | 16 | #include <linux/slab.h> |
666bfddb | 17 | #include <linux/highmem.h> |
87ebdc00 | 18 | #include <linux/printk.h> |
666bfddb VG |
19 | #include <linux/bootmem.h> |
20 | #include <linux/init.h> | |
21 | #include <linux/crash_dump.h> | |
22 | #include <linux/list.h> | |
83086978 | 23 | #include <linux/vmalloc.h> |
666bfddb VG |
24 | #include <asm/uaccess.h> |
25 | #include <asm/io.h> | |
2f96b8c1 | 26 | #include "internal.h" |
666bfddb VG |
27 | |
28 | /* List representing chunks of contiguous memory areas and their offsets in | |
29 | * vmcore file. | |
30 | */ | |
31 | static LIST_HEAD(vmcore_list); | |
32 | ||
33 | /* Stores the pointer to the buffer containing kernel elf core headers. */ | |
34 | static char *elfcorebuf; | |
35 | static size_t elfcorebuf_sz; | |
f2bdacdd | 36 | static size_t elfcorebuf_sz_orig; |
666bfddb | 37 | |
087350c9 HD |
38 | static char *elfnotes_buf; |
39 | static size_t elfnotes_sz; | |
40 | ||
666bfddb VG |
41 | /* Total size of vmcore file. */ |
42 | static u64 vmcore_size; | |
43 | ||
5aa140c2 | 44 | static struct proc_dir_entry *proc_vmcore = NULL; |
666bfddb | 45 | |
997c136f OH |
46 | /* |
47 | * Returns > 0 for RAM pages, 0 for non-RAM pages, < 0 on error | |
48 | * The called function has to take care of module refcounting. | |
49 | */ | |
50 | static int (*oldmem_pfn_is_ram)(unsigned long pfn); | |
51 | ||
52 | int register_oldmem_pfn_is_ram(int (*fn)(unsigned long pfn)) | |
53 | { | |
54 | if (oldmem_pfn_is_ram) | |
55 | return -EBUSY; | |
56 | oldmem_pfn_is_ram = fn; | |
57 | return 0; | |
58 | } | |
59 | EXPORT_SYMBOL_GPL(register_oldmem_pfn_is_ram); | |
60 | ||
61 | void unregister_oldmem_pfn_is_ram(void) | |
62 | { | |
63 | oldmem_pfn_is_ram = NULL; | |
64 | wmb(); | |
65 | } | |
66 | EXPORT_SYMBOL_GPL(unregister_oldmem_pfn_is_ram); | |
67 | ||
68 | static int pfn_is_ram(unsigned long pfn) | |
69 | { | |
70 | int (*fn)(unsigned long pfn); | |
71 | /* pfn is ram unless fn() checks pagetype */ | |
72 | int ret = 1; | |
73 | ||
74 | /* | |
75 | * Ask hypervisor if the pfn is really ram. | |
76 | * A ballooned page contains no data and reading from such a page | |
77 | * will cause high load in the hypervisor. | |
78 | */ | |
79 | fn = oldmem_pfn_is_ram; | |
80 | if (fn) | |
81 | ret = fn(pfn); | |
82 | ||
83 | return ret; | |
84 | } | |
85 | ||
666bfddb VG |
86 | /* Reads a page from the oldmem device from given offset. */ |
87 | static ssize_t read_from_oldmem(char *buf, size_t count, | |
9e9e3941 | 88 | u64 *ppos, int userbuf) |
666bfddb VG |
89 | { |
90 | unsigned long pfn, offset; | |
91 | size_t nr_bytes; | |
92 | ssize_t read = 0, tmp; | |
93 | ||
94 | if (!count) | |
95 | return 0; | |
96 | ||
97 | offset = (unsigned long)(*ppos % PAGE_SIZE); | |
98 | pfn = (unsigned long)(*ppos / PAGE_SIZE); | |
666bfddb VG |
99 | |
100 | do { | |
101 | if (count > (PAGE_SIZE - offset)) | |
102 | nr_bytes = PAGE_SIZE - offset; | |
103 | else | |
104 | nr_bytes = count; | |
105 | ||
997c136f OH |
106 | /* If pfn is not ram, return zeros for sparse dump files */ |
107 | if (pfn_is_ram(pfn) == 0) | |
108 | memset(buf, 0, nr_bytes); | |
109 | else { | |
110 | tmp = copy_oldmem_page(pfn, buf, nr_bytes, | |
111 | offset, userbuf); | |
112 | if (tmp < 0) | |
113 | return tmp; | |
114 | } | |
666bfddb VG |
115 | *ppos += nr_bytes; |
116 | count -= nr_bytes; | |
117 | buf += nr_bytes; | |
118 | read += nr_bytes; | |
119 | ++pfn; | |
120 | offset = 0; | |
121 | } while (count); | |
122 | ||
123 | return read; | |
124 | } | |
125 | ||
be8a8d06 MH |
126 | /* |
127 | * Architectures may override this function to allocate ELF header in 2nd kernel | |
128 | */ | |
129 | int __weak elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size) | |
130 | { | |
131 | return 0; | |
132 | } | |
133 | ||
134 | /* | |
135 | * Architectures may override this function to free header | |
136 | */ | |
137 | void __weak elfcorehdr_free(unsigned long long addr) | |
138 | {} | |
139 | ||
140 | /* | |
141 | * Architectures may override this function to read from ELF header | |
142 | */ | |
143 | ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos) | |
144 | { | |
145 | return read_from_oldmem(buf, count, ppos, 0); | |
146 | } | |
147 | ||
148 | /* | |
149 | * Architectures may override this function to read from notes sections | |
150 | */ | |
151 | ssize_t __weak elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos) | |
152 | { | |
153 | return read_from_oldmem(buf, count, ppos, 0); | |
154 | } | |
155 | ||
666bfddb VG |
156 | /* Read from the ELF header and then the crash dump. On error, negative value is |
157 | * returned otherwise number of bytes read are returned. | |
158 | */ | |
159 | static ssize_t read_vmcore(struct file *file, char __user *buffer, | |
160 | size_t buflen, loff_t *fpos) | |
161 | { | |
162 | ssize_t acc = 0, tmp; | |
80e8ff63 | 163 | size_t tsz; |
b27eb186 HD |
164 | u64 start; |
165 | struct vmcore *m = NULL; | |
666bfddb VG |
166 | |
167 | if (buflen == 0 || *fpos >= vmcore_size) | |
168 | return 0; | |
169 | ||
170 | /* trim buflen to not go beyond EOF */ | |
171 | if (buflen > vmcore_size - *fpos) | |
172 | buflen = vmcore_size - *fpos; | |
173 | ||
174 | /* Read ELF core header */ | |
175 | if (*fpos < elfcorebuf_sz) { | |
087350c9 | 176 | tsz = min(elfcorebuf_sz - (size_t)*fpos, buflen); |
666bfddb VG |
177 | if (copy_to_user(buffer, elfcorebuf + *fpos, tsz)) |
178 | return -EFAULT; | |
179 | buflen -= tsz; | |
180 | *fpos += tsz; | |
181 | buffer += tsz; | |
182 | acc += tsz; | |
183 | ||
184 | /* leave now if filled buffer already */ | |
185 | if (buflen == 0) | |
186 | return acc; | |
187 | } | |
188 | ||
087350c9 HD |
189 | /* Read Elf note segment */ |
190 | if (*fpos < elfcorebuf_sz + elfnotes_sz) { | |
191 | void *kaddr; | |
192 | ||
193 | tsz = min(elfcorebuf_sz + elfnotes_sz - (size_t)*fpos, buflen); | |
194 | kaddr = elfnotes_buf + *fpos - elfcorebuf_sz; | |
195 | if (copy_to_user(buffer, kaddr, tsz)) | |
196 | return -EFAULT; | |
197 | buflen -= tsz; | |
198 | *fpos += tsz; | |
199 | buffer += tsz; | |
200 | acc += tsz; | |
201 | ||
202 | /* leave now if filled buffer already */ | |
203 | if (buflen == 0) | |
204 | return acc; | |
205 | } | |
206 | ||
b27eb186 HD |
207 | list_for_each_entry(m, &vmcore_list, list) { |
208 | if (*fpos < m->offset + m->size) { | |
087350c9 | 209 | tsz = min_t(size_t, m->offset + m->size - *fpos, buflen); |
b27eb186 HD |
210 | start = m->paddr + *fpos - m->offset; |
211 | tmp = read_from_oldmem(buffer, tsz, &start, 1); | |
212 | if (tmp < 0) | |
213 | return tmp; | |
214 | buflen -= tsz; | |
215 | *fpos += tsz; | |
216 | buffer += tsz; | |
217 | acc += tsz; | |
218 | ||
219 | /* leave now if filled buffer already */ | |
220 | if (buflen == 0) | |
221 | return acc; | |
666bfddb | 222 | } |
666bfddb | 223 | } |
b27eb186 | 224 | |
666bfddb VG |
225 | return acc; |
226 | } | |
227 | ||
83086978 HD |
228 | /** |
229 | * alloc_elfnotes_buf - allocate buffer for ELF note segment in | |
230 | * vmalloc memory | |
231 | * | |
232 | * @notes_sz: size of buffer | |
233 | * | |
234 | * If CONFIG_MMU is defined, use vmalloc_user() to allow users to mmap | |
235 | * the buffer to user-space by means of remap_vmalloc_range(). | |
236 | * | |
237 | * If CONFIG_MMU is not defined, use vzalloc() since mmap_vmcore() is | |
238 | * disabled and there's no need to allow users to mmap the buffer. | |
239 | */ | |
240 | static inline char *alloc_elfnotes_buf(size_t notes_sz) | |
241 | { | |
242 | #ifdef CONFIG_MMU | |
243 | return vmalloc_user(notes_sz); | |
244 | #else | |
245 | return vzalloc(notes_sz); | |
246 | #endif | |
247 | } | |
248 | ||
249 | /* | |
250 | * Disable mmap_vmcore() if CONFIG_MMU is not defined. MMU is | |
251 | * essential for mmap_vmcore() in order to map physically | |
252 | * non-contiguous objects (ELF header, ELF note segment and memory | |
253 | * regions in the 1st kernel pointed to by PT_LOAD entries) into | |
254 | * virtually contiguous user-space in ELF layout. | |
255 | */ | |
5a74953f | 256 | #if defined(CONFIG_MMU) && !defined(CONFIG_S390) |
83086978 HD |
257 | static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) |
258 | { | |
259 | size_t size = vma->vm_end - vma->vm_start; | |
260 | u64 start, end, len, tsz; | |
261 | struct vmcore *m; | |
262 | ||
263 | start = (u64)vma->vm_pgoff << PAGE_SHIFT; | |
264 | end = start + size; | |
265 | ||
266 | if (size > vmcore_size || end > vmcore_size) | |
267 | return -EINVAL; | |
268 | ||
269 | if (vma->vm_flags & (VM_WRITE | VM_EXEC)) | |
270 | return -EPERM; | |
271 | ||
272 | vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC); | |
273 | vma->vm_flags |= VM_MIXEDMAP; | |
274 | ||
275 | len = 0; | |
276 | ||
277 | if (start < elfcorebuf_sz) { | |
278 | u64 pfn; | |
279 | ||
280 | tsz = min(elfcorebuf_sz - (size_t)start, size); | |
281 | pfn = __pa(elfcorebuf + start) >> PAGE_SHIFT; | |
282 | if (remap_pfn_range(vma, vma->vm_start, pfn, tsz, | |
283 | vma->vm_page_prot)) | |
284 | return -EAGAIN; | |
285 | size -= tsz; | |
286 | start += tsz; | |
287 | len += tsz; | |
288 | ||
289 | if (size == 0) | |
290 | return 0; | |
291 | } | |
292 | ||
293 | if (start < elfcorebuf_sz + elfnotes_sz) { | |
294 | void *kaddr; | |
295 | ||
296 | tsz = min(elfcorebuf_sz + elfnotes_sz - (size_t)start, size); | |
297 | kaddr = elfnotes_buf + start - elfcorebuf_sz; | |
298 | if (remap_vmalloc_range_partial(vma, vma->vm_start + len, | |
299 | kaddr, tsz)) | |
300 | goto fail; | |
301 | size -= tsz; | |
302 | start += tsz; | |
303 | len += tsz; | |
304 | ||
305 | if (size == 0) | |
306 | return 0; | |
307 | } | |
308 | ||
309 | list_for_each_entry(m, &vmcore_list, list) { | |
310 | if (start < m->offset + m->size) { | |
311 | u64 paddr = 0; | |
312 | ||
313 | tsz = min_t(size_t, m->offset + m->size - start, size); | |
314 | paddr = m->paddr + start - m->offset; | |
315 | if (remap_pfn_range(vma, vma->vm_start + len, | |
316 | paddr >> PAGE_SHIFT, tsz, | |
317 | vma->vm_page_prot)) | |
318 | goto fail; | |
319 | size -= tsz; | |
320 | start += tsz; | |
321 | len += tsz; | |
322 | ||
323 | if (size == 0) | |
324 | return 0; | |
325 | } | |
326 | } | |
327 | ||
328 | return 0; | |
329 | fail: | |
330 | do_munmap(vma->vm_mm, vma->vm_start, len); | |
331 | return -EAGAIN; | |
332 | } | |
333 | #else | |
334 | static int mmap_vmcore(struct file *file, struct vm_area_struct *vma) | |
335 | { | |
336 | return -ENOSYS; | |
337 | } | |
338 | #endif | |
339 | ||
5aa140c2 | 340 | static const struct file_operations proc_vmcore_operations = { |
666bfddb | 341 | .read = read_vmcore, |
c227e690 | 342 | .llseek = default_llseek, |
83086978 | 343 | .mmap = mmap_vmcore, |
666bfddb VG |
344 | }; |
345 | ||
346 | static struct vmcore* __init get_new_element(void) | |
347 | { | |
2f6d3110 | 348 | return kzalloc(sizeof(struct vmcore), GFP_KERNEL); |
666bfddb VG |
349 | } |
350 | ||
591ff716 HD |
351 | static u64 __init get_vmcore_size(size_t elfsz, size_t elfnotesegsz, |
352 | struct list_head *vc_list) | |
666bfddb | 353 | { |
666bfddb | 354 | u64 size; |
591ff716 | 355 | struct vmcore *m; |
72658e9d | 356 | |
591ff716 HD |
357 | size = elfsz + elfnotesegsz; |
358 | list_for_each_entry(m, vc_list, list) { | |
359 | size += m->size; | |
72658e9d VG |
360 | } |
361 | return size; | |
362 | } | |
363 | ||
087350c9 HD |
364 | /** |
365 | * update_note_header_size_elf64 - update p_memsz member of each PT_NOTE entry | |
366 | * | |
367 | * @ehdr_ptr: ELF header | |
368 | * | |
369 | * This function updates p_memsz member of each PT_NOTE entry in the | |
370 | * program header table pointed to by @ehdr_ptr to real size of ELF | |
371 | * note segment. | |
372 | */ | |
373 | static int __init update_note_header_size_elf64(const Elf64_Ehdr *ehdr_ptr) | |
666bfddb | 374 | { |
087350c9 HD |
375 | int i, rc=0; |
376 | Elf64_Phdr *phdr_ptr; | |
666bfddb | 377 | Elf64_Nhdr *nhdr_ptr; |
666bfddb | 378 | |
087350c9 | 379 | phdr_ptr = (Elf64_Phdr *)(ehdr_ptr + 1); |
666bfddb | 380 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { |
666bfddb | 381 | void *notes_section; |
666bfddb VG |
382 | u64 offset, max_sz, sz, real_sz = 0; |
383 | if (phdr_ptr->p_type != PT_NOTE) | |
384 | continue; | |
666bfddb VG |
385 | max_sz = phdr_ptr->p_memsz; |
386 | offset = phdr_ptr->p_offset; | |
387 | notes_section = kmalloc(max_sz, GFP_KERNEL); | |
388 | if (!notes_section) | |
389 | return -ENOMEM; | |
be8a8d06 | 390 | rc = elfcorehdr_read_notes(notes_section, max_sz, &offset); |
666bfddb VG |
391 | if (rc < 0) { |
392 | kfree(notes_section); | |
393 | return rc; | |
394 | } | |
395 | nhdr_ptr = notes_section; | |
087350c9 | 396 | while (real_sz < max_sz) { |
666bfddb VG |
397 | if (nhdr_ptr->n_namesz == 0) |
398 | break; | |
399 | sz = sizeof(Elf64_Nhdr) + | |
400 | ((nhdr_ptr->n_namesz + 3) & ~3) + | |
401 | ((nhdr_ptr->n_descsz + 3) & ~3); | |
402 | real_sz += sz; | |
403 | nhdr_ptr = (Elf64_Nhdr*)((char*)nhdr_ptr + sz); | |
404 | } | |
666bfddb | 405 | kfree(notes_section); |
087350c9 | 406 | phdr_ptr->p_memsz = real_sz; |
666bfddb VG |
407 | } |
408 | ||
087350c9 HD |
409 | return 0; |
410 | } | |
411 | ||
412 | /** | |
413 | * get_note_number_and_size_elf64 - get the number of PT_NOTE program | |
414 | * headers and sum of real size of their ELF note segment headers and | |
415 | * data. | |
416 | * | |
417 | * @ehdr_ptr: ELF header | |
418 | * @nr_ptnote: buffer for the number of PT_NOTE program headers | |
419 | * @sz_ptnote: buffer for size of unique PT_NOTE program header | |
420 | * | |
421 | * This function is used to merge multiple PT_NOTE program headers | |
422 | * into a unique single one. The resulting unique entry will have | |
423 | * @sz_ptnote in its phdr->p_mem. | |
424 | * | |
425 | * It is assumed that program headers with PT_NOTE type pointed to by | |
426 | * @ehdr_ptr has already been updated by update_note_header_size_elf64 | |
427 | * and each of PT_NOTE program headers has actual ELF note segment | |
428 | * size in its p_memsz member. | |
429 | */ | |
430 | static int __init get_note_number_and_size_elf64(const Elf64_Ehdr *ehdr_ptr, | |
431 | int *nr_ptnote, u64 *sz_ptnote) | |
432 | { | |
433 | int i; | |
434 | Elf64_Phdr *phdr_ptr; | |
435 | ||
436 | *nr_ptnote = *sz_ptnote = 0; | |
437 | ||
438 | phdr_ptr = (Elf64_Phdr *)(ehdr_ptr + 1); | |
439 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
440 | if (phdr_ptr->p_type != PT_NOTE) | |
441 | continue; | |
442 | *nr_ptnote += 1; | |
443 | *sz_ptnote += phdr_ptr->p_memsz; | |
444 | } | |
445 | ||
446 | return 0; | |
447 | } | |
448 | ||
449 | /** | |
450 | * copy_notes_elf64 - copy ELF note segments in a given buffer | |
451 | * | |
452 | * @ehdr_ptr: ELF header | |
453 | * @notes_buf: buffer into which ELF note segments are copied | |
454 | * | |
455 | * This function is used to copy ELF note segment in the 1st kernel | |
456 | * into the buffer @notes_buf in the 2nd kernel. It is assumed that | |
457 | * size of the buffer @notes_buf is equal to or larger than sum of the | |
458 | * real ELF note segment headers and data. | |
459 | * | |
460 | * It is assumed that program headers with PT_NOTE type pointed to by | |
461 | * @ehdr_ptr has already been updated by update_note_header_size_elf64 | |
462 | * and each of PT_NOTE program headers has actual ELF note segment | |
463 | * size in its p_memsz member. | |
464 | */ | |
465 | static int __init copy_notes_elf64(const Elf64_Ehdr *ehdr_ptr, char *notes_buf) | |
466 | { | |
467 | int i, rc=0; | |
468 | Elf64_Phdr *phdr_ptr; | |
469 | ||
470 | phdr_ptr = (Elf64_Phdr*)(ehdr_ptr + 1); | |
471 | ||
472 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
473 | u64 offset; | |
474 | if (phdr_ptr->p_type != PT_NOTE) | |
475 | continue; | |
476 | offset = phdr_ptr->p_offset; | |
be8a8d06 MH |
477 | rc = elfcorehdr_read_notes(notes_buf, phdr_ptr->p_memsz, |
478 | &offset); | |
087350c9 HD |
479 | if (rc < 0) |
480 | return rc; | |
481 | notes_buf += phdr_ptr->p_memsz; | |
482 | } | |
483 | ||
484 | return 0; | |
485 | } | |
486 | ||
487 | /* Merges all the PT_NOTE headers into one. */ | |
488 | static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, | |
489 | char **notes_buf, size_t *notes_sz) | |
490 | { | |
491 | int i, nr_ptnote=0, rc=0; | |
492 | char *tmp; | |
493 | Elf64_Ehdr *ehdr_ptr; | |
494 | Elf64_Phdr phdr; | |
495 | u64 phdr_sz = 0, note_off; | |
496 | ||
497 | ehdr_ptr = (Elf64_Ehdr *)elfptr; | |
498 | ||
499 | rc = update_note_header_size_elf64(ehdr_ptr); | |
500 | if (rc < 0) | |
501 | return rc; | |
502 | ||
503 | rc = get_note_number_and_size_elf64(ehdr_ptr, &nr_ptnote, &phdr_sz); | |
504 | if (rc < 0) | |
505 | return rc; | |
506 | ||
507 | *notes_sz = roundup(phdr_sz, PAGE_SIZE); | |
83086978 | 508 | *notes_buf = alloc_elfnotes_buf(*notes_sz); |
087350c9 HD |
509 | if (!*notes_buf) |
510 | return -ENOMEM; | |
511 | ||
512 | rc = copy_notes_elf64(ehdr_ptr, *notes_buf); | |
513 | if (rc < 0) | |
514 | return rc; | |
515 | ||
666bfddb VG |
516 | /* Prepare merged PT_NOTE program header. */ |
517 | phdr.p_type = PT_NOTE; | |
518 | phdr.p_flags = 0; | |
519 | note_off = sizeof(Elf64_Ehdr) + | |
520 | (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf64_Phdr); | |
087350c9 | 521 | phdr.p_offset = roundup(note_off, PAGE_SIZE); |
666bfddb VG |
522 | phdr.p_vaddr = phdr.p_paddr = 0; |
523 | phdr.p_filesz = phdr.p_memsz = phdr_sz; | |
524 | phdr.p_align = 0; | |
525 | ||
526 | /* Add merged PT_NOTE program header*/ | |
527 | tmp = elfptr + sizeof(Elf64_Ehdr); | |
528 | memcpy(tmp, &phdr, sizeof(phdr)); | |
529 | tmp += sizeof(phdr); | |
530 | ||
531 | /* Remove unwanted PT_NOTE program headers. */ | |
532 | i = (nr_ptnote - 1) * sizeof(Elf64_Phdr); | |
533 | *elfsz = *elfsz - i; | |
534 | memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf64_Ehdr)-sizeof(Elf64_Phdr))); | |
f2bdacdd HD |
535 | memset(elfptr + *elfsz, 0, i); |
536 | *elfsz = roundup(*elfsz, PAGE_SIZE); | |
666bfddb VG |
537 | |
538 | /* Modify e_phnum to reflect merged headers. */ | |
539 | ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; | |
540 | ||
541 | return 0; | |
542 | } | |
543 | ||
087350c9 HD |
544 | /** |
545 | * update_note_header_size_elf32 - update p_memsz member of each PT_NOTE entry | |
546 | * | |
547 | * @ehdr_ptr: ELF header | |
548 | * | |
549 | * This function updates p_memsz member of each PT_NOTE entry in the | |
550 | * program header table pointed to by @ehdr_ptr to real size of ELF | |
551 | * note segment. | |
552 | */ | |
553 | static int __init update_note_header_size_elf32(const Elf32_Ehdr *ehdr_ptr) | |
72658e9d | 554 | { |
087350c9 HD |
555 | int i, rc=0; |
556 | Elf32_Phdr *phdr_ptr; | |
72658e9d | 557 | Elf32_Nhdr *nhdr_ptr; |
72658e9d | 558 | |
087350c9 | 559 | phdr_ptr = (Elf32_Phdr *)(ehdr_ptr + 1); |
72658e9d | 560 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { |
72658e9d | 561 | void *notes_section; |
72658e9d VG |
562 | u64 offset, max_sz, sz, real_sz = 0; |
563 | if (phdr_ptr->p_type != PT_NOTE) | |
564 | continue; | |
72658e9d VG |
565 | max_sz = phdr_ptr->p_memsz; |
566 | offset = phdr_ptr->p_offset; | |
567 | notes_section = kmalloc(max_sz, GFP_KERNEL); | |
568 | if (!notes_section) | |
569 | return -ENOMEM; | |
be8a8d06 | 570 | rc = elfcorehdr_read_notes(notes_section, max_sz, &offset); |
72658e9d VG |
571 | if (rc < 0) { |
572 | kfree(notes_section); | |
573 | return rc; | |
574 | } | |
575 | nhdr_ptr = notes_section; | |
087350c9 | 576 | while (real_sz < max_sz) { |
72658e9d VG |
577 | if (nhdr_ptr->n_namesz == 0) |
578 | break; | |
579 | sz = sizeof(Elf32_Nhdr) + | |
580 | ((nhdr_ptr->n_namesz + 3) & ~3) + | |
581 | ((nhdr_ptr->n_descsz + 3) & ~3); | |
582 | real_sz += sz; | |
583 | nhdr_ptr = (Elf32_Nhdr*)((char*)nhdr_ptr + sz); | |
584 | } | |
72658e9d | 585 | kfree(notes_section); |
087350c9 HD |
586 | phdr_ptr->p_memsz = real_sz; |
587 | } | |
588 | ||
589 | return 0; | |
590 | } | |
591 | ||
592 | /** | |
593 | * get_note_number_and_size_elf32 - get the number of PT_NOTE program | |
594 | * headers and sum of real size of their ELF note segment headers and | |
595 | * data. | |
596 | * | |
597 | * @ehdr_ptr: ELF header | |
598 | * @nr_ptnote: buffer for the number of PT_NOTE program headers | |
599 | * @sz_ptnote: buffer for size of unique PT_NOTE program header | |
600 | * | |
601 | * This function is used to merge multiple PT_NOTE program headers | |
602 | * into a unique single one. The resulting unique entry will have | |
603 | * @sz_ptnote in its phdr->p_mem. | |
604 | * | |
605 | * It is assumed that program headers with PT_NOTE type pointed to by | |
606 | * @ehdr_ptr has already been updated by update_note_header_size_elf32 | |
607 | * and each of PT_NOTE program headers has actual ELF note segment | |
608 | * size in its p_memsz member. | |
609 | */ | |
610 | static int __init get_note_number_and_size_elf32(const Elf32_Ehdr *ehdr_ptr, | |
611 | int *nr_ptnote, u64 *sz_ptnote) | |
612 | { | |
613 | int i; | |
614 | Elf32_Phdr *phdr_ptr; | |
615 | ||
616 | *nr_ptnote = *sz_ptnote = 0; | |
617 | ||
618 | phdr_ptr = (Elf32_Phdr *)(ehdr_ptr + 1); | |
619 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
620 | if (phdr_ptr->p_type != PT_NOTE) | |
621 | continue; | |
622 | *nr_ptnote += 1; | |
623 | *sz_ptnote += phdr_ptr->p_memsz; | |
72658e9d VG |
624 | } |
625 | ||
087350c9 HD |
626 | return 0; |
627 | } | |
628 | ||
629 | /** | |
630 | * copy_notes_elf32 - copy ELF note segments in a given buffer | |
631 | * | |
632 | * @ehdr_ptr: ELF header | |
633 | * @notes_buf: buffer into which ELF note segments are copied | |
634 | * | |
635 | * This function is used to copy ELF note segment in the 1st kernel | |
636 | * into the buffer @notes_buf in the 2nd kernel. It is assumed that | |
637 | * size of the buffer @notes_buf is equal to or larger than sum of the | |
638 | * real ELF note segment headers and data. | |
639 | * | |
640 | * It is assumed that program headers with PT_NOTE type pointed to by | |
641 | * @ehdr_ptr has already been updated by update_note_header_size_elf32 | |
642 | * and each of PT_NOTE program headers has actual ELF note segment | |
643 | * size in its p_memsz member. | |
644 | */ | |
645 | static int __init copy_notes_elf32(const Elf32_Ehdr *ehdr_ptr, char *notes_buf) | |
646 | { | |
647 | int i, rc=0; | |
648 | Elf32_Phdr *phdr_ptr; | |
649 | ||
650 | phdr_ptr = (Elf32_Phdr*)(ehdr_ptr + 1); | |
651 | ||
652 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
653 | u64 offset; | |
654 | if (phdr_ptr->p_type != PT_NOTE) | |
655 | continue; | |
656 | offset = phdr_ptr->p_offset; | |
be8a8d06 MH |
657 | rc = elfcorehdr_read_notes(notes_buf, phdr_ptr->p_memsz, |
658 | &offset); | |
087350c9 HD |
659 | if (rc < 0) |
660 | return rc; | |
661 | notes_buf += phdr_ptr->p_memsz; | |
662 | } | |
663 | ||
664 | return 0; | |
665 | } | |
666 | ||
667 | /* Merges all the PT_NOTE headers into one. */ | |
668 | static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz, | |
669 | char **notes_buf, size_t *notes_sz) | |
670 | { | |
671 | int i, nr_ptnote=0, rc=0; | |
672 | char *tmp; | |
673 | Elf32_Ehdr *ehdr_ptr; | |
674 | Elf32_Phdr phdr; | |
675 | u64 phdr_sz = 0, note_off; | |
676 | ||
677 | ehdr_ptr = (Elf32_Ehdr *)elfptr; | |
678 | ||
679 | rc = update_note_header_size_elf32(ehdr_ptr); | |
680 | if (rc < 0) | |
681 | return rc; | |
682 | ||
683 | rc = get_note_number_and_size_elf32(ehdr_ptr, &nr_ptnote, &phdr_sz); | |
684 | if (rc < 0) | |
685 | return rc; | |
686 | ||
687 | *notes_sz = roundup(phdr_sz, PAGE_SIZE); | |
83086978 | 688 | *notes_buf = alloc_elfnotes_buf(*notes_sz); |
087350c9 HD |
689 | if (!*notes_buf) |
690 | return -ENOMEM; | |
691 | ||
692 | rc = copy_notes_elf32(ehdr_ptr, *notes_buf); | |
693 | if (rc < 0) | |
694 | return rc; | |
695 | ||
72658e9d VG |
696 | /* Prepare merged PT_NOTE program header. */ |
697 | phdr.p_type = PT_NOTE; | |
698 | phdr.p_flags = 0; | |
699 | note_off = sizeof(Elf32_Ehdr) + | |
700 | (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf32_Phdr); | |
087350c9 | 701 | phdr.p_offset = roundup(note_off, PAGE_SIZE); |
72658e9d VG |
702 | phdr.p_vaddr = phdr.p_paddr = 0; |
703 | phdr.p_filesz = phdr.p_memsz = phdr_sz; | |
704 | phdr.p_align = 0; | |
705 | ||
706 | /* Add merged PT_NOTE program header*/ | |
707 | tmp = elfptr + sizeof(Elf32_Ehdr); | |
708 | memcpy(tmp, &phdr, sizeof(phdr)); | |
709 | tmp += sizeof(phdr); | |
710 | ||
711 | /* Remove unwanted PT_NOTE program headers. */ | |
712 | i = (nr_ptnote - 1) * sizeof(Elf32_Phdr); | |
713 | *elfsz = *elfsz - i; | |
714 | memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf32_Ehdr)-sizeof(Elf32_Phdr))); | |
f2bdacdd HD |
715 | memset(elfptr + *elfsz, 0, i); |
716 | *elfsz = roundup(*elfsz, PAGE_SIZE); | |
72658e9d VG |
717 | |
718 | /* Modify e_phnum to reflect merged headers. */ | |
719 | ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; | |
720 | ||
721 | return 0; | |
722 | } | |
723 | ||
666bfddb VG |
724 | /* Add memory chunks represented by program headers to vmcore list. Also update |
725 | * the new offset fields of exported program headers. */ | |
726 | static int __init process_ptload_program_headers_elf64(char *elfptr, | |
727 | size_t elfsz, | |
087350c9 | 728 | size_t elfnotes_sz, |
666bfddb VG |
729 | struct list_head *vc_list) |
730 | { | |
731 | int i; | |
732 | Elf64_Ehdr *ehdr_ptr; | |
733 | Elf64_Phdr *phdr_ptr; | |
734 | loff_t vmcore_off; | |
735 | struct vmcore *new; | |
736 | ||
737 | ehdr_ptr = (Elf64_Ehdr *)elfptr; | |
738 | phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr)); /* PT_NOTE hdr */ | |
739 | ||
087350c9 HD |
740 | /* Skip Elf header, program headers and Elf note segment. */ |
741 | vmcore_off = elfsz + elfnotes_sz; | |
666bfddb VG |
742 | |
743 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
7f614cd1 HD |
744 | u64 paddr, start, end, size; |
745 | ||
666bfddb VG |
746 | if (phdr_ptr->p_type != PT_LOAD) |
747 | continue; | |
748 | ||
7f614cd1 HD |
749 | paddr = phdr_ptr->p_offset; |
750 | start = rounddown(paddr, PAGE_SIZE); | |
751 | end = roundup(paddr + phdr_ptr->p_memsz, PAGE_SIZE); | |
752 | size = end - start; | |
753 | ||
666bfddb VG |
754 | /* Add this contiguous chunk of memory to vmcore list.*/ |
755 | new = get_new_element(); | |
756 | if (!new) | |
757 | return -ENOMEM; | |
7f614cd1 HD |
758 | new->paddr = start; |
759 | new->size = size; | |
666bfddb VG |
760 | list_add_tail(&new->list, vc_list); |
761 | ||
762 | /* Update the program header offset. */ | |
7f614cd1 HD |
763 | phdr_ptr->p_offset = vmcore_off + (paddr - start); |
764 | vmcore_off = vmcore_off + size; | |
666bfddb VG |
765 | } |
766 | return 0; | |
767 | } | |
768 | ||
72658e9d VG |
769 | static int __init process_ptload_program_headers_elf32(char *elfptr, |
770 | size_t elfsz, | |
087350c9 | 771 | size_t elfnotes_sz, |
72658e9d VG |
772 | struct list_head *vc_list) |
773 | { | |
774 | int i; | |
775 | Elf32_Ehdr *ehdr_ptr; | |
776 | Elf32_Phdr *phdr_ptr; | |
777 | loff_t vmcore_off; | |
778 | struct vmcore *new; | |
779 | ||
780 | ehdr_ptr = (Elf32_Ehdr *)elfptr; | |
781 | phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr)); /* PT_NOTE hdr */ | |
782 | ||
087350c9 HD |
783 | /* Skip Elf header, program headers and Elf note segment. */ |
784 | vmcore_off = elfsz + elfnotes_sz; | |
72658e9d VG |
785 | |
786 | for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { | |
7f614cd1 HD |
787 | u64 paddr, start, end, size; |
788 | ||
72658e9d VG |
789 | if (phdr_ptr->p_type != PT_LOAD) |
790 | continue; | |
791 | ||
7f614cd1 HD |
792 | paddr = phdr_ptr->p_offset; |
793 | start = rounddown(paddr, PAGE_SIZE); | |
794 | end = roundup(paddr + phdr_ptr->p_memsz, PAGE_SIZE); | |
795 | size = end - start; | |
796 | ||
72658e9d VG |
797 | /* Add this contiguous chunk of memory to vmcore list.*/ |
798 | new = get_new_element(); | |
799 | if (!new) | |
800 | return -ENOMEM; | |
7f614cd1 HD |
801 | new->paddr = start; |
802 | new->size = size; | |
72658e9d VG |
803 | list_add_tail(&new->list, vc_list); |
804 | ||
805 | /* Update the program header offset */ | |
7f614cd1 HD |
806 | phdr_ptr->p_offset = vmcore_off + (paddr - start); |
807 | vmcore_off = vmcore_off + size; | |
72658e9d VG |
808 | } |
809 | return 0; | |
810 | } | |
811 | ||
666bfddb | 812 | /* Sets offset fields of vmcore elements. */ |
087350c9 | 813 | static void __init set_vmcore_list_offsets(size_t elfsz, size_t elfnotes_sz, |
f2bdacdd | 814 | struct list_head *vc_list) |
666bfddb VG |
815 | { |
816 | loff_t vmcore_off; | |
666bfddb VG |
817 | struct vmcore *m; |
818 | ||
087350c9 HD |
819 | /* Skip Elf header, program headers and Elf note segment. */ |
820 | vmcore_off = elfsz + elfnotes_sz; | |
666bfddb VG |
821 | |
822 | list_for_each_entry(m, vc_list, list) { | |
823 | m->offset = vmcore_off; | |
824 | vmcore_off += m->size; | |
825 | } | |
826 | } | |
827 | ||
f2bdacdd | 828 | static void free_elfcorebuf(void) |
72658e9d | 829 | { |
f2bdacdd HD |
830 | free_pages((unsigned long)elfcorebuf, get_order(elfcorebuf_sz_orig)); |
831 | elfcorebuf = NULL; | |
087350c9 HD |
832 | vfree(elfnotes_buf); |
833 | elfnotes_buf = NULL; | |
72658e9d VG |
834 | } |
835 | ||
666bfddb VG |
836 | static int __init parse_crash_elf64_headers(void) |
837 | { | |
838 | int rc=0; | |
839 | Elf64_Ehdr ehdr; | |
840 | u64 addr; | |
841 | ||
842 | addr = elfcorehdr_addr; | |
843 | ||
844 | /* Read Elf header */ | |
be8a8d06 | 845 | rc = elfcorehdr_read((char *)&ehdr, sizeof(Elf64_Ehdr), &addr); |
666bfddb VG |
846 | if (rc < 0) |
847 | return rc; | |
848 | ||
849 | /* Do some basic Verification. */ | |
850 | if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 || | |
851 | (ehdr.e_type != ET_CORE) || | |
9833c394 | 852 | !vmcore_elf64_check_arch(&ehdr) || |
666bfddb VG |
853 | ehdr.e_ident[EI_CLASS] != ELFCLASS64 || |
854 | ehdr.e_ident[EI_VERSION] != EV_CURRENT || | |
855 | ehdr.e_version != EV_CURRENT || | |
856 | ehdr.e_ehsize != sizeof(Elf64_Ehdr) || | |
857 | ehdr.e_phentsize != sizeof(Elf64_Phdr) || | |
858 | ehdr.e_phnum == 0) { | |
87ebdc00 | 859 | pr_warn("Warning: Core image elf header is not sane\n"); |
666bfddb VG |
860 | return -EINVAL; |
861 | } | |
862 | ||
863 | /* Read in all elf headers. */ | |
f2bdacdd HD |
864 | elfcorebuf_sz_orig = sizeof(Elf64_Ehdr) + |
865 | ehdr.e_phnum * sizeof(Elf64_Phdr); | |
866 | elfcorebuf_sz = elfcorebuf_sz_orig; | |
867 | elfcorebuf = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, | |
868 | get_order(elfcorebuf_sz_orig)); | |
666bfddb VG |
869 | if (!elfcorebuf) |
870 | return -ENOMEM; | |
871 | addr = elfcorehdr_addr; | |
be8a8d06 | 872 | rc = elfcorehdr_read(elfcorebuf, elfcorebuf_sz_orig, &addr); |
f2bdacdd HD |
873 | if (rc < 0) |
874 | goto fail; | |
666bfddb VG |
875 | |
876 | /* Merge all PT_NOTE headers into one. */ | |
087350c9 HD |
877 | rc = merge_note_headers_elf64(elfcorebuf, &elfcorebuf_sz, |
878 | &elfnotes_buf, &elfnotes_sz); | |
f2bdacdd HD |
879 | if (rc) |
880 | goto fail; | |
666bfddb | 881 | rc = process_ptload_program_headers_elf64(elfcorebuf, elfcorebuf_sz, |
087350c9 | 882 | elfnotes_sz, &vmcore_list); |
f2bdacdd HD |
883 | if (rc) |
884 | goto fail; | |
087350c9 | 885 | set_vmcore_list_offsets(elfcorebuf_sz, elfnotes_sz, &vmcore_list); |
666bfddb | 886 | return 0; |
f2bdacdd HD |
887 | fail: |
888 | free_elfcorebuf(); | |
889 | return rc; | |
666bfddb VG |
890 | } |
891 | ||
72658e9d VG |
892 | static int __init parse_crash_elf32_headers(void) |
893 | { | |
894 | int rc=0; | |
895 | Elf32_Ehdr ehdr; | |
896 | u64 addr; | |
897 | ||
898 | addr = elfcorehdr_addr; | |
899 | ||
900 | /* Read Elf header */ | |
be8a8d06 | 901 | rc = elfcorehdr_read((char *)&ehdr, sizeof(Elf32_Ehdr), &addr); |
72658e9d VG |
902 | if (rc < 0) |
903 | return rc; | |
904 | ||
905 | /* Do some basic Verification. */ | |
906 | if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 || | |
907 | (ehdr.e_type != ET_CORE) || | |
908 | !elf_check_arch(&ehdr) || | |
909 | ehdr.e_ident[EI_CLASS] != ELFCLASS32|| | |
910 | ehdr.e_ident[EI_VERSION] != EV_CURRENT || | |
911 | ehdr.e_version != EV_CURRENT || | |
912 | ehdr.e_ehsize != sizeof(Elf32_Ehdr) || | |
913 | ehdr.e_phentsize != sizeof(Elf32_Phdr) || | |
914 | ehdr.e_phnum == 0) { | |
87ebdc00 | 915 | pr_warn("Warning: Core image elf header is not sane\n"); |
72658e9d VG |
916 | return -EINVAL; |
917 | } | |
918 | ||
919 | /* Read in all elf headers. */ | |
f2bdacdd HD |
920 | elfcorebuf_sz_orig = sizeof(Elf32_Ehdr) + ehdr.e_phnum * sizeof(Elf32_Phdr); |
921 | elfcorebuf_sz = elfcorebuf_sz_orig; | |
922 | elfcorebuf = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, | |
923 | get_order(elfcorebuf_sz_orig)); | |
72658e9d VG |
924 | if (!elfcorebuf) |
925 | return -ENOMEM; | |
926 | addr = elfcorehdr_addr; | |
be8a8d06 | 927 | rc = elfcorehdr_read(elfcorebuf, elfcorebuf_sz_orig, &addr); |
f2bdacdd HD |
928 | if (rc < 0) |
929 | goto fail; | |
72658e9d VG |
930 | |
931 | /* Merge all PT_NOTE headers into one. */ | |
087350c9 HD |
932 | rc = merge_note_headers_elf32(elfcorebuf, &elfcorebuf_sz, |
933 | &elfnotes_buf, &elfnotes_sz); | |
f2bdacdd HD |
934 | if (rc) |
935 | goto fail; | |
72658e9d | 936 | rc = process_ptload_program_headers_elf32(elfcorebuf, elfcorebuf_sz, |
087350c9 | 937 | elfnotes_sz, &vmcore_list); |
f2bdacdd HD |
938 | if (rc) |
939 | goto fail; | |
087350c9 | 940 | set_vmcore_list_offsets(elfcorebuf_sz, elfnotes_sz, &vmcore_list); |
72658e9d | 941 | return 0; |
f2bdacdd HD |
942 | fail: |
943 | free_elfcorebuf(); | |
944 | return rc; | |
72658e9d VG |
945 | } |
946 | ||
666bfddb VG |
947 | static int __init parse_crash_elf_headers(void) |
948 | { | |
949 | unsigned char e_ident[EI_NIDENT]; | |
950 | u64 addr; | |
951 | int rc=0; | |
952 | ||
953 | addr = elfcorehdr_addr; | |
be8a8d06 | 954 | rc = elfcorehdr_read(e_ident, EI_NIDENT, &addr); |
666bfddb VG |
955 | if (rc < 0) |
956 | return rc; | |
957 | if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) { | |
87ebdc00 | 958 | pr_warn("Warning: Core image elf header not found\n"); |
666bfddb VG |
959 | return -EINVAL; |
960 | } | |
961 | ||
962 | if (e_ident[EI_CLASS] == ELFCLASS64) { | |
963 | rc = parse_crash_elf64_headers(); | |
964 | if (rc) | |
965 | return rc; | |
72658e9d VG |
966 | } else if (e_ident[EI_CLASS] == ELFCLASS32) { |
967 | rc = parse_crash_elf32_headers(); | |
968 | if (rc) | |
969 | return rc; | |
666bfddb | 970 | } else { |
87ebdc00 | 971 | pr_warn("Warning: Core image elf header is not sane\n"); |
666bfddb VG |
972 | return -EINVAL; |
973 | } | |
591ff716 HD |
974 | |
975 | /* Determine vmcore size. */ | |
976 | vmcore_size = get_vmcore_size(elfcorebuf_sz, elfnotes_sz, | |
977 | &vmcore_list); | |
978 | ||
666bfddb VG |
979 | return 0; |
980 | } | |
981 | ||
982 | /* Init function for vmcore module. */ | |
983 | static int __init vmcore_init(void) | |
984 | { | |
985 | int rc = 0; | |
986 | ||
be8a8d06 MH |
987 | /* Allow architectures to allocate ELF header in 2nd kernel */ |
988 | rc = elfcorehdr_alloc(&elfcorehdr_addr, &elfcorehdr_size); | |
989 | if (rc) | |
990 | return rc; | |
991 | /* | |
992 | * If elfcorehdr= has been passed in cmdline or created in 2nd kernel, | |
993 | * then capture the dump. | |
994 | */ | |
85a0ee34 | 995 | if (!(is_vmcore_usable())) |
666bfddb VG |
996 | return rc; |
997 | rc = parse_crash_elf_headers(); | |
998 | if (rc) { | |
87ebdc00 | 999 | pr_warn("Kdump: vmcore not initialized\n"); |
666bfddb VG |
1000 | return rc; |
1001 | } | |
be8a8d06 MH |
1002 | elfcorehdr_free(elfcorehdr_addr); |
1003 | elfcorehdr_addr = ELFCORE_ADDR_ERR; | |
666bfddb | 1004 | |
5aa140c2 | 1005 | proc_vmcore = proc_create("vmcore", S_IRUSR, NULL, &proc_vmcore_operations); |
666bfddb VG |
1006 | if (proc_vmcore) |
1007 | proc_vmcore->size = vmcore_size; | |
1008 | return 0; | |
1009 | } | |
1010 | module_init(vmcore_init) | |
16257393 MS |
1011 | |
1012 | /* Cleanup function for vmcore module. */ | |
1013 | void vmcore_cleanup(void) | |
1014 | { | |
1015 | struct list_head *pos, *next; | |
1016 | ||
1017 | if (proc_vmcore) { | |
a8ca16ea | 1018 | proc_remove(proc_vmcore); |
16257393 MS |
1019 | proc_vmcore = NULL; |
1020 | } | |
1021 | ||
1022 | /* clear the vmcore list. */ | |
1023 | list_for_each_safe(pos, next, &vmcore_list) { | |
1024 | struct vmcore *m; | |
1025 | ||
1026 | m = list_entry(pos, struct vmcore, list); | |
1027 | list_del(&m->list); | |
1028 | kfree(m); | |
1029 | } | |
f2bdacdd | 1030 | free_elfcorebuf(); |
16257393 MS |
1031 | } |
1032 | EXPORT_SYMBOL_GPL(vmcore_cleanup); |