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 10#include <linux/mm.h> 11#include <linux/proc_fs.h> 12#include <linux/user.h> 13#include <linux/a.out.h> 14#include <linux/elf.h> 15#include <linux/elfcore.h> 16#include <linux/highmem.h> 17#include <linux/bootmem.h> 18#include <linux/init.h> 19#include <linux/crash_dump.h> 20#include <linux/list.h> 21#include <asm/uaccess.h> 22#include <asm/io.h> 23 24/* List representing chunks of contiguous memory areas and their offsets in 25 * vmcore file. 26 */ 27static LIST_HEAD(vmcore_list); 28 29/* Stores the pointer to the buffer containing kernel elf core headers. */ 30static char *elfcorebuf; 31static size_t elfcorebuf_sz; 32 33/* Total size of vmcore file. */ 34static u64 vmcore_size; 35 36/* Stores the physical address of elf header of crash image. */ 37unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX; 38 39struct proc_dir_entry *proc_vmcore = NULL; 40 41/* Reads a page from the oldmem device from given offset. */ 42static ssize_t read_from_oldmem(char *buf, size_t count, 43 u64 *ppos, int userbuf) 44{ 45 unsigned long pfn, offset; 46 size_t nr_bytes; 47 ssize_t read = 0, tmp; 48 49 if (!count) 50 return 0; 51 52 offset = (unsigned long)(*ppos % PAGE_SIZE); 53 pfn = (unsigned long)(*ppos / PAGE_SIZE); 54 if (pfn > saved_max_pfn) 55 return -EINVAL; 56 57 do { 58 if (count > (PAGE_SIZE - offset)) 59 nr_bytes = PAGE_SIZE - offset; 60 else 61 nr_bytes = count; 62 63 tmp = copy_oldmem_page(pfn, buf, nr_bytes, offset, userbuf); 64 if (tmp < 0) 65 return tmp; 66 *ppos += nr_bytes; 67 count -= nr_bytes; 68 buf += nr_bytes; 69 read += nr_bytes; 70 ++pfn; 71 offset = 0; 72 } while (count); 73 74 return read; 75} 76 77/* Maps vmcore file offset to respective physical address in memroy. */ 78static u64 map_offset_to_paddr(loff_t offset, struct list_head *vc_list, 79 struct vmcore **m_ptr) 80{ 81 struct vmcore *m; 82 u64 paddr; 83 84 list_for_each_entry(m, vc_list, list) { 85 u64 start, end; 86 start = m->offset; 87 end = m->offset + m->size - 1; 88 if (offset >= start && offset <= end) { 89 paddr = m->paddr + offset - start; 90 *m_ptr = m; 91 return paddr; 92 } 93 } 94 *m_ptr = NULL; 95 return 0; 96} 97 98/* Read from the ELF header and then the crash dump. On error, negative value is 99 * returned otherwise number of bytes read are returned. 100 */ 101static ssize_t read_vmcore(struct file *file, char __user *buffer, 102 size_t buflen, loff_t *fpos) 103{ 104 ssize_t acc = 0, tmp; 105 size_t tsz; 106 u64 start, nr_bytes; 107 struct vmcore *curr_m = NULL; 108 109 if (buflen == 0 || *fpos >= vmcore_size) 110 return 0; 111 112 /* trim buflen to not go beyond EOF */ 113 if (buflen > vmcore_size - *fpos) 114 buflen = vmcore_size - *fpos; 115 116 /* Read ELF core header */ 117 if (*fpos < elfcorebuf_sz) { 118 tsz = elfcorebuf_sz - *fpos; 119 if (buflen < tsz) 120 tsz = buflen; 121 if (copy_to_user(buffer, elfcorebuf + *fpos, tsz)) 122 return -EFAULT; 123 buflen -= tsz; 124 *fpos += tsz; 125 buffer += tsz; 126 acc += tsz; 127 128 /* leave now if filled buffer already */ 129 if (buflen == 0) 130 return acc; 131 } 132 133 start = map_offset_to_paddr(*fpos, &vmcore_list, &curr_m); 134 if (!curr_m) 135 return -EINVAL; 136 if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen) 137 tsz = buflen; 138 139 /* Calculate left bytes in current memory segment. */ 140 nr_bytes = (curr_m->size - (start - curr_m->paddr)); 141 if (tsz > nr_bytes) 142 tsz = nr_bytes; 143 144 while (buflen) { 145 tmp = read_from_oldmem(buffer, tsz, &start, 1); 146 if (tmp < 0) 147 return tmp; 148 buflen -= tsz; 149 *fpos += tsz; 150 buffer += tsz; 151 acc += tsz; 152 if (start >= (curr_m->paddr + curr_m->size)) { 153 if (curr_m->list.next == &vmcore_list) 154 return acc; /*EOF*/ 155 curr_m = list_entry(curr_m->list.next, 156 struct vmcore, list); 157 start = curr_m->paddr; 158 } 159 if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen) 160 tsz = buflen; 161 /* Calculate left bytes in current memory segment. */ 162 nr_bytes = (curr_m->size - (start - curr_m->paddr)); 163 if (tsz > nr_bytes) 164 tsz = nr_bytes; 165 } 166 return acc; 167} 168 169static int open_vmcore(struct inode *inode, struct file *filp) 170{ 171 return 0; 172} 173 174const struct file_operations proc_vmcore_operations = { 175 .read = read_vmcore, 176 .open = open_vmcore, 177}; 178 179static struct vmcore* __init get_new_element(void) 180{ 181 struct vmcore *p; 182 183 p = kmalloc(sizeof(*p), GFP_KERNEL); 184 if (p) 185 memset(p, 0, sizeof(*p)); 186 return p; 187} 188 189static u64 __init get_vmcore_size_elf64(char *elfptr) 190{ 191 int i; 192 u64 size; 193 Elf64_Ehdr *ehdr_ptr; 194 Elf64_Phdr *phdr_ptr; 195 196 ehdr_ptr = (Elf64_Ehdr *)elfptr; 197 phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr)); 198 size = sizeof(Elf64_Ehdr) + ((ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr)); 199 for (i = 0; i < ehdr_ptr->e_phnum; i++) { 200 size += phdr_ptr->p_memsz; 201 phdr_ptr++; 202 } 203 return size; 204} 205 206static u64 __init get_vmcore_size_elf32(char *elfptr) 207{ 208 int i; 209 u64 size; 210 Elf32_Ehdr *ehdr_ptr; 211 Elf32_Phdr *phdr_ptr; 212 213 ehdr_ptr = (Elf32_Ehdr *)elfptr; 214 phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr)); 215 size = sizeof(Elf32_Ehdr) + ((ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr)); 216 for (i = 0; i < ehdr_ptr->e_phnum; i++) { 217 size += phdr_ptr->p_memsz; 218 phdr_ptr++; 219 } 220 return size; 221} 222 223/* Merges all the PT_NOTE headers into one. */ 224static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, 225 struct list_head *vc_list) 226{ 227 int i, nr_ptnote=0, rc=0; 228 char *tmp; 229 Elf64_Ehdr *ehdr_ptr; 230 Elf64_Phdr phdr, *phdr_ptr; 231 Elf64_Nhdr *nhdr_ptr; 232 u64 phdr_sz = 0, note_off; 233 234 ehdr_ptr = (Elf64_Ehdr *)elfptr; 235 phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr)); 236 for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { 237 int j; 238 void *notes_section; 239 struct vmcore *new; 240 u64 offset, max_sz, sz, real_sz = 0; 241 if (phdr_ptr->p_type != PT_NOTE) 242 continue; 243 nr_ptnote++; 244 max_sz = phdr_ptr->p_memsz; 245 offset = phdr_ptr->p_offset; 246 notes_section = kmalloc(max_sz, GFP_KERNEL); 247 if (!notes_section) 248 return -ENOMEM; 249 rc = read_from_oldmem(notes_section, max_sz, &offset, 0); 250 if (rc < 0) { 251 kfree(notes_section); 252 return rc; 253 } 254 nhdr_ptr = notes_section; 255 for (j = 0; j < max_sz; j += sz) { 256 if (nhdr_ptr->n_namesz == 0) 257 break; 258 sz = sizeof(Elf64_Nhdr) + 259 ((nhdr_ptr->n_namesz + 3) & ~3) + 260 ((nhdr_ptr->n_descsz + 3) & ~3); 261 real_sz += sz; 262 nhdr_ptr = (Elf64_Nhdr*)((char*)nhdr_ptr + sz); 263 } 264 265 /* Add this contiguous chunk of notes section to vmcore list.*/ 266 new = get_new_element(); 267 if (!new) { 268 kfree(notes_section); 269 return -ENOMEM; 270 } 271 new->paddr = phdr_ptr->p_offset; 272 new->size = real_sz; 273 list_add_tail(&new->list, vc_list); 274 phdr_sz += real_sz; 275 kfree(notes_section); 276 } 277 278 /* Prepare merged PT_NOTE program header. */ 279 phdr.p_type = PT_NOTE; 280 phdr.p_flags = 0; 281 note_off = sizeof(Elf64_Ehdr) + 282 (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf64_Phdr); 283 phdr.p_offset = note_off; 284 phdr.p_vaddr = phdr.p_paddr = 0; 285 phdr.p_filesz = phdr.p_memsz = phdr_sz; 286 phdr.p_align = 0; 287 288 /* Add merged PT_NOTE program header*/ 289 tmp = elfptr + sizeof(Elf64_Ehdr); 290 memcpy(tmp, &phdr, sizeof(phdr)); 291 tmp += sizeof(phdr); 292 293 /* Remove unwanted PT_NOTE program headers. */ 294 i = (nr_ptnote - 1) * sizeof(Elf64_Phdr); 295 *elfsz = *elfsz - i; 296 memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf64_Ehdr)-sizeof(Elf64_Phdr))); 297 298 /* Modify e_phnum to reflect merged headers. */ 299 ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; 300 301 return 0; 302} 303 304/* Merges all the PT_NOTE headers into one. */ 305static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz, 306 struct list_head *vc_list) 307{ 308 int i, nr_ptnote=0, rc=0; 309 char *tmp; 310 Elf32_Ehdr *ehdr_ptr; 311 Elf32_Phdr phdr, *phdr_ptr; 312 Elf32_Nhdr *nhdr_ptr; 313 u64 phdr_sz = 0, note_off; 314 315 ehdr_ptr = (Elf32_Ehdr *)elfptr; 316 phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr)); 317 for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { 318 int j; 319 void *notes_section; 320 struct vmcore *new; 321 u64 offset, max_sz, sz, real_sz = 0; 322 if (phdr_ptr->p_type != PT_NOTE) 323 continue; 324 nr_ptnote++; 325 max_sz = phdr_ptr->p_memsz; 326 offset = phdr_ptr->p_offset; 327 notes_section = kmalloc(max_sz, GFP_KERNEL); 328 if (!notes_section) 329 return -ENOMEM; 330 rc = read_from_oldmem(notes_section, max_sz, &offset, 0); 331 if (rc < 0) { 332 kfree(notes_section); 333 return rc; 334 } 335 nhdr_ptr = notes_section; 336 for (j = 0; j < max_sz; j += sz) { 337 if (nhdr_ptr->n_namesz == 0) 338 break; 339 sz = sizeof(Elf32_Nhdr) + 340 ((nhdr_ptr->n_namesz + 3) & ~3) + 341 ((nhdr_ptr->n_descsz + 3) & ~3); 342 real_sz += sz; 343 nhdr_ptr = (Elf32_Nhdr*)((char*)nhdr_ptr + sz); 344 } 345 346 /* Add this contiguous chunk of notes section to vmcore list.*/ 347 new = get_new_element(); 348 if (!new) { 349 kfree(notes_section); 350 return -ENOMEM; 351 } 352 new->paddr = phdr_ptr->p_offset; 353 new->size = real_sz; 354 list_add_tail(&new->list, vc_list); 355 phdr_sz += real_sz; 356 kfree(notes_section); 357 } 358 359 /* Prepare merged PT_NOTE program header. */ 360 phdr.p_type = PT_NOTE; 361 phdr.p_flags = 0; 362 note_off = sizeof(Elf32_Ehdr) + 363 (ehdr_ptr->e_phnum - nr_ptnote +1) * sizeof(Elf32_Phdr); 364 phdr.p_offset = note_off; 365 phdr.p_vaddr = phdr.p_paddr = 0; 366 phdr.p_filesz = phdr.p_memsz = phdr_sz; 367 phdr.p_align = 0; 368 369 /* Add merged PT_NOTE program header*/ 370 tmp = elfptr + sizeof(Elf32_Ehdr); 371 memcpy(tmp, &phdr, sizeof(phdr)); 372 tmp += sizeof(phdr); 373 374 /* Remove unwanted PT_NOTE program headers. */ 375 i = (nr_ptnote - 1) * sizeof(Elf32_Phdr); 376 *elfsz = *elfsz - i; 377 memmove(tmp, tmp+i, ((*elfsz)-sizeof(Elf32_Ehdr)-sizeof(Elf32_Phdr))); 378 379 /* Modify e_phnum to reflect merged headers. */ 380 ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; 381 382 return 0; 383} 384 385/* Add memory chunks represented by program headers to vmcore list. Also update 386 * the new offset fields of exported program headers. */ 387static int __init process_ptload_program_headers_elf64(char *elfptr, 388 size_t elfsz, 389 struct list_head *vc_list) 390{ 391 int i; 392 Elf64_Ehdr *ehdr_ptr; 393 Elf64_Phdr *phdr_ptr; 394 loff_t vmcore_off; 395 struct vmcore *new; 396 397 ehdr_ptr = (Elf64_Ehdr *)elfptr; 398 phdr_ptr = (Elf64_Phdr*)(elfptr + sizeof(Elf64_Ehdr)); /* PT_NOTE hdr */ 399 400 /* First program header is PT_NOTE header. */ 401 vmcore_off = sizeof(Elf64_Ehdr) + 402 (ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr) + 403 phdr_ptr->p_memsz; /* Note sections */ 404 405 for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { 406 if (phdr_ptr->p_type != PT_LOAD) 407 continue; 408 409 /* Add this contiguous chunk of memory to vmcore list.*/ 410 new = get_new_element(); 411 if (!new) 412 return -ENOMEM; 413 new->paddr = phdr_ptr->p_offset; 414 new->size = phdr_ptr->p_memsz; 415 list_add_tail(&new->list, vc_list); 416 417 /* Update the program header offset. */ 418 phdr_ptr->p_offset = vmcore_off; 419 vmcore_off = vmcore_off + phdr_ptr->p_memsz; 420 } 421 return 0; 422} 423 424static int __init process_ptload_program_headers_elf32(char *elfptr, 425 size_t elfsz, 426 struct list_head *vc_list) 427{ 428 int i; 429 Elf32_Ehdr *ehdr_ptr; 430 Elf32_Phdr *phdr_ptr; 431 loff_t vmcore_off; 432 struct vmcore *new; 433 434 ehdr_ptr = (Elf32_Ehdr *)elfptr; 435 phdr_ptr = (Elf32_Phdr*)(elfptr + sizeof(Elf32_Ehdr)); /* PT_NOTE hdr */ 436 437 /* First program header is PT_NOTE header. */ 438 vmcore_off = sizeof(Elf32_Ehdr) + 439 (ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr) + 440 phdr_ptr->p_memsz; /* Note sections */ 441 442 for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { 443 if (phdr_ptr->p_type != PT_LOAD) 444 continue; 445 446 /* Add this contiguous chunk of memory to vmcore list.*/ 447 new = get_new_element(); 448 if (!new) 449 return -ENOMEM; 450 new->paddr = phdr_ptr->p_offset; 451 new->size = phdr_ptr->p_memsz; 452 list_add_tail(&new->list, vc_list); 453 454 /* Update the program header offset */ 455 phdr_ptr->p_offset = vmcore_off; 456 vmcore_off = vmcore_off + phdr_ptr->p_memsz; 457 } 458 return 0; 459} 460 461/* Sets offset fields of vmcore elements. */ 462static void __init set_vmcore_list_offsets_elf64(char *elfptr, 463 struct list_head *vc_list) 464{ 465 loff_t vmcore_off; 466 Elf64_Ehdr *ehdr_ptr; 467 struct vmcore *m; 468 469 ehdr_ptr = (Elf64_Ehdr *)elfptr; 470 471 /* Skip Elf header and program headers. */ 472 vmcore_off = sizeof(Elf64_Ehdr) + 473 (ehdr_ptr->e_phnum) * sizeof(Elf64_Phdr); 474 475 list_for_each_entry(m, vc_list, list) { 476 m->offset = vmcore_off; 477 vmcore_off += m->size; 478 } 479} 480 481/* Sets offset fields of vmcore elements. */ 482static void __init set_vmcore_list_offsets_elf32(char *elfptr, 483 struct list_head *vc_list) 484{ 485 loff_t vmcore_off; 486 Elf32_Ehdr *ehdr_ptr; 487 struct vmcore *m; 488 489 ehdr_ptr = (Elf32_Ehdr *)elfptr; 490 491 /* Skip Elf header and program headers. */ 492 vmcore_off = sizeof(Elf32_Ehdr) + 493 (ehdr_ptr->e_phnum) * sizeof(Elf32_Phdr); 494 495 list_for_each_entry(m, vc_list, list) { 496 m->offset = vmcore_off; 497 vmcore_off += m->size; 498 } 499} 500 501static int __init parse_crash_elf64_headers(void) 502{ 503 int rc=0; 504 Elf64_Ehdr ehdr; 505 u64 addr; 506 507 addr = elfcorehdr_addr; 508 509 /* Read Elf header */ 510 rc = read_from_oldmem((char*)&ehdr, sizeof(Elf64_Ehdr), &addr, 0); 511 if (rc < 0) 512 return rc; 513 514 /* Do some basic Verification. */ 515 if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 || 516 (ehdr.e_type != ET_CORE) || 517 !vmcore_elf_check_arch(&ehdr) || 518 ehdr.e_ident[EI_CLASS] != ELFCLASS64 || 519 ehdr.e_ident[EI_VERSION] != EV_CURRENT || 520 ehdr.e_version != EV_CURRENT || 521 ehdr.e_ehsize != sizeof(Elf64_Ehdr) || 522 ehdr.e_phentsize != sizeof(Elf64_Phdr) || 523 ehdr.e_phnum == 0) { 524 printk(KERN_WARNING "Warning: Core image elf header is not" 525 "sane\n"); 526 return -EINVAL; 527 } 528 529 /* Read in all elf headers. */ 530 elfcorebuf_sz = sizeof(Elf64_Ehdr) + ehdr.e_phnum * sizeof(Elf64_Phdr); 531 elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL); 532 if (!elfcorebuf) 533 return -ENOMEM; 534 addr = elfcorehdr_addr; 535 rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz, &addr, 0); 536 if (rc < 0) { 537 kfree(elfcorebuf); 538 return rc; 539 } 540 541 /* Merge all PT_NOTE headers into one. */ 542 rc = merge_note_headers_elf64(elfcorebuf, &elfcorebuf_sz, &vmcore_list); 543 if (rc) { 544 kfree(elfcorebuf); 545 return rc; 546 } 547 rc = process_ptload_program_headers_elf64(elfcorebuf, elfcorebuf_sz, 548 &vmcore_list); 549 if (rc) { 550 kfree(elfcorebuf); 551 return rc; 552 } 553 set_vmcore_list_offsets_elf64(elfcorebuf, &vmcore_list); 554 return 0; 555} 556 557static int __init parse_crash_elf32_headers(void) 558{ 559 int rc=0; 560 Elf32_Ehdr ehdr; 561 u64 addr; 562 563 addr = elfcorehdr_addr; 564 565 /* Read Elf header */ 566 rc = read_from_oldmem((char*)&ehdr, sizeof(Elf32_Ehdr), &addr, 0); 567 if (rc < 0) 568 return rc; 569 570 /* Do some basic Verification. */ 571 if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 || 572 (ehdr.e_type != ET_CORE) || 573 !elf_check_arch(&ehdr) || 574 ehdr.e_ident[EI_CLASS] != ELFCLASS32|| 575 ehdr.e_ident[EI_VERSION] != EV_CURRENT || 576 ehdr.e_version != EV_CURRENT || 577 ehdr.e_ehsize != sizeof(Elf32_Ehdr) || 578 ehdr.e_phentsize != sizeof(Elf32_Phdr) || 579 ehdr.e_phnum == 0) { 580 printk(KERN_WARNING "Warning: Core image elf header is not" 581 "sane\n"); 582 return -EINVAL; 583 } 584 585 /* Read in all elf headers. */ 586 elfcorebuf_sz = sizeof(Elf32_Ehdr) + ehdr.e_phnum * sizeof(Elf32_Phdr); 587 elfcorebuf = kmalloc(elfcorebuf_sz, GFP_KERNEL); 588 if (!elfcorebuf) 589 return -ENOMEM; 590 addr = elfcorehdr_addr; 591 rc = read_from_oldmem(elfcorebuf, elfcorebuf_sz, &addr, 0); 592 if (rc < 0) { 593 kfree(elfcorebuf); 594 return rc; 595 } 596 597 /* Merge all PT_NOTE headers into one. */ 598 rc = merge_note_headers_elf32(elfcorebuf, &elfcorebuf_sz, &vmcore_list); 599 if (rc) { 600 kfree(elfcorebuf); 601 return rc; 602 } 603 rc = process_ptload_program_headers_elf32(elfcorebuf, elfcorebuf_sz, 604 &vmcore_list); 605 if (rc) { 606 kfree(elfcorebuf); 607 return rc; 608 } 609 set_vmcore_list_offsets_elf32(elfcorebuf, &vmcore_list); 610 return 0; 611} 612 613static int __init parse_crash_elf_headers(void) 614{ 615 unsigned char e_ident[EI_NIDENT]; 616 u64 addr; 617 int rc=0; 618 619 addr = elfcorehdr_addr; 620 rc = read_from_oldmem(e_ident, EI_NIDENT, &addr, 0); 621 if (rc < 0) 622 return rc; 623 if (memcmp(e_ident, ELFMAG, SELFMAG) != 0) { 624 printk(KERN_WARNING "Warning: Core image elf header" 625 " not found\n"); 626 return -EINVAL; 627 } 628 629 if (e_ident[EI_CLASS] == ELFCLASS64) { 630 rc = parse_crash_elf64_headers(); 631 if (rc) 632 return rc; 633 634 /* Determine vmcore size. */ 635 vmcore_size = get_vmcore_size_elf64(elfcorebuf); 636 } else if (e_ident[EI_CLASS] == ELFCLASS32) { 637 rc = parse_crash_elf32_headers(); 638 if (rc) 639 return rc; 640 641 /* Determine vmcore size. */ 642 vmcore_size = get_vmcore_size_elf32(elfcorebuf); 643 } else { 644 printk(KERN_WARNING "Warning: Core image elf header is not" 645 " sane\n"); 646 return -EINVAL; 647 } 648 return 0; 649} 650 651/* Init function for vmcore module. */ 652static int __init vmcore_init(void) 653{ 654 int rc = 0; 655 656 /* If elfcorehdr= has been passed in cmdline, then capture the dump.*/ 657 if (!(elfcorehdr_addr < ELFCORE_ADDR_MAX)) 658 return rc; 659 rc = parse_crash_elf_headers(); 660 if (rc) { 661 printk(KERN_WARNING "Kdump: vmcore not initialized\n"); 662 return rc; 663 } 664 665 /* Initialize /proc/vmcore size if proc is already up. */ 666 if (proc_vmcore) 667 proc_vmcore->size = vmcore_size; 668 return 0; 669} 670module_init(vmcore_init) 671