1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) 4 * Copyright (C) 2002-2006 Novell, Inc. 5 * Jan Beulich <jbeulich@novell.com> 6 * 7 * A simple API for unwinding kernel stacks. This is used for 8 * debugging and error reporting purposes. The kernel doesn't need 9 * full-blown stack unwinding with all the bells and whistles, so there 10 * is not much point in implementing the full Dwarf2 unwind API. 11 */ 12 13 #include <linux/sched.h> 14 #include <linux/module.h> 15 #include <linux/memblock.h> 16 #include <linux/sort.h> 17 #include <linux/slab.h> 18 #include <linux/stop_machine.h> 19 #include <linux/uaccess.h> 20 #include <linux/ptrace.h> 21 #include <asm/sections.h> 22 #include <asm/unaligned.h> 23 #include <asm/unwind.h> 24 25 extern char __start_unwind[], __end_unwind[]; 26 /* extern const u8 __start_unwind_hdr[], __end_unwind_hdr[];*/ 27 28 /* #define UNWIND_DEBUG */ 29 30 #ifdef UNWIND_DEBUG 31 int dbg_unw; 32 #define unw_debug(fmt, ...) \ 33 do { \ 34 if (dbg_unw) \ 35 pr_info(fmt, ##__VA_ARGS__); \ 36 } while (0); 37 #else 38 #define unw_debug(fmt, ...) 39 #endif 40 41 #define MAX_STACK_DEPTH 8 42 43 #define EXTRA_INFO(f) { \ 44 BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) \ 45 % sizeof_field(struct unwind_frame_info, f)) \ 46 + offsetof(struct unwind_frame_info, f) \ 47 / sizeof_field(struct unwind_frame_info, f), \ 48 sizeof_field(struct unwind_frame_info, f) \ 49 } 50 #define PTREGS_INFO(f) EXTRA_INFO(regs.f) 51 52 static const struct { 53 unsigned offs:BITS_PER_LONG / 2; 54 unsigned width:BITS_PER_LONG / 2; 55 } reg_info[] = { 56 UNW_REGISTER_INFO}; 57 58 #undef PTREGS_INFO 59 #undef EXTRA_INFO 60 61 #ifndef REG_INVALID 62 #define REG_INVALID(r) (reg_info[r].width == 0) 63 #endif 64 65 #define DW_CFA_nop 0x00 66 #define DW_CFA_set_loc 0x01 67 #define DW_CFA_advance_loc1 0x02 68 #define DW_CFA_advance_loc2 0x03 69 #define DW_CFA_advance_loc4 0x04 70 #define DW_CFA_offset_extended 0x05 71 #define DW_CFA_restore_extended 0x06 72 #define DW_CFA_undefined 0x07 73 #define DW_CFA_same_value 0x08 74 #define DW_CFA_register 0x09 75 #define DW_CFA_remember_state 0x0a 76 #define DW_CFA_restore_state 0x0b 77 #define DW_CFA_def_cfa 0x0c 78 #define DW_CFA_def_cfa_register 0x0d 79 #define DW_CFA_def_cfa_offset 0x0e 80 #define DW_CFA_def_cfa_expression 0x0f 81 #define DW_CFA_expression 0x10 82 #define DW_CFA_offset_extended_sf 0x11 83 #define DW_CFA_def_cfa_sf 0x12 84 #define DW_CFA_def_cfa_offset_sf 0x13 85 #define DW_CFA_val_offset 0x14 86 #define DW_CFA_val_offset_sf 0x15 87 #define DW_CFA_val_expression 0x16 88 #define DW_CFA_lo_user 0x1c 89 #define DW_CFA_GNU_window_save 0x2d 90 #define DW_CFA_GNU_args_size 0x2e 91 #define DW_CFA_GNU_negative_offset_extended 0x2f 92 #define DW_CFA_hi_user 0x3f 93 94 #define DW_EH_PE_FORM 0x07 95 #define DW_EH_PE_native 0x00 96 #define DW_EH_PE_leb128 0x01 97 #define DW_EH_PE_data2 0x02 98 #define DW_EH_PE_data4 0x03 99 #define DW_EH_PE_data8 0x04 100 #define DW_EH_PE_signed 0x08 101 #define DW_EH_PE_ADJUST 0x70 102 #define DW_EH_PE_abs 0x00 103 #define DW_EH_PE_pcrel 0x10 104 #define DW_EH_PE_textrel 0x20 105 #define DW_EH_PE_datarel 0x30 106 #define DW_EH_PE_funcrel 0x40 107 #define DW_EH_PE_aligned 0x50 108 #define DW_EH_PE_indirect 0x80 109 #define DW_EH_PE_omit 0xff 110 111 #define CIE_ID 0 112 113 typedef unsigned long uleb128_t; 114 typedef signed long sleb128_t; 115 116 static struct unwind_table { 117 struct { 118 unsigned long pc; 119 unsigned long range; 120 } core, init; 121 const void *address; 122 unsigned long size; 123 const unsigned char *header; 124 unsigned long hdrsz; 125 struct unwind_table *link; 126 const char *name; 127 } root_table; 128 129 struct unwind_item { 130 enum item_location { 131 Nowhere, 132 Memory, 133 Register, 134 Value 135 } where; 136 uleb128_t value; 137 }; 138 139 struct unwind_state { 140 uleb128_t loc, org; 141 const u8 *cieStart, *cieEnd; 142 uleb128_t codeAlign; 143 sleb128_t dataAlign; 144 struct cfa { 145 uleb128_t reg, offs; 146 } cfa; 147 struct unwind_item regs[ARRAY_SIZE(reg_info)]; 148 unsigned stackDepth:8; 149 unsigned version:8; 150 const u8 *label; 151 const u8 *stack[MAX_STACK_DEPTH]; 152 }; 153 154 static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 }; 155 156 static struct unwind_table *find_table(unsigned long pc) 157 { 158 struct unwind_table *table; 159 160 for (table = &root_table; table; table = table->link) 161 if ((pc >= table->core.pc 162 && pc < table->core.pc + table->core.range) 163 || (pc >= table->init.pc 164 && pc < table->init.pc + table->init.range)) 165 break; 166 167 return table; 168 } 169 170 static unsigned long read_pointer(const u8 **pLoc, 171 const void *end, signed ptrType); 172 static void init_unwind_hdr(struct unwind_table *table, 173 void *(*alloc) (unsigned long)); 174 175 /* 176 * wrappers for header alloc (vs. calling one vs. other at call site) 177 * to elide section mismatches warnings 178 */ 179 static void *__init unw_hdr_alloc_early(unsigned long sz) 180 { 181 return memblock_alloc_from(sz, sizeof(unsigned int), MAX_DMA_ADDRESS); 182 } 183 184 static void init_unwind_table(struct unwind_table *table, const char *name, 185 const void *core_start, unsigned long core_size, 186 const void *init_start, unsigned long init_size, 187 const void *table_start, unsigned long table_size, 188 const u8 *header_start, unsigned long header_size) 189 { 190 table->core.pc = (unsigned long)core_start; 191 table->core.range = core_size; 192 table->init.pc = (unsigned long)init_start; 193 table->init.range = init_size; 194 table->address = table_start; 195 table->size = table_size; 196 /* To avoid the pointer addition with NULL pointer.*/ 197 if (header_start != NULL) { 198 const u8 *ptr = header_start + 4; 199 const u8 *end = header_start + header_size; 200 /* See if the linker provided table looks valid. */ 201 if (header_size <= 4 202 || header_start[0] != 1 203 || (void *)read_pointer(&ptr, end, header_start[1]) 204 != table_start 205 || header_start[2] == DW_EH_PE_omit 206 || read_pointer(&ptr, end, header_start[2]) <= 0 207 || header_start[3] == DW_EH_PE_omit) 208 header_start = NULL; 209 } 210 table->hdrsz = header_size; 211 smp_wmb(); 212 table->header = header_start; 213 table->link = NULL; 214 table->name = name; 215 } 216 217 void __init arc_unwind_init(void) 218 { 219 init_unwind_table(&root_table, "kernel", _text, _end - _text, NULL, 0, 220 __start_unwind, __end_unwind - __start_unwind, 221 NULL, 0); 222 /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/ 223 224 init_unwind_hdr(&root_table, unw_hdr_alloc_early); 225 } 226 227 static const u32 bad_cie, not_fde; 228 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *); 229 static const u32 *__cie_for_fde(const u32 *fde); 230 static signed fde_pointer_type(const u32 *cie); 231 232 struct eh_frame_hdr_table_entry { 233 unsigned long start, fde; 234 }; 235 236 static int cmp_eh_frame_hdr_table_entries(const void *p1, const void *p2) 237 { 238 const struct eh_frame_hdr_table_entry *e1 = p1; 239 const struct eh_frame_hdr_table_entry *e2 = p2; 240 241 return (e1->start > e2->start) - (e1->start < e2->start); 242 } 243 244 static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size) 245 { 246 struct eh_frame_hdr_table_entry *e1 = p1; 247 struct eh_frame_hdr_table_entry *e2 = p2; 248 249 swap(e1->start, e2->start); 250 swap(e1->fde, e2->fde); 251 } 252 253 static void init_unwind_hdr(struct unwind_table *table, 254 void *(*alloc) (unsigned long)) 255 { 256 const u8 *ptr; 257 unsigned long tableSize = table->size, hdrSize; 258 unsigned int n; 259 const u32 *fde; 260 struct { 261 u8 version; 262 u8 eh_frame_ptr_enc; 263 u8 fde_count_enc; 264 u8 table_enc; 265 unsigned long eh_frame_ptr; 266 unsigned int fde_count; 267 struct eh_frame_hdr_table_entry table[]; 268 } __attribute__ ((__packed__)) *header; 269 270 if (table->header) 271 return; 272 273 if (table->hdrsz) 274 pr_warn(".eh_frame_hdr for '%s' present but unusable\n", 275 table->name); 276 277 if (tableSize & (sizeof(*fde) - 1)) 278 return; 279 280 for (fde = table->address, n = 0; 281 tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde; 282 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) { 283 const u32 *cie = cie_for_fde(fde, table); 284 signed ptrType; 285 286 if (cie == ¬_fde) 287 continue; 288 if (cie == NULL || cie == &bad_cie) 289 goto ret_err; 290 ptrType = fde_pointer_type(cie); 291 if (ptrType < 0) 292 goto ret_err; 293 294 ptr = (const u8 *)(fde + 2); 295 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde, 296 ptrType)) { 297 /* FIXME_Rajesh We have 4 instances of null addresses 298 * instead of the initial loc addr 299 * return; 300 */ 301 WARN(1, "unwinder: FDE->initial_location NULL %p\n", 302 (const u8 *)(fde + 1) + *fde); 303 } 304 ++n; 305 } 306 307 if (tableSize || !n) 308 goto ret_err; 309 310 hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int) 311 + 2 * n * sizeof(unsigned long); 312 313 header = alloc(hdrSize); 314 if (!header) 315 goto ret_err; 316 317 header->version = 1; 318 header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native; 319 header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4; 320 header->table_enc = DW_EH_PE_abs | DW_EH_PE_native; 321 put_unaligned((unsigned long)table->address, &header->eh_frame_ptr); 322 BUILD_BUG_ON(offsetof(typeof(*header), fde_count) 323 % __alignof(typeof(header->fde_count))); 324 header->fde_count = n; 325 326 BUILD_BUG_ON(offsetof(typeof(*header), table) 327 % __alignof(typeof(*header->table))); 328 for (fde = table->address, tableSize = table->size, n = 0; 329 tableSize; 330 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) { 331 const u32 *cie = __cie_for_fde(fde); 332 333 if (fde[1] == CIE_ID) 334 continue; /* this is a CIE */ 335 ptr = (const u8 *)(fde + 2); 336 header->table[n].start = read_pointer(&ptr, 337 (const u8 *)(fde + 1) + 338 *fde, 339 fde_pointer_type(cie)); 340 header->table[n].fde = (unsigned long)fde; 341 ++n; 342 } 343 WARN_ON(n != header->fde_count); 344 345 sort(header->table, 346 n, 347 sizeof(*header->table), 348 cmp_eh_frame_hdr_table_entries, swap_eh_frame_hdr_table_entries); 349 350 table->hdrsz = hdrSize; 351 smp_wmb(); 352 table->header = (const void *)header; 353 return; 354 355 ret_err: 356 panic("Attention !!! Dwarf FDE parsing errors\n"); 357 } 358 359 #ifdef CONFIG_MODULES 360 static void *unw_hdr_alloc(unsigned long sz) 361 { 362 return kmalloc(sz, GFP_KERNEL); 363 } 364 365 static struct unwind_table *last_table; 366 367 /* Must be called with module_mutex held. */ 368 void *unwind_add_table(struct module *module, const void *table_start, 369 unsigned long table_size) 370 { 371 struct unwind_table *table; 372 373 if (table_size <= 0) 374 return NULL; 375 376 table = kmalloc(sizeof(*table), GFP_KERNEL); 377 if (!table) 378 return NULL; 379 380 init_unwind_table(table, module->name, 381 module->core_layout.base, module->core_layout.size, 382 module->init_layout.base, module->init_layout.size, 383 table_start, table_size, 384 NULL, 0); 385 386 init_unwind_hdr(table, unw_hdr_alloc); 387 388 #ifdef UNWIND_DEBUG 389 unw_debug("Table added for [%s] %lx %lx\n", 390 module->name, table->core.pc, table->core.range); 391 #endif 392 if (last_table) 393 last_table->link = table; 394 else 395 root_table.link = table; 396 last_table = table; 397 398 return table; 399 } 400 401 struct unlink_table_info { 402 struct unwind_table *table; 403 int init_only; 404 }; 405 406 static int unlink_table(void *arg) 407 { 408 struct unlink_table_info *info = arg; 409 struct unwind_table *table = info->table, *prev; 410 411 for (prev = &root_table; prev->link && prev->link != table; 412 prev = prev->link) 413 ; 414 415 if (prev->link) { 416 if (info->init_only) { 417 table->init.pc = 0; 418 table->init.range = 0; 419 info->table = NULL; 420 } else { 421 prev->link = table->link; 422 if (!prev->link) 423 last_table = prev; 424 } 425 } else 426 info->table = NULL; 427 428 return 0; 429 } 430 431 /* Must be called with module_mutex held. */ 432 void unwind_remove_table(void *handle, int init_only) 433 { 434 struct unwind_table *table = handle; 435 struct unlink_table_info info; 436 437 if (!table || table == &root_table) 438 return; 439 440 if (init_only && table == last_table) { 441 table->init.pc = 0; 442 table->init.range = 0; 443 return; 444 } 445 446 info.table = table; 447 info.init_only = init_only; 448 449 unlink_table(&info); /* XXX: SMP */ 450 kfree(table->header); 451 kfree(table); 452 } 453 454 #endif /* CONFIG_MODULES */ 455 456 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end) 457 { 458 const u8 *cur = *pcur; 459 uleb128_t value; 460 unsigned int shift; 461 462 for (shift = 0, value = 0; cur < end; shift += 7) { 463 if (shift + 7 > 8 * sizeof(value) 464 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) { 465 cur = end + 1; 466 break; 467 } 468 value |= (uleb128_t) (*cur & 0x7f) << shift; 469 if (!(*cur++ & 0x80)) 470 break; 471 } 472 *pcur = cur; 473 474 return value; 475 } 476 477 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end) 478 { 479 const u8 *cur = *pcur; 480 sleb128_t value; 481 unsigned int shift; 482 483 for (shift = 0, value = 0; cur < end; shift += 7) { 484 if (shift + 7 > 8 * sizeof(value) 485 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) { 486 cur = end + 1; 487 break; 488 } 489 value |= (sleb128_t) (*cur & 0x7f) << shift; 490 if (!(*cur & 0x80)) { 491 value |= -(*cur++ & 0x40) << shift; 492 break; 493 } 494 } 495 *pcur = cur; 496 497 return value; 498 } 499 500 static const u32 *__cie_for_fde(const u32 *fde) 501 { 502 const u32 *cie; 503 504 cie = fde + 1 - fde[1] / sizeof(*fde); 505 506 return cie; 507 } 508 509 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table) 510 { 511 const u32 *cie; 512 513 if (!*fde || (*fde & (sizeof(*fde) - 1))) 514 return &bad_cie; 515 516 if (fde[1] == CIE_ID) 517 return ¬_fde; /* this is a CIE */ 518 519 if ((fde[1] & (sizeof(*fde) - 1))) 520 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */ 521 return NULL; /* this is not a valid FDE */ 522 523 cie = __cie_for_fde(fde); 524 525 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde) 526 || (*cie & (sizeof(*cie) - 1)) 527 || (cie[1] != CIE_ID)) 528 return NULL; /* this is not a (valid) CIE */ 529 return cie; 530 } 531 532 static unsigned long read_pointer(const u8 **pLoc, const void *end, 533 signed ptrType) 534 { 535 unsigned long value = 0; 536 union { 537 const u8 *p8; 538 const u16 *p16u; 539 const s16 *p16s; 540 const u32 *p32u; 541 const s32 *p32s; 542 const unsigned long *pul; 543 } ptr; 544 545 if (ptrType < 0 || ptrType == DW_EH_PE_omit) 546 return 0; 547 ptr.p8 = *pLoc; 548 switch (ptrType & DW_EH_PE_FORM) { 549 case DW_EH_PE_data2: 550 if (end < (const void *)(ptr.p16u + 1)) 551 return 0; 552 if (ptrType & DW_EH_PE_signed) 553 value = get_unaligned((u16 *) ptr.p16s++); 554 else 555 value = get_unaligned((u16 *) ptr.p16u++); 556 break; 557 case DW_EH_PE_data4: 558 #ifdef CONFIG_64BIT 559 if (end < (const void *)(ptr.p32u + 1)) 560 return 0; 561 if (ptrType & DW_EH_PE_signed) 562 value = get_unaligned(ptr.p32s++); 563 else 564 value = get_unaligned(ptr.p32u++); 565 break; 566 case DW_EH_PE_data8: 567 BUILD_BUG_ON(sizeof(u64) != sizeof(value)); 568 #else 569 BUILD_BUG_ON(sizeof(u32) != sizeof(value)); 570 #endif 571 fallthrough; 572 case DW_EH_PE_native: 573 if (end < (const void *)(ptr.pul + 1)) 574 return 0; 575 value = get_unaligned((unsigned long *)ptr.pul++); 576 break; 577 case DW_EH_PE_leb128: 578 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value)); 579 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end) 580 : get_uleb128(&ptr.p8, end); 581 if ((const void *)ptr.p8 > end) 582 return 0; 583 break; 584 default: 585 return 0; 586 } 587 switch (ptrType & DW_EH_PE_ADJUST) { 588 case DW_EH_PE_abs: 589 break; 590 case DW_EH_PE_pcrel: 591 value += (unsigned long)*pLoc; 592 break; 593 default: 594 return 0; 595 } 596 if ((ptrType & DW_EH_PE_indirect) 597 && __get_user(value, (unsigned long __user *)value)) 598 return 0; 599 *pLoc = ptr.p8; 600 601 return value; 602 } 603 604 static signed fde_pointer_type(const u32 *cie) 605 { 606 const u8 *ptr = (const u8 *)(cie + 2); 607 unsigned int version = *ptr; 608 609 if (*++ptr) { 610 const char *aug; 611 const u8 *end = (const u8 *)(cie + 1) + *cie; 612 uleb128_t len; 613 614 /* check if augmentation size is first (and thus present) */ 615 if (*ptr != 'z') 616 return -1; 617 618 /* check if augmentation string is nul-terminated */ 619 aug = (const void *)ptr; 620 ptr = memchr(aug, 0, end - ptr); 621 if (ptr == NULL) 622 return -1; 623 624 ++ptr; /* skip terminator */ 625 get_uleb128(&ptr, end); /* skip code alignment */ 626 get_sleb128(&ptr, end); /* skip data alignment */ 627 /* skip return address column */ 628 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end); 629 len = get_uleb128(&ptr, end); /* augmentation length */ 630 631 if (ptr + len < ptr || ptr + len > end) 632 return -1; 633 634 end = ptr + len; 635 while (*++aug) { 636 if (ptr >= end) 637 return -1; 638 switch (*aug) { 639 case 'L': 640 ++ptr; 641 break; 642 case 'P':{ 643 signed ptrType = *ptr++; 644 645 if (!read_pointer(&ptr, end, ptrType) 646 || ptr > end) 647 return -1; 648 } 649 break; 650 case 'R': 651 return *ptr; 652 default: 653 return -1; 654 } 655 } 656 } 657 return DW_EH_PE_native | DW_EH_PE_abs; 658 } 659 660 static int advance_loc(unsigned long delta, struct unwind_state *state) 661 { 662 state->loc += delta * state->codeAlign; 663 664 /* FIXME_Rajesh: Probably we are defining for the initial range as well; 665 return delta > 0; 666 */ 667 unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc); 668 return 1; 669 } 670 671 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value, 672 struct unwind_state *state) 673 { 674 if (reg < ARRAY_SIZE(state->regs)) { 675 state->regs[reg].where = where; 676 state->regs[reg].value = value; 677 678 #ifdef UNWIND_DEBUG 679 unw_debug("r%lu: ", reg); 680 switch (where) { 681 case Nowhere: 682 unw_debug("s "); 683 break; 684 case Memory: 685 unw_debug("c(%lu) ", value); 686 break; 687 case Register: 688 unw_debug("r(%lu) ", value); 689 break; 690 case Value: 691 unw_debug("v(%lu) ", value); 692 break; 693 default: 694 break; 695 } 696 #endif 697 } 698 } 699 700 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc, 701 signed ptrType, struct unwind_state *state) 702 { 703 union { 704 const u8 *p8; 705 const u16 *p16; 706 const u32 *p32; 707 } ptr; 708 int result = 1; 709 u8 opcode; 710 711 if (start != state->cieStart) { 712 state->loc = state->org; 713 result = 714 processCFI(state->cieStart, state->cieEnd, 0, ptrType, 715 state); 716 if (targetLoc == 0 && state->label == NULL) 717 return result; 718 } 719 for (ptr.p8 = start; result && ptr.p8 < end;) { 720 switch (*ptr.p8 >> 6) { 721 uleb128_t value; 722 723 case 0: 724 opcode = *ptr.p8++; 725 726 switch (opcode) { 727 case DW_CFA_nop: 728 unw_debug("cfa nop "); 729 break; 730 case DW_CFA_set_loc: 731 state->loc = read_pointer(&ptr.p8, end, 732 ptrType); 733 if (state->loc == 0) 734 result = 0; 735 unw_debug("cfa_set_loc: 0x%lx ", state->loc); 736 break; 737 case DW_CFA_advance_loc1: 738 unw_debug("\ncfa advance loc1:"); 739 result = ptr.p8 < end 740 && advance_loc(*ptr.p8++, state); 741 break; 742 case DW_CFA_advance_loc2: 743 value = *ptr.p8++; 744 value += *ptr.p8++ << 8; 745 unw_debug("\ncfa advance loc2:"); 746 result = ptr.p8 <= end + 2 747 /* && advance_loc(*ptr.p16++, state); */ 748 && advance_loc(value, state); 749 break; 750 case DW_CFA_advance_loc4: 751 unw_debug("\ncfa advance loc4:"); 752 result = ptr.p8 <= end + 4 753 && advance_loc(*ptr.p32++, state); 754 break; 755 case DW_CFA_offset_extended: 756 value = get_uleb128(&ptr.p8, end); 757 unw_debug("cfa_offset_extended: "); 758 set_rule(value, Memory, 759 get_uleb128(&ptr.p8, end), state); 760 break; 761 case DW_CFA_val_offset: 762 value = get_uleb128(&ptr.p8, end); 763 set_rule(value, Value, 764 get_uleb128(&ptr.p8, end), state); 765 break; 766 case DW_CFA_offset_extended_sf: 767 value = get_uleb128(&ptr.p8, end); 768 set_rule(value, Memory, 769 get_sleb128(&ptr.p8, end), state); 770 break; 771 case DW_CFA_val_offset_sf: 772 value = get_uleb128(&ptr.p8, end); 773 set_rule(value, Value, 774 get_sleb128(&ptr.p8, end), state); 775 break; 776 case DW_CFA_restore_extended: 777 unw_debug("cfa_restore_extended: "); 778 case DW_CFA_undefined: 779 unw_debug("cfa_undefined: "); 780 case DW_CFA_same_value: 781 unw_debug("cfa_same_value: "); 782 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0, 783 state); 784 break; 785 case DW_CFA_register: 786 unw_debug("cfa_register: "); 787 value = get_uleb128(&ptr.p8, end); 788 set_rule(value, 789 Register, 790 get_uleb128(&ptr.p8, end), state); 791 break; 792 case DW_CFA_remember_state: 793 unw_debug("cfa_remember_state: "); 794 if (ptr.p8 == state->label) { 795 state->label = NULL; 796 return 1; 797 } 798 if (state->stackDepth >= MAX_STACK_DEPTH) 799 return 0; 800 state->stack[state->stackDepth++] = ptr.p8; 801 break; 802 case DW_CFA_restore_state: 803 unw_debug("cfa_restore_state: "); 804 if (state->stackDepth) { 805 const uleb128_t loc = state->loc; 806 const u8 *label = state->label; 807 808 state->label = 809 state->stack[state->stackDepth - 1]; 810 memcpy(&state->cfa, &badCFA, 811 sizeof(state->cfa)); 812 memset(state->regs, 0, 813 sizeof(state->regs)); 814 state->stackDepth = 0; 815 result = 816 processCFI(start, end, 0, ptrType, 817 state); 818 state->loc = loc; 819 state->label = label; 820 } else 821 return 0; 822 break; 823 case DW_CFA_def_cfa: 824 state->cfa.reg = get_uleb128(&ptr.p8, end); 825 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg); 826 fallthrough; 827 case DW_CFA_def_cfa_offset: 828 state->cfa.offs = get_uleb128(&ptr.p8, end); 829 unw_debug("cfa_def_cfa_offset: 0x%lx ", 830 state->cfa.offs); 831 break; 832 case DW_CFA_def_cfa_sf: 833 state->cfa.reg = get_uleb128(&ptr.p8, end); 834 fallthrough; 835 case DW_CFA_def_cfa_offset_sf: 836 state->cfa.offs = get_sleb128(&ptr.p8, end) 837 * state->dataAlign; 838 break; 839 case DW_CFA_def_cfa_register: 840 unw_debug("cfa_def_cfa_register: "); 841 state->cfa.reg = get_uleb128(&ptr.p8, end); 842 break; 843 /*todo case DW_CFA_def_cfa_expression: */ 844 /*todo case DW_CFA_expression: */ 845 /*todo case DW_CFA_val_expression: */ 846 case DW_CFA_GNU_args_size: 847 get_uleb128(&ptr.p8, end); 848 break; 849 case DW_CFA_GNU_negative_offset_extended: 850 value = get_uleb128(&ptr.p8, end); 851 set_rule(value, 852 Memory, 853 (uleb128_t) 0 - get_uleb128(&ptr.p8, 854 end), 855 state); 856 break; 857 case DW_CFA_GNU_window_save: 858 default: 859 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode); 860 result = 0; 861 break; 862 } 863 break; 864 case 1: 865 unw_debug("\ncfa_adv_loc: "); 866 result = advance_loc(*ptr.p8++ & 0x3f, state); 867 break; 868 case 2: 869 unw_debug("cfa_offset: "); 870 value = *ptr.p8++ & 0x3f; 871 set_rule(value, Memory, get_uleb128(&ptr.p8, end), 872 state); 873 break; 874 case 3: 875 unw_debug("cfa_restore: "); 876 set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state); 877 break; 878 } 879 880 if (ptr.p8 > end) 881 result = 0; 882 if (result && targetLoc != 0 && targetLoc < state->loc) 883 return 1; 884 } 885 886 return result && ptr.p8 == end && (targetLoc == 0 || ( 887 /*todo While in theory this should apply, gcc in practice omits 888 everything past the function prolog, and hence the location 889 never reaches the end of the function. 890 targetLoc < state->loc && */ state->label == NULL)); 891 } 892 893 /* Unwind to previous to frame. Returns 0 if successful, negative 894 * number in case of an error. */ 895 int arc_unwind(struct unwind_frame_info *frame) 896 { 897 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs]) 898 const u32 *fde = NULL, *cie = NULL; 899 const u8 *ptr = NULL, *end = NULL; 900 unsigned long pc = UNW_PC(frame) - frame->call_frame; 901 unsigned long startLoc = 0, endLoc = 0, cfa; 902 unsigned int i; 903 signed ptrType = -1; 904 uleb128_t retAddrReg = 0; 905 const struct unwind_table *table; 906 struct unwind_state state; 907 unsigned long *fptr; 908 unsigned long addr; 909 910 unw_debug("\n\nUNWIND FRAME:\n"); 911 unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n", 912 UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame), 913 UNW_FP(frame)); 914 915 if (UNW_PC(frame) == 0) 916 return -EINVAL; 917 918 #ifdef UNWIND_DEBUG 919 { 920 unsigned long *sptr = (unsigned long *)UNW_SP(frame); 921 unw_debug("\nStack Dump:\n"); 922 for (i = 0; i < 20; i++, sptr++) 923 unw_debug("0x%p: 0x%lx\n", sptr, *sptr); 924 unw_debug("\n"); 925 } 926 #endif 927 928 table = find_table(pc); 929 if (table != NULL 930 && !(table->size & (sizeof(*fde) - 1))) { 931 const u8 *hdr = table->header; 932 unsigned long tableSize; 933 934 smp_rmb(); 935 if (hdr && hdr[0] == 1) { 936 switch (hdr[3] & DW_EH_PE_FORM) { 937 case DW_EH_PE_native: 938 tableSize = sizeof(unsigned long); 939 break; 940 case DW_EH_PE_data2: 941 tableSize = 2; 942 break; 943 case DW_EH_PE_data4: 944 tableSize = 4; 945 break; 946 case DW_EH_PE_data8: 947 tableSize = 8; 948 break; 949 default: 950 tableSize = 0; 951 break; 952 } 953 ptr = hdr + 4; 954 end = hdr + table->hdrsz; 955 if (tableSize && read_pointer(&ptr, end, hdr[1]) 956 == (unsigned long)table->address 957 && (i = read_pointer(&ptr, end, hdr[2])) > 0 958 && i == (end - ptr) / (2 * tableSize) 959 && !((end - ptr) % (2 * tableSize))) { 960 do { 961 const u8 *cur = 962 ptr + (i / 2) * (2 * tableSize); 963 964 startLoc = read_pointer(&cur, 965 cur + tableSize, 966 hdr[3]); 967 if (pc < startLoc) 968 i /= 2; 969 else { 970 ptr = cur - tableSize; 971 i = (i + 1) / 2; 972 } 973 } while (startLoc && i > 1); 974 if (i == 1 975 && (startLoc = read_pointer(&ptr, 976 ptr + tableSize, 977 hdr[3])) != 0 978 && pc >= startLoc) 979 fde = (void *)read_pointer(&ptr, 980 ptr + 981 tableSize, 982 hdr[3]); 983 } 984 } 985 986 if (fde != NULL) { 987 cie = cie_for_fde(fde, table); 988 ptr = (const u8 *)(fde + 2); 989 if (cie != NULL 990 && cie != &bad_cie 991 && cie != ¬_fde 992 && (ptrType = fde_pointer_type(cie)) >= 0 993 && read_pointer(&ptr, 994 (const u8 *)(fde + 1) + *fde, 995 ptrType) == startLoc) { 996 if (!(ptrType & DW_EH_PE_indirect)) 997 ptrType &= 998 DW_EH_PE_FORM | DW_EH_PE_signed; 999 endLoc = 1000 startLoc + read_pointer(&ptr, 1001 (const u8 *)(fde + 1002 1) + 1003 *fde, ptrType); 1004 if (pc >= endLoc) { 1005 fde = NULL; 1006 cie = NULL; 1007 } 1008 } else { 1009 fde = NULL; 1010 cie = NULL; 1011 } 1012 } 1013 } 1014 if (cie != NULL) { 1015 memset(&state, 0, sizeof(state)); 1016 state.cieEnd = ptr; /* keep here temporarily */ 1017 ptr = (const u8 *)(cie + 2); 1018 end = (const u8 *)(cie + 1) + *cie; 1019 frame->call_frame = 1; 1020 if (*++ptr) { 1021 /* check if augmentation size is first (thus present) */ 1022 if (*ptr == 'z') { 1023 while (++ptr < end && *ptr) { 1024 switch (*ptr) { 1025 /* chk for ignorable or already handled 1026 * nul-terminated augmentation string */ 1027 case 'L': 1028 case 'P': 1029 case 'R': 1030 continue; 1031 case 'S': 1032 frame->call_frame = 0; 1033 continue; 1034 default: 1035 break; 1036 } 1037 break; 1038 } 1039 } 1040 if (ptr >= end || *ptr) 1041 cie = NULL; 1042 } 1043 ++ptr; 1044 } 1045 if (cie != NULL) { 1046 /* get code alignment factor */ 1047 state.codeAlign = get_uleb128(&ptr, end); 1048 /* get data alignment factor */ 1049 state.dataAlign = get_sleb128(&ptr, end); 1050 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end) 1051 cie = NULL; 1052 else { 1053 retAddrReg = 1054 state.version <= 1 ? *ptr++ : get_uleb128(&ptr, 1055 end); 1056 unw_debug("CIE Frame Info:\n"); 1057 unw_debug("return Address register 0x%lx\n", 1058 retAddrReg); 1059 unw_debug("data Align: %ld\n", state.dataAlign); 1060 unw_debug("code Align: %lu\n", state.codeAlign); 1061 /* skip augmentation */ 1062 if (((const char *)(cie + 2))[1] == 'z') { 1063 uleb128_t augSize = get_uleb128(&ptr, end); 1064 1065 ptr += augSize; 1066 } 1067 if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info) 1068 || REG_INVALID(retAddrReg) 1069 || reg_info[retAddrReg].width != 1070 sizeof(unsigned long)) 1071 cie = NULL; 1072 } 1073 } 1074 if (cie != NULL) { 1075 state.cieStart = ptr; 1076 ptr = state.cieEnd; 1077 state.cieEnd = end; 1078 end = (const u8 *)(fde + 1) + *fde; 1079 /* skip augmentation */ 1080 if (((const char *)(cie + 2))[1] == 'z') { 1081 uleb128_t augSize = get_uleb128(&ptr, end); 1082 1083 if ((ptr += augSize) > end) 1084 fde = NULL; 1085 } 1086 } 1087 if (cie == NULL || fde == NULL) { 1088 #ifdef CONFIG_FRAME_POINTER 1089 unsigned long top, bottom; 1090 1091 top = STACK_TOP_UNW(frame->task); 1092 bottom = STACK_BOTTOM_UNW(frame->task); 1093 #if FRAME_RETADDR_OFFSET < 0 1094 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame) 1095 && bottom < UNW_FP(frame) 1096 #else 1097 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame) 1098 && bottom > UNW_FP(frame) 1099 #endif 1100 && !((UNW_SP(frame) | UNW_FP(frame)) 1101 & (sizeof(unsigned long) - 1))) { 1102 unsigned long link; 1103 1104 if (!__get_user(link, (unsigned long *) 1105 (UNW_FP(frame) + FRAME_LINK_OFFSET)) 1106 #if FRAME_RETADDR_OFFSET < 0 1107 && link > bottom && link < UNW_FP(frame) 1108 #else 1109 && link > UNW_FP(frame) && link < bottom 1110 #endif 1111 && !(link & (sizeof(link) - 1)) 1112 && !__get_user(UNW_PC(frame), 1113 (unsigned long *)(UNW_FP(frame) 1114 + FRAME_RETADDR_OFFSET))) 1115 { 1116 UNW_SP(frame) = 1117 UNW_FP(frame) + FRAME_RETADDR_OFFSET 1118 #if FRAME_RETADDR_OFFSET < 0 1119 - 1120 #else 1121 + 1122 #endif 1123 sizeof(UNW_PC(frame)); 1124 UNW_FP(frame) = link; 1125 return 0; 1126 } 1127 } 1128 #endif 1129 return -ENXIO; 1130 } 1131 state.org = startLoc; 1132 memcpy(&state.cfa, &badCFA, sizeof(state.cfa)); 1133 1134 unw_debug("\nProcess instructions\n"); 1135 1136 /* process instructions 1137 * For ARC, we optimize by having blink(retAddrReg) with 1138 * the sameValue in the leaf function, so we should not check 1139 * state.regs[retAddrReg].where == Nowhere 1140 */ 1141 if (!processCFI(ptr, end, pc, ptrType, &state) 1142 || state.loc > endLoc 1143 /* || state.regs[retAddrReg].where == Nowhere */ 1144 || state.cfa.reg >= ARRAY_SIZE(reg_info) 1145 || reg_info[state.cfa.reg].width != sizeof(unsigned long) 1146 || state.cfa.offs % sizeof(unsigned long)) 1147 return -EIO; 1148 1149 #ifdef UNWIND_DEBUG 1150 unw_debug("\n"); 1151 1152 unw_debug("\nRegister State Based on the rules parsed from FDE:\n"); 1153 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) { 1154 1155 if (REG_INVALID(i)) 1156 continue; 1157 1158 switch (state.regs[i].where) { 1159 case Nowhere: 1160 break; 1161 case Memory: 1162 unw_debug(" r%d: c(%lu),", i, state.regs[i].value); 1163 break; 1164 case Register: 1165 unw_debug(" r%d: r(%lu),", i, state.regs[i].value); 1166 break; 1167 case Value: 1168 unw_debug(" r%d: v(%lu),", i, state.regs[i].value); 1169 break; 1170 } 1171 } 1172 1173 unw_debug("\n"); 1174 #endif 1175 1176 /* update frame */ 1177 if (frame->call_frame 1178 && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign)) 1179 frame->call_frame = 0; 1180 cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs; 1181 startLoc = min_t(unsigned long, UNW_SP(frame), cfa); 1182 endLoc = max_t(unsigned long, UNW_SP(frame), cfa); 1183 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) { 1184 startLoc = min(STACK_LIMIT(cfa), cfa); 1185 endLoc = max(STACK_LIMIT(cfa), cfa); 1186 } 1187 1188 unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx => 0x%lx\n", 1189 state.cfa.reg, state.cfa.offs, cfa); 1190 1191 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) { 1192 if (REG_INVALID(i)) { 1193 if (state.regs[i].where == Nowhere) 1194 continue; 1195 return -EIO; 1196 } 1197 switch (state.regs[i].where) { 1198 default: 1199 break; 1200 case Register: 1201 if (state.regs[i].value >= ARRAY_SIZE(reg_info) 1202 || REG_INVALID(state.regs[i].value) 1203 || reg_info[i].width > 1204 reg_info[state.regs[i].value].width) 1205 return -EIO; 1206 switch (reg_info[state.regs[i].value].width) { 1207 case sizeof(u8): 1208 state.regs[i].value = 1209 FRAME_REG(state.regs[i].value, const u8); 1210 break; 1211 case sizeof(u16): 1212 state.regs[i].value = 1213 FRAME_REG(state.regs[i].value, const u16); 1214 break; 1215 case sizeof(u32): 1216 state.regs[i].value = 1217 FRAME_REG(state.regs[i].value, const u32); 1218 break; 1219 #ifdef CONFIG_64BIT 1220 case sizeof(u64): 1221 state.regs[i].value = 1222 FRAME_REG(state.regs[i].value, const u64); 1223 break; 1224 #endif 1225 default: 1226 return -EIO; 1227 } 1228 break; 1229 } 1230 } 1231 1232 unw_debug("\nRegister state after evaluation with realtime Stack:\n"); 1233 fptr = (unsigned long *)(&frame->regs); 1234 for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) { 1235 1236 if (REG_INVALID(i)) 1237 continue; 1238 switch (state.regs[i].where) { 1239 case Nowhere: 1240 if (reg_info[i].width != sizeof(UNW_SP(frame)) 1241 || &FRAME_REG(i, __typeof__(UNW_SP(frame))) 1242 != &UNW_SP(frame)) 1243 continue; 1244 UNW_SP(frame) = cfa; 1245 break; 1246 case Register: 1247 switch (reg_info[i].width) { 1248 case sizeof(u8): 1249 FRAME_REG(i, u8) = state.regs[i].value; 1250 break; 1251 case sizeof(u16): 1252 FRAME_REG(i, u16) = state.regs[i].value; 1253 break; 1254 case sizeof(u32): 1255 FRAME_REG(i, u32) = state.regs[i].value; 1256 break; 1257 #ifdef CONFIG_64BIT 1258 case sizeof(u64): 1259 FRAME_REG(i, u64) = state.regs[i].value; 1260 break; 1261 #endif 1262 default: 1263 return -EIO; 1264 } 1265 break; 1266 case Value: 1267 if (reg_info[i].width != sizeof(unsigned long)) 1268 return -EIO; 1269 FRAME_REG(i, unsigned long) = cfa + state.regs[i].value 1270 * state.dataAlign; 1271 break; 1272 case Memory: 1273 addr = cfa + state.regs[i].value * state.dataAlign; 1274 1275 if ((state.regs[i].value * state.dataAlign) 1276 % sizeof(unsigned long) 1277 || addr < startLoc 1278 || addr + sizeof(unsigned long) < addr 1279 || addr + sizeof(unsigned long) > endLoc) 1280 return -EIO; 1281 1282 switch (reg_info[i].width) { 1283 case sizeof(u8): 1284 __get_user(FRAME_REG(i, u8), 1285 (u8 __user *)addr); 1286 break; 1287 case sizeof(u16): 1288 __get_user(FRAME_REG(i, u16), 1289 (u16 __user *)addr); 1290 break; 1291 case sizeof(u32): 1292 __get_user(FRAME_REG(i, u32), 1293 (u32 __user *)addr); 1294 break; 1295 #ifdef CONFIG_64BIT 1296 case sizeof(u64): 1297 __get_user(FRAME_REG(i, u64), 1298 (u64 __user *)addr); 1299 break; 1300 #endif 1301 default: 1302 return -EIO; 1303 } 1304 1305 break; 1306 } 1307 unw_debug("r%d: 0x%lx ", i, *fptr); 1308 } 1309 1310 return 0; 1311 #undef FRAME_REG 1312 } 1313 EXPORT_SYMBOL(arc_unwind); 1314