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