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