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