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 struct module_memory *core_text; 373 struct module_memory *init_text; 374 375 if (table_size <= 0) 376 return NULL; 377 378 table = kmalloc(sizeof(*table), GFP_KERNEL); 379 if (!table) 380 return NULL; 381 382 core_text = &module->mem[MOD_TEXT]; 383 init_text = &module->mem[MOD_INIT_TEXT]; 384 385 init_unwind_table(table, module->name, core_text->base, core_text->size, 386 init_text->base, init_text->size, table_start, table_size, NULL, 0); 387 388 init_unwind_hdr(table, unw_hdr_alloc); 389 390 #ifdef UNWIND_DEBUG 391 unw_debug("Table added for [%s] %lx %lx\n", 392 module->name, table->core.pc, table->core.range); 393 #endif 394 if (last_table) 395 last_table->link = table; 396 else 397 root_table.link = table; 398 last_table = table; 399 400 return table; 401 } 402 403 struct unlink_table_info { 404 struct unwind_table *table; 405 int init_only; 406 }; 407 408 static int unlink_table(void *arg) 409 { 410 struct unlink_table_info *info = arg; 411 struct unwind_table *table = info->table, *prev; 412 413 for (prev = &root_table; prev->link && prev->link != table; 414 prev = prev->link) 415 ; 416 417 if (prev->link) { 418 if (info->init_only) { 419 table->init.pc = 0; 420 table->init.range = 0; 421 info->table = NULL; 422 } else { 423 prev->link = table->link; 424 if (!prev->link) 425 last_table = prev; 426 } 427 } else 428 info->table = NULL; 429 430 return 0; 431 } 432 433 /* Must be called with module_mutex held. */ 434 void unwind_remove_table(void *handle, int init_only) 435 { 436 struct unwind_table *table = handle; 437 struct unlink_table_info info; 438 439 if (!table || table == &root_table) 440 return; 441 442 if (init_only && table == last_table) { 443 table->init.pc = 0; 444 table->init.range = 0; 445 return; 446 } 447 448 info.table = table; 449 info.init_only = init_only; 450 451 unlink_table(&info); /* XXX: SMP */ 452 kfree(table->header); 453 kfree(table); 454 } 455 456 #endif /* CONFIG_MODULES */ 457 458 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end) 459 { 460 const u8 *cur = *pcur; 461 uleb128_t value; 462 unsigned int shift; 463 464 for (shift = 0, value = 0; cur < end; shift += 7) { 465 if (shift + 7 > 8 * sizeof(value) 466 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) { 467 cur = end + 1; 468 break; 469 } 470 value |= (uleb128_t) (*cur & 0x7f) << shift; 471 if (!(*cur++ & 0x80)) 472 break; 473 } 474 *pcur = cur; 475 476 return value; 477 } 478 479 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end) 480 { 481 const u8 *cur = *pcur; 482 sleb128_t value; 483 unsigned int shift; 484 485 for (shift = 0, value = 0; cur < end; shift += 7) { 486 if (shift + 7 > 8 * sizeof(value) 487 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) { 488 cur = end + 1; 489 break; 490 } 491 value |= (sleb128_t) (*cur & 0x7f) << shift; 492 if (!(*cur & 0x80)) { 493 value |= -(*cur++ & 0x40) << shift; 494 break; 495 } 496 } 497 *pcur = cur; 498 499 return value; 500 } 501 502 static const u32 *__cie_for_fde(const u32 *fde) 503 { 504 const u32 *cie; 505 506 cie = fde + 1 - fde[1] / sizeof(*fde); 507 508 return cie; 509 } 510 511 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table) 512 { 513 const u32 *cie; 514 515 if (!*fde || (*fde & (sizeof(*fde) - 1))) 516 return &bad_cie; 517 518 if (fde[1] == CIE_ID) 519 return ¬_fde; /* this is a CIE */ 520 521 if ((fde[1] & (sizeof(*fde) - 1))) 522 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */ 523 return NULL; /* this is not a valid FDE */ 524 525 cie = __cie_for_fde(fde); 526 527 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde) 528 || (*cie & (sizeof(*cie) - 1)) 529 || (cie[1] != CIE_ID)) 530 return NULL; /* this is not a (valid) CIE */ 531 return cie; 532 } 533 534 static unsigned long read_pointer(const u8 **pLoc, const void *end, 535 signed ptrType) 536 { 537 unsigned long value = 0; 538 union { 539 const u8 *p8; 540 const u16 *p16u; 541 const s16 *p16s; 542 const u32 *p32u; 543 const s32 *p32s; 544 const unsigned long *pul; 545 } ptr; 546 547 if (ptrType < 0 || ptrType == DW_EH_PE_omit) 548 return 0; 549 ptr.p8 = *pLoc; 550 switch (ptrType & DW_EH_PE_FORM) { 551 case DW_EH_PE_data2: 552 if (end < (const void *)(ptr.p16u + 1)) 553 return 0; 554 if (ptrType & DW_EH_PE_signed) 555 value = get_unaligned((u16 *) ptr.p16s++); 556 else 557 value = get_unaligned((u16 *) ptr.p16u++); 558 break; 559 case DW_EH_PE_data4: 560 #ifdef CONFIG_64BIT 561 if (end < (const void *)(ptr.p32u + 1)) 562 return 0; 563 if (ptrType & DW_EH_PE_signed) 564 value = get_unaligned(ptr.p32s++); 565 else 566 value = get_unaligned(ptr.p32u++); 567 break; 568 case DW_EH_PE_data8: 569 BUILD_BUG_ON(sizeof(u64) != sizeof(value)); 570 #else 571 BUILD_BUG_ON(sizeof(u32) != sizeof(value)); 572 #endif 573 fallthrough; 574 case DW_EH_PE_native: 575 if (end < (const void *)(ptr.pul + 1)) 576 return 0; 577 value = get_unaligned((unsigned long *)ptr.pul++); 578 break; 579 case DW_EH_PE_leb128: 580 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value)); 581 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end) 582 : get_uleb128(&ptr.p8, end); 583 if ((const void *)ptr.p8 > end) 584 return 0; 585 break; 586 default: 587 return 0; 588 } 589 switch (ptrType & DW_EH_PE_ADJUST) { 590 case DW_EH_PE_abs: 591 break; 592 case DW_EH_PE_pcrel: 593 value += (unsigned long)*pLoc; 594 break; 595 default: 596 return 0; 597 } 598 if ((ptrType & DW_EH_PE_indirect) 599 && __get_user(value, (unsigned long __user *)value)) 600 return 0; 601 *pLoc = ptr.p8; 602 603 return value; 604 } 605 606 static signed fde_pointer_type(const u32 *cie) 607 { 608 const u8 *ptr = (const u8 *)(cie + 2); 609 unsigned int version = *ptr; 610 611 if (*++ptr) { 612 const char *aug; 613 const u8 *end = (const u8 *)(cie + 1) + *cie; 614 uleb128_t len; 615 616 /* check if augmentation size is first (and thus present) */ 617 if (*ptr != 'z') 618 return -1; 619 620 /* check if augmentation string is nul-terminated */ 621 aug = (const void *)ptr; 622 ptr = memchr(aug, 0, end - ptr); 623 if (ptr == NULL) 624 return -1; 625 626 ++ptr; /* skip terminator */ 627 get_uleb128(&ptr, end); /* skip code alignment */ 628 get_sleb128(&ptr, end); /* skip data alignment */ 629 /* skip return address column */ 630 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end); 631 len = get_uleb128(&ptr, end); /* augmentation length */ 632 633 if (ptr + len < ptr || ptr + len > end) 634 return -1; 635 636 end = ptr + len; 637 while (*++aug) { 638 if (ptr >= end) 639 return -1; 640 switch (*aug) { 641 case 'L': 642 ++ptr; 643 break; 644 case 'P':{ 645 signed ptrType = *ptr++; 646 647 if (!read_pointer(&ptr, end, ptrType) 648 || ptr > end) 649 return -1; 650 } 651 break; 652 case 'R': 653 return *ptr; 654 default: 655 return -1; 656 } 657 } 658 } 659 return DW_EH_PE_native | DW_EH_PE_abs; 660 } 661 662 static int advance_loc(unsigned long delta, struct unwind_state *state) 663 { 664 state->loc += delta * state->codeAlign; 665 666 /* FIXME_Rajesh: Probably we are defining for the initial range as well; 667 return delta > 0; 668 */ 669 unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc); 670 return 1; 671 } 672 673 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value, 674 struct unwind_state *state) 675 { 676 if (reg < ARRAY_SIZE(state->regs)) { 677 state->regs[reg].where = where; 678 state->regs[reg].value = value; 679 680 #ifdef UNWIND_DEBUG 681 unw_debug("r%lu: ", reg); 682 switch (where) { 683 case Nowhere: 684 unw_debug("s "); 685 break; 686 case Memory: 687 unw_debug("c(%lu) ", value); 688 break; 689 case Register: 690 unw_debug("r(%lu) ", value); 691 break; 692 case Value: 693 unw_debug("v(%lu) ", value); 694 break; 695 default: 696 break; 697 } 698 #endif 699 } 700 } 701 702 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc, 703 signed ptrType, struct unwind_state *state) 704 { 705 union { 706 const u8 *p8; 707 const u16 *p16; 708 const u32 *p32; 709 } ptr; 710 int result = 1; 711 u8 opcode; 712 713 if (start != state->cieStart) { 714 state->loc = state->org; 715 result = 716 processCFI(state->cieStart, state->cieEnd, 0, ptrType, 717 state); 718 if (targetLoc == 0 && state->label == NULL) 719 return result; 720 } 721 for (ptr.p8 = start; result && ptr.p8 < end;) { 722 switch (*ptr.p8 >> 6) { 723 uleb128_t value; 724 725 case 0: 726 opcode = *ptr.p8++; 727 728 switch (opcode) { 729 case DW_CFA_nop: 730 unw_debug("cfa nop "); 731 break; 732 case DW_CFA_set_loc: 733 state->loc = read_pointer(&ptr.p8, end, 734 ptrType); 735 if (state->loc == 0) 736 result = 0; 737 unw_debug("cfa_set_loc: 0x%lx ", state->loc); 738 break; 739 case DW_CFA_advance_loc1: 740 unw_debug("\ncfa advance loc1:"); 741 result = ptr.p8 < end 742 && advance_loc(*ptr.p8++, state); 743 break; 744 case DW_CFA_advance_loc2: 745 value = *ptr.p8++; 746 value += *ptr.p8++ << 8; 747 unw_debug("\ncfa advance loc2:"); 748 result = ptr.p8 <= end + 2 749 /* && advance_loc(*ptr.p16++, state); */ 750 && advance_loc(value, state); 751 break; 752 case DW_CFA_advance_loc4: 753 unw_debug("\ncfa advance loc4:"); 754 result = ptr.p8 <= end + 4 755 && advance_loc(*ptr.p32++, state); 756 break; 757 case DW_CFA_offset_extended: 758 value = get_uleb128(&ptr.p8, end); 759 unw_debug("cfa_offset_extended: "); 760 set_rule(value, Memory, 761 get_uleb128(&ptr.p8, end), state); 762 break; 763 case DW_CFA_val_offset: 764 value = get_uleb128(&ptr.p8, end); 765 set_rule(value, Value, 766 get_uleb128(&ptr.p8, end), state); 767 break; 768 case DW_CFA_offset_extended_sf: 769 value = get_uleb128(&ptr.p8, end); 770 set_rule(value, Memory, 771 get_sleb128(&ptr.p8, end), state); 772 break; 773 case DW_CFA_val_offset_sf: 774 value = get_uleb128(&ptr.p8, end); 775 set_rule(value, Value, 776 get_sleb128(&ptr.p8, end), state); 777 break; 778 case DW_CFA_restore_extended: 779 unw_debug("cfa_restore_extended: "); 780 case DW_CFA_undefined: 781 unw_debug("cfa_undefined: "); 782 case DW_CFA_same_value: 783 unw_debug("cfa_same_value: "); 784 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0, 785 state); 786 break; 787 case DW_CFA_register: 788 unw_debug("cfa_register: "); 789 value = get_uleb128(&ptr.p8, end); 790 set_rule(value, 791 Register, 792 get_uleb128(&ptr.p8, end), state); 793 break; 794 case DW_CFA_remember_state: 795 unw_debug("cfa_remember_state: "); 796 if (ptr.p8 == state->label) { 797 state->label = NULL; 798 return 1; 799 } 800 if (state->stackDepth >= MAX_STACK_DEPTH) 801 return 0; 802 state->stack[state->stackDepth++] = ptr.p8; 803 break; 804 case DW_CFA_restore_state: 805 unw_debug("cfa_restore_state: "); 806 if (state->stackDepth) { 807 const uleb128_t loc = state->loc; 808 const u8 *label = state->label; 809 810 state->label = 811 state->stack[state->stackDepth - 1]; 812 memcpy(&state->cfa, &badCFA, 813 sizeof(state->cfa)); 814 memset(state->regs, 0, 815 sizeof(state->regs)); 816 state->stackDepth = 0; 817 result = 818 processCFI(start, end, 0, ptrType, 819 state); 820 state->loc = loc; 821 state->label = label; 822 } else 823 return 0; 824 break; 825 case DW_CFA_def_cfa: 826 state->cfa.reg = get_uleb128(&ptr.p8, end); 827 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg); 828 fallthrough; 829 case DW_CFA_def_cfa_offset: 830 state->cfa.offs = get_uleb128(&ptr.p8, end); 831 unw_debug("cfa_def_cfa_offset: 0x%lx ", 832 state->cfa.offs); 833 break; 834 case DW_CFA_def_cfa_sf: 835 state->cfa.reg = get_uleb128(&ptr.p8, end); 836 fallthrough; 837 case DW_CFA_def_cfa_offset_sf: 838 state->cfa.offs = get_sleb128(&ptr.p8, end) 839 * state->dataAlign; 840 break; 841 case DW_CFA_def_cfa_register: 842 unw_debug("cfa_def_cfa_register: "); 843 state->cfa.reg = get_uleb128(&ptr.p8, end); 844 break; 845 /*todo case DW_CFA_def_cfa_expression: */ 846 /*todo case DW_CFA_expression: */ 847 /*todo case DW_CFA_val_expression: */ 848 case DW_CFA_GNU_args_size: 849 get_uleb128(&ptr.p8, end); 850 break; 851 case DW_CFA_GNU_negative_offset_extended: 852 value = get_uleb128(&ptr.p8, end); 853 set_rule(value, 854 Memory, 855 (uleb128_t) 0 - get_uleb128(&ptr.p8, 856 end), 857 state); 858 break; 859 case DW_CFA_GNU_window_save: 860 default: 861 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode); 862 result = 0; 863 break; 864 } 865 break; 866 case 1: 867 unw_debug("\ncfa_adv_loc: "); 868 result = advance_loc(*ptr.p8++ & 0x3f, state); 869 break; 870 case 2: 871 unw_debug("cfa_offset: "); 872 value = *ptr.p8++ & 0x3f; 873 set_rule(value, Memory, get_uleb128(&ptr.p8, end), 874 state); 875 break; 876 case 3: 877 unw_debug("cfa_restore: "); 878 set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state); 879 break; 880 } 881 882 if (ptr.p8 > end) 883 result = 0; 884 if (result && targetLoc != 0 && targetLoc < state->loc) 885 return 1; 886 } 887 888 return result && ptr.p8 == end && (targetLoc == 0 || ( 889 /*todo While in theory this should apply, gcc in practice omits 890 everything past the function prolog, and hence the location 891 never reaches the end of the function. 892 targetLoc < state->loc && */ state->label == NULL)); 893 } 894 895 /* Unwind to previous to frame. Returns 0 if successful, negative 896 * number in case of an error. */ 897 int arc_unwind(struct unwind_frame_info *frame) 898 { 899 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs]) 900 const u32 *fde = NULL, *cie = NULL; 901 const u8 *ptr = NULL, *end = NULL; 902 unsigned long pc = UNW_PC(frame) - frame->call_frame; 903 unsigned long startLoc = 0, endLoc = 0, cfa; 904 unsigned int i; 905 signed ptrType = -1; 906 uleb128_t retAddrReg = 0; 907 const struct unwind_table *table; 908 struct unwind_state state; 909 unsigned long *fptr; 910 unsigned long addr; 911 912 unw_debug("\n\nUNWIND FRAME:\n"); 913 unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n", 914 UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame), 915 UNW_FP(frame)); 916 917 if (UNW_PC(frame) == 0) 918 return -EINVAL; 919 920 #ifdef UNWIND_DEBUG 921 { 922 unsigned long *sptr = (unsigned long *)UNW_SP(frame); 923 unw_debug("\nStack Dump:\n"); 924 for (i = 0; i < 20; i++, sptr++) 925 unw_debug("0x%p: 0x%lx\n", sptr, *sptr); 926 unw_debug("\n"); 927 } 928 #endif 929 930 table = find_table(pc); 931 if (table != NULL 932 && !(table->size & (sizeof(*fde) - 1))) { 933 const u8 *hdr = table->header; 934 unsigned long tableSize; 935 936 smp_rmb(); 937 if (hdr && hdr[0] == 1) { 938 switch (hdr[3] & DW_EH_PE_FORM) { 939 case DW_EH_PE_native: 940 tableSize = sizeof(unsigned long); 941 break; 942 case DW_EH_PE_data2: 943 tableSize = 2; 944 break; 945 case DW_EH_PE_data4: 946 tableSize = 4; 947 break; 948 case DW_EH_PE_data8: 949 tableSize = 8; 950 break; 951 default: 952 tableSize = 0; 953 break; 954 } 955 ptr = hdr + 4; 956 end = hdr + table->hdrsz; 957 if (tableSize && read_pointer(&ptr, end, hdr[1]) 958 == (unsigned long)table->address 959 && (i = read_pointer(&ptr, end, hdr[2])) > 0 960 && i == (end - ptr) / (2 * tableSize) 961 && !((end - ptr) % (2 * tableSize))) { 962 do { 963 const u8 *cur = 964 ptr + (i / 2) * (2 * tableSize); 965 966 startLoc = read_pointer(&cur, 967 cur + tableSize, 968 hdr[3]); 969 if (pc < startLoc) 970 i /= 2; 971 else { 972 ptr = cur - tableSize; 973 i = (i + 1) / 2; 974 } 975 } while (startLoc && i > 1); 976 if (i == 1 977 && (startLoc = read_pointer(&ptr, 978 ptr + tableSize, 979 hdr[3])) != 0 980 && pc >= startLoc) 981 fde = (void *)read_pointer(&ptr, 982 ptr + 983 tableSize, 984 hdr[3]); 985 } 986 } 987 988 if (fde != NULL) { 989 cie = cie_for_fde(fde, table); 990 ptr = (const u8 *)(fde + 2); 991 if (cie != NULL 992 && cie != &bad_cie 993 && cie != ¬_fde 994 && (ptrType = fde_pointer_type(cie)) >= 0 995 && read_pointer(&ptr, 996 (const u8 *)(fde + 1) + *fde, 997 ptrType) == startLoc) { 998 if (!(ptrType & DW_EH_PE_indirect)) 999 ptrType &= 1000 DW_EH_PE_FORM | DW_EH_PE_signed; 1001 endLoc = 1002 startLoc + read_pointer(&ptr, 1003 (const u8 *)(fde + 1004 1) + 1005 *fde, ptrType); 1006 if (pc >= endLoc) { 1007 fde = NULL; 1008 cie = NULL; 1009 } 1010 } else { 1011 fde = NULL; 1012 cie = NULL; 1013 } 1014 } 1015 } 1016 if (cie != NULL) { 1017 memset(&state, 0, sizeof(state)); 1018 state.cieEnd = ptr; /* keep here temporarily */ 1019 ptr = (const u8 *)(cie + 2); 1020 end = (const u8 *)(cie + 1) + *cie; 1021 frame->call_frame = 1; 1022 if (*++ptr) { 1023 /* check if augmentation size is first (thus present) */ 1024 if (*ptr == 'z') { 1025 while (++ptr < end && *ptr) { 1026 switch (*ptr) { 1027 /* chk for ignorable or already handled 1028 * nul-terminated augmentation string */ 1029 case 'L': 1030 case 'P': 1031 case 'R': 1032 continue; 1033 case 'S': 1034 frame->call_frame = 0; 1035 continue; 1036 default: 1037 break; 1038 } 1039 break; 1040 } 1041 } 1042 if (ptr >= end || *ptr) 1043 cie = NULL; 1044 } 1045 ++ptr; 1046 } 1047 if (cie != NULL) { 1048 /* get code alignment factor */ 1049 state.codeAlign = get_uleb128(&ptr, end); 1050 /* get data alignment factor */ 1051 state.dataAlign = get_sleb128(&ptr, end); 1052 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end) 1053 cie = NULL; 1054 else { 1055 retAddrReg = 1056 state.version <= 1 ? *ptr++ : get_uleb128(&ptr, 1057 end); 1058 unw_debug("CIE Frame Info:\n"); 1059 unw_debug("return Address register 0x%lx\n", 1060 retAddrReg); 1061 unw_debug("data Align: %ld\n", state.dataAlign); 1062 unw_debug("code Align: %lu\n", state.codeAlign); 1063 /* skip augmentation */ 1064 if (((const char *)(cie + 2))[1] == 'z') { 1065 uleb128_t augSize = get_uleb128(&ptr, end); 1066 1067 ptr += augSize; 1068 } 1069 if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info) 1070 || REG_INVALID(retAddrReg) 1071 || reg_info[retAddrReg].width != 1072 sizeof(unsigned long)) 1073 cie = NULL; 1074 } 1075 } 1076 if (cie != NULL) { 1077 state.cieStart = ptr; 1078 ptr = state.cieEnd; 1079 state.cieEnd = end; 1080 end = (const u8 *)(fde + 1) + *fde; 1081 /* skip augmentation */ 1082 if (((const char *)(cie + 2))[1] == 'z') { 1083 uleb128_t augSize = get_uleb128(&ptr, end); 1084 1085 if ((ptr += augSize) > end) 1086 fde = NULL; 1087 } 1088 } 1089 if (cie == NULL || fde == NULL) { 1090 #ifdef CONFIG_FRAME_POINTER 1091 unsigned long top, bottom; 1092 1093 top = STACK_TOP_UNW(frame->task); 1094 bottom = STACK_BOTTOM_UNW(frame->task); 1095 #if FRAME_RETADDR_OFFSET < 0 1096 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame) 1097 && bottom < UNW_FP(frame) 1098 #else 1099 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame) 1100 && bottom > UNW_FP(frame) 1101 #endif 1102 && !((UNW_SP(frame) | UNW_FP(frame)) 1103 & (sizeof(unsigned long) - 1))) { 1104 unsigned long link; 1105 1106 if (!__get_user(link, (unsigned long *) 1107 (UNW_FP(frame) + FRAME_LINK_OFFSET)) 1108 #if FRAME_RETADDR_OFFSET < 0 1109 && link > bottom && link < UNW_FP(frame) 1110 #else 1111 && link > UNW_FP(frame) && link < bottom 1112 #endif 1113 && !(link & (sizeof(link) - 1)) 1114 && !__get_user(UNW_PC(frame), 1115 (unsigned long *)(UNW_FP(frame) 1116 + FRAME_RETADDR_OFFSET))) 1117 { 1118 UNW_SP(frame) = 1119 UNW_FP(frame) + FRAME_RETADDR_OFFSET 1120 #if FRAME_RETADDR_OFFSET < 0 1121 - 1122 #else 1123 + 1124 #endif 1125 sizeof(UNW_PC(frame)); 1126 UNW_FP(frame) = link; 1127 return 0; 1128 } 1129 } 1130 #endif 1131 return -ENXIO; 1132 } 1133 state.org = startLoc; 1134 memcpy(&state.cfa, &badCFA, sizeof(state.cfa)); 1135 1136 unw_debug("\nProcess instructions\n"); 1137 1138 /* process instructions 1139 * For ARC, we optimize by having blink(retAddrReg) with 1140 * the sameValue in the leaf function, so we should not check 1141 * state.regs[retAddrReg].where == Nowhere 1142 */ 1143 if (!processCFI(ptr, end, pc, ptrType, &state) 1144 || state.loc > endLoc 1145 /* || state.regs[retAddrReg].where == Nowhere */ 1146 || state.cfa.reg >= ARRAY_SIZE(reg_info) 1147 || reg_info[state.cfa.reg].width != sizeof(unsigned long) 1148 || state.cfa.offs % sizeof(unsigned long)) 1149 return -EIO; 1150 1151 #ifdef UNWIND_DEBUG 1152 unw_debug("\n"); 1153 1154 unw_debug("\nRegister State Based on the rules parsed from FDE:\n"); 1155 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) { 1156 1157 if (REG_INVALID(i)) 1158 continue; 1159 1160 switch (state.regs[i].where) { 1161 case Nowhere: 1162 break; 1163 case Memory: 1164 unw_debug(" r%d: c(%lu),", i, state.regs[i].value); 1165 break; 1166 case Register: 1167 unw_debug(" r%d: r(%lu),", i, state.regs[i].value); 1168 break; 1169 case Value: 1170 unw_debug(" r%d: v(%lu),", i, state.regs[i].value); 1171 break; 1172 } 1173 } 1174 1175 unw_debug("\n"); 1176 #endif 1177 1178 /* update frame */ 1179 if (frame->call_frame 1180 && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign)) 1181 frame->call_frame = 0; 1182 cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs; 1183 startLoc = min_t(unsigned long, UNW_SP(frame), cfa); 1184 endLoc = max_t(unsigned long, UNW_SP(frame), cfa); 1185 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) { 1186 startLoc = min(STACK_LIMIT(cfa), cfa); 1187 endLoc = max(STACK_LIMIT(cfa), cfa); 1188 } 1189 1190 unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx => 0x%lx\n", 1191 state.cfa.reg, state.cfa.offs, cfa); 1192 1193 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) { 1194 if (REG_INVALID(i)) { 1195 if (state.regs[i].where == Nowhere) 1196 continue; 1197 return -EIO; 1198 } 1199 switch (state.regs[i].where) { 1200 default: 1201 break; 1202 case Register: 1203 if (state.regs[i].value >= ARRAY_SIZE(reg_info) 1204 || REG_INVALID(state.regs[i].value) 1205 || reg_info[i].width > 1206 reg_info[state.regs[i].value].width) 1207 return -EIO; 1208 switch (reg_info[state.regs[i].value].width) { 1209 case sizeof(u8): 1210 state.regs[i].value = 1211 FRAME_REG(state.regs[i].value, const u8); 1212 break; 1213 case sizeof(u16): 1214 state.regs[i].value = 1215 FRAME_REG(state.regs[i].value, const u16); 1216 break; 1217 case sizeof(u32): 1218 state.regs[i].value = 1219 FRAME_REG(state.regs[i].value, const u32); 1220 break; 1221 #ifdef CONFIG_64BIT 1222 case sizeof(u64): 1223 state.regs[i].value = 1224 FRAME_REG(state.regs[i].value, const u64); 1225 break; 1226 #endif 1227 default: 1228 return -EIO; 1229 } 1230 break; 1231 } 1232 } 1233 1234 unw_debug("\nRegister state after evaluation with realtime Stack:\n"); 1235 fptr = (unsigned long *)(&frame->regs); 1236 for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) { 1237 1238 if (REG_INVALID(i)) 1239 continue; 1240 switch (state.regs[i].where) { 1241 case Nowhere: 1242 if (reg_info[i].width != sizeof(UNW_SP(frame)) 1243 || &FRAME_REG(i, __typeof__(UNW_SP(frame))) 1244 != &UNW_SP(frame)) 1245 continue; 1246 UNW_SP(frame) = cfa; 1247 break; 1248 case Register: 1249 switch (reg_info[i].width) { 1250 case sizeof(u8): 1251 FRAME_REG(i, u8) = state.regs[i].value; 1252 break; 1253 case sizeof(u16): 1254 FRAME_REG(i, u16) = state.regs[i].value; 1255 break; 1256 case sizeof(u32): 1257 FRAME_REG(i, u32) = state.regs[i].value; 1258 break; 1259 #ifdef CONFIG_64BIT 1260 case sizeof(u64): 1261 FRAME_REG(i, u64) = state.regs[i].value; 1262 break; 1263 #endif 1264 default: 1265 return -EIO; 1266 } 1267 break; 1268 case Value: 1269 if (reg_info[i].width != sizeof(unsigned long)) 1270 return -EIO; 1271 FRAME_REG(i, unsigned long) = cfa + state.regs[i].value 1272 * state.dataAlign; 1273 break; 1274 case Memory: 1275 addr = cfa + state.regs[i].value * state.dataAlign; 1276 1277 if ((state.regs[i].value * state.dataAlign) 1278 % sizeof(unsigned long) 1279 || addr < startLoc 1280 || addr + sizeof(unsigned long) < addr 1281 || addr + sizeof(unsigned long) > endLoc) 1282 return -EIO; 1283 1284 switch (reg_info[i].width) { 1285 case sizeof(u8): 1286 __get_user(FRAME_REG(i, u8), 1287 (u8 __user *)addr); 1288 break; 1289 case sizeof(u16): 1290 __get_user(FRAME_REG(i, u16), 1291 (u16 __user *)addr); 1292 break; 1293 case sizeof(u32): 1294 __get_user(FRAME_REG(i, u32), 1295 (u32 __user *)addr); 1296 break; 1297 #ifdef CONFIG_64BIT 1298 case sizeof(u64): 1299 __get_user(FRAME_REG(i, u64), 1300 (u64 __user *)addr); 1301 break; 1302 #endif 1303 default: 1304 return -EIO; 1305 } 1306 1307 break; 1308 } 1309 unw_debug("r%d: 0x%lx ", i, *fptr); 1310 } 1311 1312 return 0; 1313 #undef FRAME_REG 1314 } 1315 EXPORT_SYMBOL(arc_unwind); 1316