1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ppc64 code to implement the kexec_file_load syscall 4 * 5 * Copyright (C) 2004 Adam Litke (agl@us.ibm.com) 6 * Copyright (C) 2004 IBM Corp. 7 * Copyright (C) 2004,2005 Milton D Miller II, IBM Corporation 8 * Copyright (C) 2005 R Sharada (sharada@in.ibm.com) 9 * Copyright (C) 2006 Mohan Kumar M (mohan@in.ibm.com) 10 * Copyright (C) 2020 IBM Corporation 11 * 12 * Based on kexec-tools' kexec-ppc64.c, kexec-elf-rel-ppc64.c, fs2dt.c. 13 * Heavily modified for the kernel by 14 * Hari Bathini, IBM Corporation. 15 */ 16 17 #include <linux/kexec.h> 18 #include <linux/of_fdt.h> 19 #include <linux/libfdt.h> 20 #include <linux/of_device.h> 21 #include <linux/memblock.h> 22 #include <linux/slab.h> 23 #include <linux/vmalloc.h> 24 #include <asm/drmem.h> 25 #include <asm/kexec_ranges.h> 26 #include <asm/crashdump-ppc64.h> 27 28 struct umem_info { 29 u64 *buf; /* data buffer for usable-memory property */ 30 u32 size; /* size allocated for the data buffer */ 31 u32 max_entries; /* maximum no. of entries */ 32 u32 idx; /* index of current entry */ 33 34 /* usable memory ranges to look up */ 35 unsigned int nr_ranges; 36 const struct crash_mem_range *ranges; 37 }; 38 39 const struct kexec_file_ops * const kexec_file_loaders[] = { 40 &kexec_elf64_ops, 41 NULL 42 }; 43 44 /** 45 * get_exclude_memory_ranges - Get exclude memory ranges. This list includes 46 * regions like opal/rtas, tce-table, initrd, 47 * kernel, htab which should be avoided while 48 * setting up kexec load segments. 49 * @mem_ranges: Range list to add the memory ranges to. 50 * 51 * Returns 0 on success, negative errno on error. 52 */ 53 static int get_exclude_memory_ranges(struct crash_mem **mem_ranges) 54 { 55 int ret; 56 57 ret = add_tce_mem_ranges(mem_ranges); 58 if (ret) 59 goto out; 60 61 ret = add_initrd_mem_range(mem_ranges); 62 if (ret) 63 goto out; 64 65 ret = add_htab_mem_range(mem_ranges); 66 if (ret) 67 goto out; 68 69 ret = add_kernel_mem_range(mem_ranges); 70 if (ret) 71 goto out; 72 73 ret = add_rtas_mem_range(mem_ranges); 74 if (ret) 75 goto out; 76 77 ret = add_opal_mem_range(mem_ranges); 78 if (ret) 79 goto out; 80 81 ret = add_reserved_mem_ranges(mem_ranges); 82 if (ret) 83 goto out; 84 85 /* exclude memory ranges should be sorted for easy lookup */ 86 sort_memory_ranges(*mem_ranges, true); 87 out: 88 if (ret) 89 pr_err("Failed to setup exclude memory ranges\n"); 90 return ret; 91 } 92 93 /** 94 * get_usable_memory_ranges - Get usable memory ranges. This list includes 95 * regions like crashkernel, opal/rtas & tce-table, 96 * that kdump kernel could use. 97 * @mem_ranges: Range list to add the memory ranges to. 98 * 99 * Returns 0 on success, negative errno on error. 100 */ 101 static int get_usable_memory_ranges(struct crash_mem **mem_ranges) 102 { 103 int ret; 104 105 /* 106 * Early boot failure observed on guests when low memory (first memory 107 * block?) is not added to usable memory. So, add [0, crashk_res.end] 108 * instead of [crashk_res.start, crashk_res.end] to workaround it. 109 * Also, crashed kernel's memory must be added to reserve map to 110 * avoid kdump kernel from using it. 111 */ 112 ret = add_mem_range(mem_ranges, 0, crashk_res.end + 1); 113 if (ret) 114 goto out; 115 116 ret = add_rtas_mem_range(mem_ranges); 117 if (ret) 118 goto out; 119 120 ret = add_opal_mem_range(mem_ranges); 121 if (ret) 122 goto out; 123 124 ret = add_tce_mem_ranges(mem_ranges); 125 out: 126 if (ret) 127 pr_err("Failed to setup usable memory ranges\n"); 128 return ret; 129 } 130 131 /** 132 * get_crash_memory_ranges - Get crash memory ranges. This list includes 133 * first/crashing kernel's memory regions that 134 * would be exported via an elfcore. 135 * @mem_ranges: Range list to add the memory ranges to. 136 * 137 * Returns 0 on success, negative errno on error. 138 */ 139 static int get_crash_memory_ranges(struct crash_mem **mem_ranges) 140 { 141 struct memblock_region *reg; 142 struct crash_mem *tmem; 143 int ret; 144 145 for_each_memblock(memory, reg) { 146 u64 base, size; 147 148 base = (u64)reg->base; 149 size = (u64)reg->size; 150 151 /* Skip backup memory region, which needs a separate entry */ 152 if (base == BACKUP_SRC_START) { 153 if (size > BACKUP_SRC_SIZE) { 154 base = BACKUP_SRC_END + 1; 155 size -= BACKUP_SRC_SIZE; 156 } else 157 continue; 158 } 159 160 ret = add_mem_range(mem_ranges, base, size); 161 if (ret) 162 goto out; 163 164 /* Try merging adjacent ranges before reallocation attempt */ 165 if ((*mem_ranges)->nr_ranges == (*mem_ranges)->max_nr_ranges) 166 sort_memory_ranges(*mem_ranges, true); 167 } 168 169 /* Reallocate memory ranges if there is no space to split ranges */ 170 tmem = *mem_ranges; 171 if (tmem && (tmem->nr_ranges == tmem->max_nr_ranges)) { 172 tmem = realloc_mem_ranges(mem_ranges); 173 if (!tmem) 174 goto out; 175 } 176 177 /* Exclude crashkernel region */ 178 ret = crash_exclude_mem_range(tmem, crashk_res.start, crashk_res.end); 179 if (ret) 180 goto out; 181 182 /* 183 * FIXME: For now, stay in parity with kexec-tools but if RTAS/OPAL 184 * regions are exported to save their context at the time of 185 * crash, they should actually be backed up just like the 186 * first 64K bytes of memory. 187 */ 188 ret = add_rtas_mem_range(mem_ranges); 189 if (ret) 190 goto out; 191 192 ret = add_opal_mem_range(mem_ranges); 193 if (ret) 194 goto out; 195 196 /* create a separate program header for the backup region */ 197 ret = add_mem_range(mem_ranges, BACKUP_SRC_START, BACKUP_SRC_SIZE); 198 if (ret) 199 goto out; 200 201 sort_memory_ranges(*mem_ranges, false); 202 out: 203 if (ret) 204 pr_err("Failed to setup crash memory ranges\n"); 205 return ret; 206 } 207 208 /** 209 * get_reserved_memory_ranges - Get reserve memory ranges. This list includes 210 * memory regions that should be added to the 211 * memory reserve map to ensure the region is 212 * protected from any mischief. 213 * @mem_ranges: Range list to add the memory ranges to. 214 * 215 * Returns 0 on success, negative errno on error. 216 */ 217 static int get_reserved_memory_ranges(struct crash_mem **mem_ranges) 218 { 219 int ret; 220 221 ret = add_rtas_mem_range(mem_ranges); 222 if (ret) 223 goto out; 224 225 ret = add_tce_mem_ranges(mem_ranges); 226 if (ret) 227 goto out; 228 229 ret = add_reserved_mem_ranges(mem_ranges); 230 out: 231 if (ret) 232 pr_err("Failed to setup reserved memory ranges\n"); 233 return ret; 234 } 235 236 /** 237 * __locate_mem_hole_top_down - Looks top down for a large enough memory hole 238 * in the memory regions between buf_min & buf_max 239 * for the buffer. If found, sets kbuf->mem. 240 * @kbuf: Buffer contents and memory parameters. 241 * @buf_min: Minimum address for the buffer. 242 * @buf_max: Maximum address for the buffer. 243 * 244 * Returns 0 on success, negative errno on error. 245 */ 246 static int __locate_mem_hole_top_down(struct kexec_buf *kbuf, 247 u64 buf_min, u64 buf_max) 248 { 249 int ret = -EADDRNOTAVAIL; 250 phys_addr_t start, end; 251 u64 i; 252 253 for_each_mem_range_rev(i, &memblock.memory, NULL, NUMA_NO_NODE, 254 MEMBLOCK_NONE, &start, &end, NULL) { 255 /* 256 * memblock uses [start, end) convention while it is 257 * [start, end] here. Fix the off-by-one to have the 258 * same convention. 259 */ 260 end -= 1; 261 262 if (start > buf_max) 263 continue; 264 265 /* Memory hole not found */ 266 if (end < buf_min) 267 break; 268 269 /* Adjust memory region based on the given range */ 270 if (start < buf_min) 271 start = buf_min; 272 if (end > buf_max) 273 end = buf_max; 274 275 start = ALIGN(start, kbuf->buf_align); 276 if (start < end && (end - start + 1) >= kbuf->memsz) { 277 /* Suitable memory range found. Set kbuf->mem */ 278 kbuf->mem = ALIGN_DOWN(end - kbuf->memsz + 1, 279 kbuf->buf_align); 280 ret = 0; 281 break; 282 } 283 } 284 285 return ret; 286 } 287 288 /** 289 * locate_mem_hole_top_down_ppc64 - Skip special memory regions to find a 290 * suitable buffer with top down approach. 291 * @kbuf: Buffer contents and memory parameters. 292 * @buf_min: Minimum address for the buffer. 293 * @buf_max: Maximum address for the buffer. 294 * @emem: Exclude memory ranges. 295 * 296 * Returns 0 on success, negative errno on error. 297 */ 298 static int locate_mem_hole_top_down_ppc64(struct kexec_buf *kbuf, 299 u64 buf_min, u64 buf_max, 300 const struct crash_mem *emem) 301 { 302 int i, ret = 0, err = -EADDRNOTAVAIL; 303 u64 start, end, tmin, tmax; 304 305 tmax = buf_max; 306 for (i = (emem->nr_ranges - 1); i >= 0; i--) { 307 start = emem->ranges[i].start; 308 end = emem->ranges[i].end; 309 310 if (start > tmax) 311 continue; 312 313 if (end < tmax) { 314 tmin = (end < buf_min ? buf_min : end + 1); 315 ret = __locate_mem_hole_top_down(kbuf, tmin, tmax); 316 if (!ret) 317 return 0; 318 } 319 320 tmax = start - 1; 321 322 if (tmax < buf_min) { 323 ret = err; 324 break; 325 } 326 ret = 0; 327 } 328 329 if (!ret) { 330 tmin = buf_min; 331 ret = __locate_mem_hole_top_down(kbuf, tmin, tmax); 332 } 333 return ret; 334 } 335 336 /** 337 * __locate_mem_hole_bottom_up - Looks bottom up for a large enough memory hole 338 * in the memory regions between buf_min & buf_max 339 * for the buffer. If found, sets kbuf->mem. 340 * @kbuf: Buffer contents and memory parameters. 341 * @buf_min: Minimum address for the buffer. 342 * @buf_max: Maximum address for the buffer. 343 * 344 * Returns 0 on success, negative errno on error. 345 */ 346 static int __locate_mem_hole_bottom_up(struct kexec_buf *kbuf, 347 u64 buf_min, u64 buf_max) 348 { 349 int ret = -EADDRNOTAVAIL; 350 phys_addr_t start, end; 351 u64 i; 352 353 for_each_mem_range(i, &memblock.memory, NULL, NUMA_NO_NODE, 354 MEMBLOCK_NONE, &start, &end, NULL) { 355 /* 356 * memblock uses [start, end) convention while it is 357 * [start, end] here. Fix the off-by-one to have the 358 * same convention. 359 */ 360 end -= 1; 361 362 if (end < buf_min) 363 continue; 364 365 /* Memory hole not found */ 366 if (start > buf_max) 367 break; 368 369 /* Adjust memory region based on the given range */ 370 if (start < buf_min) 371 start = buf_min; 372 if (end > buf_max) 373 end = buf_max; 374 375 start = ALIGN(start, kbuf->buf_align); 376 if (start < end && (end - start + 1) >= kbuf->memsz) { 377 /* Suitable memory range found. Set kbuf->mem */ 378 kbuf->mem = start; 379 ret = 0; 380 break; 381 } 382 } 383 384 return ret; 385 } 386 387 /** 388 * locate_mem_hole_bottom_up_ppc64 - Skip special memory regions to find a 389 * suitable buffer with bottom up approach. 390 * @kbuf: Buffer contents and memory parameters. 391 * @buf_min: Minimum address for the buffer. 392 * @buf_max: Maximum address for the buffer. 393 * @emem: Exclude memory ranges. 394 * 395 * Returns 0 on success, negative errno on error. 396 */ 397 static int locate_mem_hole_bottom_up_ppc64(struct kexec_buf *kbuf, 398 u64 buf_min, u64 buf_max, 399 const struct crash_mem *emem) 400 { 401 int i, ret = 0, err = -EADDRNOTAVAIL; 402 u64 start, end, tmin, tmax; 403 404 tmin = buf_min; 405 for (i = 0; i < emem->nr_ranges; i++) { 406 start = emem->ranges[i].start; 407 end = emem->ranges[i].end; 408 409 if (end < tmin) 410 continue; 411 412 if (start > tmin) { 413 tmax = (start > buf_max ? buf_max : start - 1); 414 ret = __locate_mem_hole_bottom_up(kbuf, tmin, tmax); 415 if (!ret) 416 return 0; 417 } 418 419 tmin = end + 1; 420 421 if (tmin > buf_max) { 422 ret = err; 423 break; 424 } 425 ret = 0; 426 } 427 428 if (!ret) { 429 tmax = buf_max; 430 ret = __locate_mem_hole_bottom_up(kbuf, tmin, tmax); 431 } 432 return ret; 433 } 434 435 /** 436 * check_realloc_usable_mem - Reallocate buffer if it can't accommodate entries 437 * @um_info: Usable memory buffer and ranges info. 438 * @cnt: No. of entries to accommodate. 439 * 440 * Frees up the old buffer if memory reallocation fails. 441 * 442 * Returns buffer on success, NULL on error. 443 */ 444 static u64 *check_realloc_usable_mem(struct umem_info *um_info, int cnt) 445 { 446 u32 new_size; 447 u64 *tbuf; 448 449 if ((um_info->idx + cnt) <= um_info->max_entries) 450 return um_info->buf; 451 452 new_size = um_info->size + MEM_RANGE_CHUNK_SZ; 453 tbuf = krealloc(um_info->buf, new_size, GFP_KERNEL); 454 if (tbuf) { 455 um_info->buf = tbuf; 456 um_info->size = new_size; 457 um_info->max_entries = (um_info->size / sizeof(u64)); 458 } 459 460 return tbuf; 461 } 462 463 /** 464 * add_usable_mem - Add the usable memory ranges within the given memory range 465 * to the buffer 466 * @um_info: Usable memory buffer and ranges info. 467 * @base: Base address of memory range to look for. 468 * @end: End address of memory range to look for. 469 * 470 * Returns 0 on success, negative errno on error. 471 */ 472 static int add_usable_mem(struct umem_info *um_info, u64 base, u64 end) 473 { 474 u64 loc_base, loc_end; 475 bool add; 476 int i; 477 478 for (i = 0; i < um_info->nr_ranges; i++) { 479 add = false; 480 loc_base = um_info->ranges[i].start; 481 loc_end = um_info->ranges[i].end; 482 if (loc_base >= base && loc_end <= end) 483 add = true; 484 else if (base < loc_end && end > loc_base) { 485 if (loc_base < base) 486 loc_base = base; 487 if (loc_end > end) 488 loc_end = end; 489 add = true; 490 } 491 492 if (add) { 493 if (!check_realloc_usable_mem(um_info, 2)) 494 return -ENOMEM; 495 496 um_info->buf[um_info->idx++] = cpu_to_be64(loc_base); 497 um_info->buf[um_info->idx++] = 498 cpu_to_be64(loc_end - loc_base + 1); 499 } 500 } 501 502 return 0; 503 } 504 505 /** 506 * kdump_setup_usable_lmb - This is a callback function that gets called by 507 * walk_drmem_lmbs for every LMB to set its 508 * usable memory ranges. 509 * @lmb: LMB info. 510 * @usm: linux,drconf-usable-memory property value. 511 * @data: Pointer to usable memory buffer and ranges info. 512 * 513 * Returns 0 on success, negative errno on error. 514 */ 515 static int kdump_setup_usable_lmb(struct drmem_lmb *lmb, const __be32 **usm, 516 void *data) 517 { 518 struct umem_info *um_info; 519 int tmp_idx, ret; 520 u64 base, end; 521 522 /* 523 * kdump load isn't supported on kernels already booted with 524 * linux,drconf-usable-memory property. 525 */ 526 if (*usm) { 527 pr_err("linux,drconf-usable-memory property already exists!"); 528 return -EINVAL; 529 } 530 531 um_info = data; 532 tmp_idx = um_info->idx; 533 if (!check_realloc_usable_mem(um_info, 1)) 534 return -ENOMEM; 535 536 um_info->idx++; 537 base = lmb->base_addr; 538 end = base + drmem_lmb_size() - 1; 539 ret = add_usable_mem(um_info, base, end); 540 if (!ret) { 541 /* 542 * Update the no. of ranges added. Two entries (base & size) 543 * for every range added. 544 */ 545 um_info->buf[tmp_idx] = 546 cpu_to_be64((um_info->idx - tmp_idx - 1) / 2); 547 } 548 549 return ret; 550 } 551 552 #define NODE_PATH_LEN 256 553 /** 554 * add_usable_mem_property - Add usable memory property for the given 555 * memory node. 556 * @fdt: Flattened device tree for the kdump kernel. 557 * @dn: Memory node. 558 * @um_info: Usable memory buffer and ranges info. 559 * 560 * Returns 0 on success, negative errno on error. 561 */ 562 static int add_usable_mem_property(void *fdt, struct device_node *dn, 563 struct umem_info *um_info) 564 { 565 int n_mem_addr_cells, n_mem_size_cells, node; 566 char path[NODE_PATH_LEN]; 567 int i, len, ranges, ret; 568 const __be32 *prop; 569 u64 base, end; 570 571 of_node_get(dn); 572 573 if (snprintf(path, NODE_PATH_LEN, "%pOF", dn) > (NODE_PATH_LEN - 1)) { 574 pr_err("Buffer (%d) too small for memory node: %pOF\n", 575 NODE_PATH_LEN, dn); 576 return -EOVERFLOW; 577 } 578 pr_debug("Memory node path: %s\n", path); 579 580 /* Now that we know the path, find its offset in kdump kernel's fdt */ 581 node = fdt_path_offset(fdt, path); 582 if (node < 0) { 583 pr_err("Malformed device tree: error reading %s\n", path); 584 ret = -EINVAL; 585 goto out; 586 } 587 588 /* Get the address & size cells */ 589 n_mem_addr_cells = of_n_addr_cells(dn); 590 n_mem_size_cells = of_n_size_cells(dn); 591 pr_debug("address cells: %d, size cells: %d\n", n_mem_addr_cells, 592 n_mem_size_cells); 593 594 um_info->idx = 0; 595 if (!check_realloc_usable_mem(um_info, 2)) { 596 ret = -ENOMEM; 597 goto out; 598 } 599 600 prop = of_get_property(dn, "reg", &len); 601 if (!prop || len <= 0) { 602 ret = 0; 603 goto out; 604 } 605 606 /* 607 * "reg" property represents sequence of (addr,size) tuples 608 * each representing a memory range. 609 */ 610 ranges = (len >> 2) / (n_mem_addr_cells + n_mem_size_cells); 611 612 for (i = 0; i < ranges; i++) { 613 base = of_read_number(prop, n_mem_addr_cells); 614 prop += n_mem_addr_cells; 615 end = base + of_read_number(prop, n_mem_size_cells) - 1; 616 prop += n_mem_size_cells; 617 618 ret = add_usable_mem(um_info, base, end); 619 if (ret) 620 goto out; 621 } 622 623 /* 624 * No kdump kernel usable memory found in this memory node. 625 * Write (0,0) tuple in linux,usable-memory property for 626 * this region to be ignored. 627 */ 628 if (um_info->idx == 0) { 629 um_info->buf[0] = 0; 630 um_info->buf[1] = 0; 631 um_info->idx = 2; 632 } 633 634 ret = fdt_setprop(fdt, node, "linux,usable-memory", um_info->buf, 635 (um_info->idx * sizeof(u64))); 636 637 out: 638 of_node_put(dn); 639 return ret; 640 } 641 642 643 /** 644 * update_usable_mem_fdt - Updates kdump kernel's fdt with linux,usable-memory 645 * and linux,drconf-usable-memory DT properties as 646 * appropriate to restrict its memory usage. 647 * @fdt: Flattened device tree for the kdump kernel. 648 * @usable_mem: Usable memory ranges for kdump kernel. 649 * 650 * Returns 0 on success, negative errno on error. 651 */ 652 static int update_usable_mem_fdt(void *fdt, struct crash_mem *usable_mem) 653 { 654 struct umem_info um_info; 655 struct device_node *dn; 656 int node, ret = 0; 657 658 if (!usable_mem) { 659 pr_err("Usable memory ranges for kdump kernel not found\n"); 660 return -ENOENT; 661 } 662 663 node = fdt_path_offset(fdt, "/ibm,dynamic-reconfiguration-memory"); 664 if (node == -FDT_ERR_NOTFOUND) 665 pr_debug("No dynamic reconfiguration memory found\n"); 666 else if (node < 0) { 667 pr_err("Malformed device tree: error reading /ibm,dynamic-reconfiguration-memory.\n"); 668 return -EINVAL; 669 } 670 671 um_info.buf = NULL; 672 um_info.size = 0; 673 um_info.max_entries = 0; 674 um_info.idx = 0; 675 /* Memory ranges to look up */ 676 um_info.ranges = &(usable_mem->ranges[0]); 677 um_info.nr_ranges = usable_mem->nr_ranges; 678 679 dn = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory"); 680 if (dn) { 681 ret = walk_drmem_lmbs(dn, &um_info, kdump_setup_usable_lmb); 682 of_node_put(dn); 683 684 if (ret) { 685 pr_err("Could not setup linux,drconf-usable-memory property for kdump\n"); 686 goto out; 687 } 688 689 ret = fdt_setprop(fdt, node, "linux,drconf-usable-memory", 690 um_info.buf, (um_info.idx * sizeof(u64))); 691 if (ret) { 692 pr_err("Failed to update fdt with linux,drconf-usable-memory property"); 693 goto out; 694 } 695 } 696 697 /* 698 * Walk through each memory node and set linux,usable-memory property 699 * for the corresponding node in kdump kernel's fdt. 700 */ 701 for_each_node_by_type(dn, "memory") { 702 ret = add_usable_mem_property(fdt, dn, &um_info); 703 if (ret) { 704 pr_err("Failed to set linux,usable-memory property for %s node", 705 dn->full_name); 706 goto out; 707 } 708 } 709 710 out: 711 kfree(um_info.buf); 712 return ret; 713 } 714 715 /** 716 * load_backup_segment - Locate a memory hole to place the backup region. 717 * @image: Kexec image. 718 * @kbuf: Buffer contents and memory parameters. 719 * 720 * Returns 0 on success, negative errno on error. 721 */ 722 static int load_backup_segment(struct kimage *image, struct kexec_buf *kbuf) 723 { 724 void *buf; 725 int ret; 726 727 /* 728 * Setup a source buffer for backup segment. 729 * 730 * A source buffer has no meaning for backup region as data will 731 * be copied from backup source, after crash, in the purgatory. 732 * But as load segment code doesn't recognize such segments, 733 * setup a dummy source buffer to keep it happy for now. 734 */ 735 buf = vzalloc(BACKUP_SRC_SIZE); 736 if (!buf) 737 return -ENOMEM; 738 739 kbuf->buffer = buf; 740 kbuf->mem = KEXEC_BUF_MEM_UNKNOWN; 741 kbuf->bufsz = kbuf->memsz = BACKUP_SRC_SIZE; 742 kbuf->top_down = false; 743 744 ret = kexec_add_buffer(kbuf); 745 if (ret) { 746 vfree(buf); 747 return ret; 748 } 749 750 image->arch.backup_buf = buf; 751 image->arch.backup_start = kbuf->mem; 752 return 0; 753 } 754 755 /** 756 * update_backup_region_phdr - Update backup region's offset for the core to 757 * export the region appropriately. 758 * @image: Kexec image. 759 * @ehdr: ELF core header. 760 * 761 * Assumes an exclusive program header is setup for the backup region 762 * in the ELF headers 763 * 764 * Returns nothing. 765 */ 766 static void update_backup_region_phdr(struct kimage *image, Elf64_Ehdr *ehdr) 767 { 768 Elf64_Phdr *phdr; 769 unsigned int i; 770 771 phdr = (Elf64_Phdr *)(ehdr + 1); 772 for (i = 0; i < ehdr->e_phnum; i++) { 773 if (phdr->p_paddr == BACKUP_SRC_START) { 774 phdr->p_offset = image->arch.backup_start; 775 pr_debug("Backup region offset updated to 0x%lx\n", 776 image->arch.backup_start); 777 return; 778 } 779 } 780 } 781 782 /** 783 * load_elfcorehdr_segment - Setup crash memory ranges and initialize elfcorehdr 784 * segment needed to load kdump kernel. 785 * @image: Kexec image. 786 * @kbuf: Buffer contents and memory parameters. 787 * 788 * Returns 0 on success, negative errno on error. 789 */ 790 static int load_elfcorehdr_segment(struct kimage *image, struct kexec_buf *kbuf) 791 { 792 struct crash_mem *cmem = NULL; 793 unsigned long headers_sz; 794 void *headers = NULL; 795 int ret; 796 797 ret = get_crash_memory_ranges(&cmem); 798 if (ret) 799 goto out; 800 801 /* Setup elfcorehdr segment */ 802 ret = crash_prepare_elf64_headers(cmem, false, &headers, &headers_sz); 803 if (ret) { 804 pr_err("Failed to prepare elf headers for the core\n"); 805 goto out; 806 } 807 808 /* Fix the offset for backup region in the ELF header */ 809 update_backup_region_phdr(image, headers); 810 811 kbuf->buffer = headers; 812 kbuf->mem = KEXEC_BUF_MEM_UNKNOWN; 813 kbuf->bufsz = kbuf->memsz = headers_sz; 814 kbuf->top_down = false; 815 816 ret = kexec_add_buffer(kbuf); 817 if (ret) { 818 vfree(headers); 819 goto out; 820 } 821 822 image->arch.elfcorehdr_addr = kbuf->mem; 823 image->arch.elf_headers_sz = headers_sz; 824 image->arch.elf_headers = headers; 825 out: 826 kfree(cmem); 827 return ret; 828 } 829 830 /** 831 * load_crashdump_segments_ppc64 - Initialize the additional segements needed 832 * to load kdump kernel. 833 * @image: Kexec image. 834 * @kbuf: Buffer contents and memory parameters. 835 * 836 * Returns 0 on success, negative errno on error. 837 */ 838 int load_crashdump_segments_ppc64(struct kimage *image, 839 struct kexec_buf *kbuf) 840 { 841 int ret; 842 843 /* Load backup segment - first 64K bytes of the crashing kernel */ 844 ret = load_backup_segment(image, kbuf); 845 if (ret) { 846 pr_err("Failed to load backup segment\n"); 847 return ret; 848 } 849 pr_debug("Loaded the backup region at 0x%lx\n", kbuf->mem); 850 851 /* Load elfcorehdr segment - to export crashing kernel's vmcore */ 852 ret = load_elfcorehdr_segment(image, kbuf); 853 if (ret) { 854 pr_err("Failed to load elfcorehdr segment\n"); 855 return ret; 856 } 857 pr_debug("Loaded elf core header at 0x%lx, bufsz=0x%lx memsz=0x%lx\n", 858 image->arch.elfcorehdr_addr, kbuf->bufsz, kbuf->memsz); 859 860 return 0; 861 } 862 863 /** 864 * setup_purgatory_ppc64 - initialize PPC64 specific purgatory's global 865 * variables and call setup_purgatory() to initialize 866 * common global variable. 867 * @image: kexec image. 868 * @slave_code: Slave code for the purgatory. 869 * @fdt: Flattened device tree for the next kernel. 870 * @kernel_load_addr: Address where the kernel is loaded. 871 * @fdt_load_addr: Address where the flattened device tree is loaded. 872 * 873 * Returns 0 on success, negative errno on error. 874 */ 875 int setup_purgatory_ppc64(struct kimage *image, const void *slave_code, 876 const void *fdt, unsigned long kernel_load_addr, 877 unsigned long fdt_load_addr) 878 { 879 struct device_node *dn = NULL; 880 int ret; 881 882 ret = setup_purgatory(image, slave_code, fdt, kernel_load_addr, 883 fdt_load_addr); 884 if (ret) 885 goto out; 886 887 if (image->type == KEXEC_TYPE_CRASH) { 888 u32 my_run_at_load = 1; 889 890 /* 891 * Tell relocatable kernel to run at load address 892 * via the word meant for that at 0x5c. 893 */ 894 ret = kexec_purgatory_get_set_symbol(image, "run_at_load", 895 &my_run_at_load, 896 sizeof(my_run_at_load), 897 false); 898 if (ret) 899 goto out; 900 } 901 902 /* Tell purgatory where to look for backup region */ 903 ret = kexec_purgatory_get_set_symbol(image, "backup_start", 904 &image->arch.backup_start, 905 sizeof(image->arch.backup_start), 906 false); 907 if (ret) 908 goto out; 909 910 /* Setup OPAL base & entry values */ 911 dn = of_find_node_by_path("/ibm,opal"); 912 if (dn) { 913 u64 val; 914 915 of_property_read_u64(dn, "opal-base-address", &val); 916 ret = kexec_purgatory_get_set_symbol(image, "opal_base", &val, 917 sizeof(val), false); 918 if (ret) 919 goto out; 920 921 of_property_read_u64(dn, "opal-entry-address", &val); 922 ret = kexec_purgatory_get_set_symbol(image, "opal_entry", &val, 923 sizeof(val), false); 924 } 925 out: 926 if (ret) 927 pr_err("Failed to setup purgatory symbols"); 928 of_node_put(dn); 929 return ret; 930 } 931 932 /** 933 * setup_new_fdt_ppc64 - Update the flattend device-tree of the kernel 934 * being loaded. 935 * @image: kexec image being loaded. 936 * @fdt: Flattened device tree for the next kernel. 937 * @initrd_load_addr: Address where the next initrd will be loaded. 938 * @initrd_len: Size of the next initrd, or 0 if there will be none. 939 * @cmdline: Command line for the next kernel, or NULL if there will 940 * be none. 941 * 942 * Returns 0 on success, negative errno on error. 943 */ 944 int setup_new_fdt_ppc64(const struct kimage *image, void *fdt, 945 unsigned long initrd_load_addr, 946 unsigned long initrd_len, const char *cmdline) 947 { 948 struct crash_mem *umem = NULL, *rmem = NULL; 949 int i, nr_ranges, ret; 950 951 ret = setup_new_fdt(image, fdt, initrd_load_addr, initrd_len, cmdline); 952 if (ret) 953 goto out; 954 955 /* 956 * Restrict memory usage for kdump kernel by setting up 957 * usable memory ranges and memory reserve map. 958 */ 959 if (image->type == KEXEC_TYPE_CRASH) { 960 ret = get_usable_memory_ranges(&umem); 961 if (ret) 962 goto out; 963 964 ret = update_usable_mem_fdt(fdt, umem); 965 if (ret) { 966 pr_err("Error setting up usable-memory property for kdump kernel\n"); 967 goto out; 968 } 969 970 /* 971 * Ensure we don't touch crashed kernel's memory except the 972 * first 64K of RAM, which will be backed up. 973 */ 974 ret = fdt_add_mem_rsv(fdt, BACKUP_SRC_END + 1, 975 crashk_res.start - BACKUP_SRC_SIZE); 976 if (ret) { 977 pr_err("Error reserving crash memory: %s\n", 978 fdt_strerror(ret)); 979 goto out; 980 } 981 982 /* Ensure backup region is not used by kdump/capture kernel */ 983 ret = fdt_add_mem_rsv(fdt, image->arch.backup_start, 984 BACKUP_SRC_SIZE); 985 if (ret) { 986 pr_err("Error reserving memory for backup: %s\n", 987 fdt_strerror(ret)); 988 goto out; 989 } 990 } 991 992 /* Update memory reserve map */ 993 ret = get_reserved_memory_ranges(&rmem); 994 if (ret) 995 goto out; 996 997 nr_ranges = rmem ? rmem->nr_ranges : 0; 998 for (i = 0; i < nr_ranges; i++) { 999 u64 base, size; 1000 1001 base = rmem->ranges[i].start; 1002 size = rmem->ranges[i].end - base + 1; 1003 ret = fdt_add_mem_rsv(fdt, base, size); 1004 if (ret) { 1005 pr_err("Error updating memory reserve map: %s\n", 1006 fdt_strerror(ret)); 1007 goto out; 1008 } 1009 } 1010 1011 out: 1012 kfree(rmem); 1013 kfree(umem); 1014 return ret; 1015 } 1016 1017 /** 1018 * arch_kexec_locate_mem_hole - Skip special memory regions like rtas, opal, 1019 * tce-table, reserved-ranges & such (exclude 1020 * memory ranges) as they can't be used for kexec 1021 * segment buffer. Sets kbuf->mem when a suitable 1022 * memory hole is found. 1023 * @kbuf: Buffer contents and memory parameters. 1024 * 1025 * Assumes minimum of PAGE_SIZE alignment for kbuf->memsz & kbuf->buf_align. 1026 * 1027 * Returns 0 on success, negative errno on error. 1028 */ 1029 int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf) 1030 { 1031 struct crash_mem **emem; 1032 u64 buf_min, buf_max; 1033 int ret; 1034 1035 /* Look up the exclude ranges list while locating the memory hole */ 1036 emem = &(kbuf->image->arch.exclude_ranges); 1037 if (!(*emem) || ((*emem)->nr_ranges == 0)) { 1038 pr_warn("No exclude range list. Using the default locate mem hole method\n"); 1039 return kexec_locate_mem_hole(kbuf); 1040 } 1041 1042 buf_min = kbuf->buf_min; 1043 buf_max = kbuf->buf_max; 1044 /* Segments for kdump kernel should be within crashkernel region */ 1045 if (kbuf->image->type == KEXEC_TYPE_CRASH) { 1046 buf_min = (buf_min < crashk_res.start ? 1047 crashk_res.start : buf_min); 1048 buf_max = (buf_max > crashk_res.end ? 1049 crashk_res.end : buf_max); 1050 } 1051 1052 if (buf_min > buf_max) { 1053 pr_err("Invalid buffer min and/or max values\n"); 1054 return -EINVAL; 1055 } 1056 1057 if (kbuf->top_down) 1058 ret = locate_mem_hole_top_down_ppc64(kbuf, buf_min, buf_max, 1059 *emem); 1060 else 1061 ret = locate_mem_hole_bottom_up_ppc64(kbuf, buf_min, buf_max, 1062 *emem); 1063 1064 /* Add the buffer allocated to the exclude list for the next lookup */ 1065 if (!ret) { 1066 add_mem_range(emem, kbuf->mem, kbuf->memsz); 1067 sort_memory_ranges(*emem, true); 1068 } else { 1069 pr_err("Failed to locate memory buffer of size %lu\n", 1070 kbuf->memsz); 1071 } 1072 return ret; 1073 } 1074 1075 /** 1076 * arch_kexec_kernel_image_probe - Does additional handling needed to setup 1077 * kexec segments. 1078 * @image: kexec image being loaded. 1079 * @buf: Buffer pointing to elf data. 1080 * @buf_len: Length of the buffer. 1081 * 1082 * Returns 0 on success, negative errno on error. 1083 */ 1084 int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, 1085 unsigned long buf_len) 1086 { 1087 int ret; 1088 1089 /* Get exclude memory ranges needed for setting up kexec segments */ 1090 ret = get_exclude_memory_ranges(&(image->arch.exclude_ranges)); 1091 if (ret) { 1092 pr_err("Failed to setup exclude memory ranges for buffer lookup\n"); 1093 return ret; 1094 } 1095 1096 return kexec_image_probe_default(image, buf, buf_len); 1097 } 1098 1099 /** 1100 * arch_kimage_file_post_load_cleanup - Frees up all the allocations done 1101 * while loading the image. 1102 * @image: kexec image being loaded. 1103 * 1104 * Returns 0 on success, negative errno on error. 1105 */ 1106 int arch_kimage_file_post_load_cleanup(struct kimage *image) 1107 { 1108 kfree(image->arch.exclude_ranges); 1109 image->arch.exclude_ranges = NULL; 1110 1111 vfree(image->arch.backup_buf); 1112 image->arch.backup_buf = NULL; 1113 1114 vfree(image->arch.elf_headers); 1115 image->arch.elf_headers = NULL; 1116 image->arch.elf_headers_sz = 0; 1117 1118 return kexec_image_post_load_cleanup_default(image); 1119 } 1120