2 * Copyright (C) 2009 Matt Fleming <matt@console-pimps.org>
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License. See the file "COPYING" in the main directory of this archive
8 * This is an implementation of a DWARF unwinder. Its main purpose is
9 * for generating stacktrace information. Based on the DWARF 3
10 * specification from http://www.dwarfstd.org.
13 * - DWARF64 doesn't work.
14 * - Registers with DWARF_VAL_OFFSET rules aren't handled properly.
18 #include <linux/kernel.h>
20 #include <linux/list.h>
21 #include <linux/mempool.h>
23 #include <linux/elf.h>
24 #include <linux/ftrace.h>
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <asm/dwarf.h>
28 #include <asm/unwinder.h>
29 #include <asm/sections.h>
30 #include <asm/unaligned.h>
31 #include <asm/stacktrace.h>
33 /* Reserve enough memory for two stack frames */
34 #define DWARF_FRAME_MIN_REQ 2
35 /* ... with 4 registers per frame. */
36 #define DWARF_REG_MIN_REQ (DWARF_FRAME_MIN_REQ * 4)
38 static struct kmem_cache
*dwarf_frame_cachep
;
39 static mempool_t
*dwarf_frame_pool
;
41 static struct kmem_cache
*dwarf_reg_cachep
;
42 static mempool_t
*dwarf_reg_pool
;
44 static struct rb_root cie_root
;
45 static DEFINE_SPINLOCK(dwarf_cie_lock
);
47 static struct rb_root fde_root
;
48 static DEFINE_SPINLOCK(dwarf_fde_lock
);
50 static struct dwarf_cie
*cached_cie
;
53 * dwarf_frame_alloc_reg - allocate memory for a DWARF register
54 * @frame: the DWARF frame whose list of registers we insert on
55 * @reg_num: the register number
57 * Allocate space for, and initialise, a dwarf reg from
58 * dwarf_reg_pool and insert it onto the (unsorted) linked-list of
59 * dwarf registers for @frame.
61 * Return the initialised DWARF reg.
63 static struct dwarf_reg
*dwarf_frame_alloc_reg(struct dwarf_frame
*frame
,
66 struct dwarf_reg
*reg
;
68 reg
= mempool_alloc(dwarf_reg_pool
, GFP_ATOMIC
);
70 printk(KERN_WARNING
"Unable to allocate a DWARF register\n");
72 * Let's just bomb hard here, we have no way to
78 reg
->number
= reg_num
;
82 list_add(®
->link
, &frame
->reg_list
);
87 static void dwarf_frame_free_regs(struct dwarf_frame
*frame
)
89 struct dwarf_reg
*reg
, *n
;
91 list_for_each_entry_safe(reg
, n
, &frame
->reg_list
, link
) {
93 mempool_free(reg
, dwarf_reg_pool
);
98 * dwarf_frame_reg - return a DWARF register
99 * @frame: the DWARF frame to search in for @reg_num
100 * @reg_num: the register number to search for
102 * Lookup and return the dwarf reg @reg_num for this frame. Return
103 * NULL if @reg_num is an register invalid number.
105 static struct dwarf_reg
*dwarf_frame_reg(struct dwarf_frame
*frame
,
106 unsigned int reg_num
)
108 struct dwarf_reg
*reg
;
110 list_for_each_entry(reg
, &frame
->reg_list
, link
) {
111 if (reg
->number
== reg_num
)
119 * dwarf_read_addr - read dwarf data
120 * @src: source address of data
121 * @dst: destination address to store the data to
123 * Read 'n' bytes from @src, where 'n' is the size of an address on
124 * the native machine. We return the number of bytes read, which
125 * should always be 'n'. We also have to be careful when reading
126 * from @src and writing to @dst, because they can be arbitrarily
127 * aligned. Return 'n' - the number of bytes read.
129 static inline int dwarf_read_addr(unsigned long *src
, unsigned long *dst
)
131 u32 val
= get_unaligned(src
);
132 put_unaligned(val
, dst
);
133 return sizeof(unsigned long *);
137 * dwarf_read_uleb128 - read unsigned LEB128 data
138 * @addr: the address where the ULEB128 data is stored
139 * @ret: address to store the result
141 * Decode an unsigned LEB128 encoded datum. The algorithm is taken
142 * from Appendix C of the DWARF 3 spec. For information on the
143 * encodings refer to section "7.6 - Variable Length Data". Return
144 * the number of bytes read.
146 static inline unsigned long dwarf_read_uleb128(char *addr
, unsigned int *ret
)
157 byte
= __raw_readb(addr
);
161 result
|= (byte
& 0x7f) << shift
;
174 * dwarf_read_leb128 - read signed LEB128 data
175 * @addr: the address of the LEB128 encoded data
176 * @ret: address to store the result
178 * Decode signed LEB128 data. The algorithm is taken from Appendix
179 * C of the DWARF 3 spec. Return the number of bytes read.
181 static inline unsigned long dwarf_read_leb128(char *addr
, int *ret
)
193 byte
= __raw_readb(addr
);
195 result
|= (byte
& 0x7f) << shift
;
203 /* The number of bits in a signed integer. */
204 num_bits
= 8 * sizeof(result
);
206 if ((shift
< num_bits
) && (byte
& 0x40))
207 result
|= (-1 << shift
);
215 * dwarf_read_encoded_value - return the decoded value at @addr
216 * @addr: the address of the encoded value
217 * @val: where to write the decoded value
218 * @encoding: the encoding with which we can decode @addr
220 * GCC emits encoded address in the .eh_frame FDE entries. Decode
221 * the value at @addr using @encoding. The decoded value is written
222 * to @val and the number of bytes read is returned.
224 static int dwarf_read_encoded_value(char *addr
, unsigned long *val
,
227 unsigned long decoded_addr
= 0;
230 switch (encoding
& 0x70) {
231 case DW_EH_PE_absptr
:
234 decoded_addr
= (unsigned long)addr
;
237 pr_debug("encoding=0x%x\n", (encoding
& 0x70));
241 if ((encoding
& 0x07) == 0x00)
242 encoding
|= DW_EH_PE_udata4
;
244 switch (encoding
& 0x0f) {
245 case DW_EH_PE_sdata4
:
246 case DW_EH_PE_udata4
:
248 decoded_addr
+= get_unaligned((u32
*)addr
);
249 __raw_writel(decoded_addr
, val
);
252 pr_debug("encoding=0x%x\n", encoding
);
260 * dwarf_entry_len - return the length of an FDE or CIE
261 * @addr: the address of the entry
262 * @len: the length of the entry
264 * Read the initial_length field of the entry and store the size of
265 * the entry in @len. We return the number of bytes read. Return a
266 * count of 0 on error.
268 static inline int dwarf_entry_len(char *addr
, unsigned long *len
)
273 initial_len
= get_unaligned((u32
*)addr
);
277 * An initial length field value in the range DW_LEN_EXT_LO -
278 * DW_LEN_EXT_HI indicates an extension, and should not be
279 * interpreted as a length. The only extension that we currently
280 * understand is the use of DWARF64 addresses.
282 if (initial_len
>= DW_EXT_LO
&& initial_len
<= DW_EXT_HI
) {
284 * The 64-bit length field immediately follows the
285 * compulsory 32-bit length field.
287 if (initial_len
== DW_EXT_DWARF64
) {
288 *len
= get_unaligned((u64
*)addr
+ 4);
291 printk(KERN_WARNING
"Unknown DWARF extension\n");
301 * dwarf_lookup_cie - locate the cie
302 * @cie_ptr: pointer to help with lookup
304 static struct dwarf_cie
*dwarf_lookup_cie(unsigned long cie_ptr
)
306 struct rb_node
**rb_node
= &cie_root
.rb_node
;
307 struct dwarf_cie
*cie
= NULL
;
310 spin_lock_irqsave(&dwarf_cie_lock
, flags
);
313 * We've cached the last CIE we looked up because chances are
314 * that the FDE wants this CIE.
316 if (cached_cie
&& cached_cie
->cie_pointer
== cie_ptr
) {
322 struct dwarf_cie
*cie_tmp
;
324 cie_tmp
= rb_entry(*rb_node
, struct dwarf_cie
, node
);
327 if (cie_ptr
== cie_tmp
->cie_pointer
) {
329 cached_cie
= cie_tmp
;
332 if (cie_ptr
< cie_tmp
->cie_pointer
)
333 rb_node
= &(*rb_node
)->rb_left
;
335 rb_node
= &(*rb_node
)->rb_right
;
340 spin_unlock_irqrestore(&dwarf_cie_lock
, flags
);
345 * dwarf_lookup_fde - locate the FDE that covers pc
346 * @pc: the program counter
348 struct dwarf_fde
*dwarf_lookup_fde(unsigned long pc
)
350 struct rb_node
**rb_node
= &fde_root
.rb_node
;
351 struct dwarf_fde
*fde
= NULL
;
354 spin_lock_irqsave(&dwarf_fde_lock
, flags
);
357 struct dwarf_fde
*fde_tmp
;
358 unsigned long tmp_start
, tmp_end
;
360 fde_tmp
= rb_entry(*rb_node
, struct dwarf_fde
, node
);
363 tmp_start
= fde_tmp
->initial_location
;
364 tmp_end
= fde_tmp
->initial_location
+ fde_tmp
->address_range
;
366 if (pc
< tmp_start
) {
367 rb_node
= &(*rb_node
)->rb_left
;
373 rb_node
= &(*rb_node
)->rb_right
;
378 spin_unlock_irqrestore(&dwarf_fde_lock
, flags
);
384 * dwarf_cfa_execute_insns - execute instructions to calculate a CFA
385 * @insn_start: address of the first instruction
386 * @insn_end: address of the last instruction
387 * @cie: the CIE for this function
388 * @fde: the FDE for this function
389 * @frame: the instructions calculate the CFA for this frame
390 * @pc: the program counter of the address we're interested in
392 * Execute the Call Frame instruction sequence starting at
393 * @insn_start and ending at @insn_end. The instructions describe
394 * how to calculate the Canonical Frame Address of a stackframe.
395 * Store the results in @frame.
397 static int dwarf_cfa_execute_insns(unsigned char *insn_start
,
398 unsigned char *insn_end
,
399 struct dwarf_cie
*cie
,
400 struct dwarf_fde
*fde
,
401 struct dwarf_frame
*frame
,
405 unsigned char *current_insn
;
406 unsigned int count
, delta
, reg
, expr_len
, offset
;
407 struct dwarf_reg
*regp
;
409 current_insn
= insn_start
;
411 while (current_insn
< insn_end
&& frame
->pc
<= pc
) {
412 insn
= __raw_readb(current_insn
++);
415 * Firstly, handle the opcodes that embed their operands
416 * in the instructions.
418 switch (DW_CFA_opcode(insn
)) {
419 case DW_CFA_advance_loc
:
420 delta
= DW_CFA_operand(insn
);
421 delta
*= cie
->code_alignment_factor
;
426 reg
= DW_CFA_operand(insn
);
427 count
= dwarf_read_uleb128(current_insn
, &offset
);
428 current_insn
+= count
;
429 offset
*= cie
->data_alignment_factor
;
430 regp
= dwarf_frame_alloc_reg(frame
, reg
);
432 regp
->flags
|= DWARF_REG_OFFSET
;
436 reg
= DW_CFA_operand(insn
);
442 * Secondly, handle the opcodes that don't embed their
443 * operands in the instruction.
448 case DW_CFA_advance_loc1
:
449 delta
= *current_insn
++;
450 frame
->pc
+= delta
* cie
->code_alignment_factor
;
452 case DW_CFA_advance_loc2
:
453 delta
= get_unaligned((u16
*)current_insn
);
455 frame
->pc
+= delta
* cie
->code_alignment_factor
;
457 case DW_CFA_advance_loc4
:
458 delta
= get_unaligned((u32
*)current_insn
);
460 frame
->pc
+= delta
* cie
->code_alignment_factor
;
462 case DW_CFA_offset_extended
:
463 count
= dwarf_read_uleb128(current_insn
, ®
);
464 current_insn
+= count
;
465 count
= dwarf_read_uleb128(current_insn
, &offset
);
466 current_insn
+= count
;
467 offset
*= cie
->data_alignment_factor
;
469 case DW_CFA_restore_extended
:
470 count
= dwarf_read_uleb128(current_insn
, ®
);
471 current_insn
+= count
;
473 case DW_CFA_undefined
:
474 count
= dwarf_read_uleb128(current_insn
, ®
);
475 current_insn
+= count
;
476 regp
= dwarf_frame_alloc_reg(frame
, reg
);
477 regp
->flags
|= DWARF_UNDEFINED
;
480 count
= dwarf_read_uleb128(current_insn
,
481 &frame
->cfa_register
);
482 current_insn
+= count
;
483 count
= dwarf_read_uleb128(current_insn
,
485 current_insn
+= count
;
487 frame
->flags
|= DWARF_FRAME_CFA_REG_OFFSET
;
489 case DW_CFA_def_cfa_register
:
490 count
= dwarf_read_uleb128(current_insn
,
491 &frame
->cfa_register
);
492 current_insn
+= count
;
493 frame
->flags
|= DWARF_FRAME_CFA_REG_OFFSET
;
495 case DW_CFA_def_cfa_offset
:
496 count
= dwarf_read_uleb128(current_insn
, &offset
);
497 current_insn
+= count
;
498 frame
->cfa_offset
= offset
;
500 case DW_CFA_def_cfa_expression
:
501 count
= dwarf_read_uleb128(current_insn
, &expr_len
);
502 current_insn
+= count
;
504 frame
->cfa_expr
= current_insn
;
505 frame
->cfa_expr_len
= expr_len
;
506 current_insn
+= expr_len
;
508 frame
->flags
|= DWARF_FRAME_CFA_REG_EXP
;
510 case DW_CFA_offset_extended_sf
:
511 count
= dwarf_read_uleb128(current_insn
, ®
);
512 current_insn
+= count
;
513 count
= dwarf_read_leb128(current_insn
, &offset
);
514 current_insn
+= count
;
515 offset
*= cie
->data_alignment_factor
;
516 regp
= dwarf_frame_alloc_reg(frame
, reg
);
517 regp
->flags
|= DWARF_REG_OFFSET
;
520 case DW_CFA_val_offset
:
521 count
= dwarf_read_uleb128(current_insn
, ®
);
522 current_insn
+= count
;
523 count
= dwarf_read_leb128(current_insn
, &offset
);
524 offset
*= cie
->data_alignment_factor
;
525 regp
= dwarf_frame_alloc_reg(frame
, reg
);
526 regp
->flags
|= DWARF_VAL_OFFSET
;
529 case DW_CFA_GNU_args_size
:
530 count
= dwarf_read_uleb128(current_insn
, &offset
);
531 current_insn
+= count
;
533 case DW_CFA_GNU_negative_offset_extended
:
534 count
= dwarf_read_uleb128(current_insn
, ®
);
535 current_insn
+= count
;
536 count
= dwarf_read_uleb128(current_insn
, &offset
);
537 offset
*= cie
->data_alignment_factor
;
539 regp
= dwarf_frame_alloc_reg(frame
, reg
);
540 regp
->flags
|= DWARF_REG_OFFSET
;
541 regp
->addr
= -offset
;
544 pr_debug("unhandled DWARF instruction 0x%x\n", insn
);
554 * dwarf_free_frame - free the memory allocated for @frame
555 * @frame: the frame to free
557 void dwarf_free_frame(struct dwarf_frame
*frame
)
559 dwarf_frame_free_regs(frame
);
560 mempool_free(frame
, dwarf_frame_pool
);
563 extern void ret_from_irq(void);
566 * dwarf_unwind_stack - unwind the stack
568 * @pc: address of the function to unwind
569 * @prev: struct dwarf_frame of the previous stackframe on the callstack
571 * Return a struct dwarf_frame representing the most recent frame
572 * on the callstack. Each of the lower (older) stack frames are
573 * linked via the "prev" member.
575 struct dwarf_frame
*dwarf_unwind_stack(unsigned long pc
,
576 struct dwarf_frame
*prev
)
578 struct dwarf_frame
*frame
;
579 struct dwarf_cie
*cie
;
580 struct dwarf_fde
*fde
;
581 struct dwarf_reg
*reg
;
585 * If we're starting at the top of the stack we need get the
586 * contents of a physical register to get the CFA in order to
587 * begin the virtual unwinding of the stack.
589 * NOTE: the return address is guaranteed to be setup by the
590 * time this function makes its first function call.
593 pc
= (unsigned long)current_text_addr();
595 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
597 * If our stack has been patched by the function graph tracer
598 * then we might see the address of return_to_handler() where we
599 * expected to find the real return address.
601 if (pc
== (unsigned long)&return_to_handler
) {
602 int index
= current
->curr_ret_stack
;
605 * We currently have no way of tracking how many
606 * return_to_handler()'s we've seen. If there is more
607 * than one patched return address on our stack,
612 pc
= current
->ret_stack
[index
].ret
;
616 frame
= mempool_alloc(dwarf_frame_pool
, GFP_ATOMIC
);
618 printk(KERN_ERR
"Unable to allocate a dwarf frame\n");
622 INIT_LIST_HEAD(&frame
->reg_list
);
625 frame
->return_addr
= 0;
627 fde
= dwarf_lookup_fde(pc
);
630 * This is our normal exit path. There are two reasons
631 * why we might exit here,
633 * a) pc has no asscociated DWARF frame info and so
634 * we don't know how to unwind this frame. This is
635 * usually the case when we're trying to unwind a
636 * frame that was called from some assembly code
637 * that has no DWARF info, e.g. syscalls.
639 * b) the DEBUG info for pc is bogus. There's
640 * really no way to distinguish this case from the
641 * case above, which sucks because we could print a
647 cie
= dwarf_lookup_cie(fde
->cie_pointer
);
649 frame
->pc
= fde
->initial_location
;
651 /* CIE initial instructions */
652 dwarf_cfa_execute_insns(cie
->initial_instructions
,
653 cie
->instructions_end
, cie
, fde
,
656 /* FDE instructions */
657 dwarf_cfa_execute_insns(fde
->instructions
, fde
->end
, cie
,
660 /* Calculate the CFA */
661 switch (frame
->flags
) {
662 case DWARF_FRAME_CFA_REG_OFFSET
:
664 reg
= dwarf_frame_reg(prev
, frame
->cfa_register
);
665 UNWINDER_BUG_ON(!reg
);
666 UNWINDER_BUG_ON(reg
->flags
!= DWARF_REG_OFFSET
);
668 addr
= prev
->cfa
+ reg
->addr
;
669 frame
->cfa
= __raw_readl(addr
);
673 * Again, we're starting from the top of the
674 * stack. We need to physically read
675 * the contents of a register in order to get
676 * the Canonical Frame Address for this
679 frame
->cfa
= dwarf_read_arch_reg(frame
->cfa_register
);
682 frame
->cfa
+= frame
->cfa_offset
;
688 reg
= dwarf_frame_reg(frame
, DWARF_ARCH_RA_REG
);
691 * If we haven't seen the return address register or the return
692 * address column is undefined then we must assume that this is
693 * the end of the callstack.
695 if (!reg
|| reg
->flags
== DWARF_UNDEFINED
)
698 UNWINDER_BUG_ON(reg
->flags
!= DWARF_REG_OFFSET
);
700 addr
= frame
->cfa
+ reg
->addr
;
701 frame
->return_addr
= __raw_readl(addr
);
704 * Ah, the joys of unwinding through interrupts.
706 * Interrupts are tricky - the DWARF info needs to be _really_
707 * accurate and unfortunately I'm seeing a lot of bogus DWARF
708 * info. For example, I've seen interrupts occur in epilogues
709 * just after the frame pointer (r14) had been restored. The
710 * problem was that the DWARF info claimed that the CFA could be
711 * reached by using the value of the frame pointer before it was
714 * So until the compiler can be trusted to produce reliable
715 * DWARF info when it really matters, let's stop unwinding once
716 * we've calculated the function that was interrupted.
718 if (prev
&& prev
->pc
== (unsigned long)ret_from_irq
)
719 frame
->return_addr
= 0;
724 dwarf_free_frame(frame
);
728 static int dwarf_parse_cie(void *entry
, void *p
, unsigned long len
,
729 unsigned char *end
, struct module
*mod
)
731 struct rb_node
**rb_node
= &cie_root
.rb_node
;
732 struct rb_node
*parent
= *rb_node
;
733 struct dwarf_cie
*cie
;
737 cie
= kzalloc(sizeof(*cie
), GFP_KERNEL
);
744 * Record the offset into the .eh_frame section
745 * for this CIE. It allows this CIE to be
746 * quickly and easily looked up from the
749 cie
->cie_pointer
= (unsigned long)entry
;
751 cie
->version
= *(char *)p
++;
752 UNWINDER_BUG_ON(cie
->version
!= 1);
754 cie
->augmentation
= p
;
755 p
+= strlen(cie
->augmentation
) + 1;
757 count
= dwarf_read_uleb128(p
, &cie
->code_alignment_factor
);
760 count
= dwarf_read_leb128(p
, &cie
->data_alignment_factor
);
764 * Which column in the rule table contains the
767 if (cie
->version
== 1) {
768 cie
->return_address_reg
= __raw_readb(p
);
771 count
= dwarf_read_uleb128(p
, &cie
->return_address_reg
);
775 if (cie
->augmentation
[0] == 'z') {
776 unsigned int length
, count
;
777 cie
->flags
|= DWARF_CIE_Z_AUGMENTATION
;
779 count
= dwarf_read_uleb128(p
, &length
);
782 UNWINDER_BUG_ON((unsigned char *)p
> end
);
784 cie
->initial_instructions
= p
+ length
;
788 while (*cie
->augmentation
) {
790 * "L" indicates a byte showing how the
791 * LSDA pointer is encoded. Skip it.
793 if (*cie
->augmentation
== 'L') {
796 } else if (*cie
->augmentation
== 'R') {
798 * "R" indicates a byte showing
799 * how FDE addresses are
802 cie
->encoding
= *(char *)p
++;
804 } else if (*cie
->augmentation
== 'P') {
806 * "R" indicates a personality
811 } else if (*cie
->augmentation
== 'S') {
815 * Unknown augmentation. Assume
818 p
= cie
->initial_instructions
;
824 cie
->initial_instructions
= p
;
825 cie
->instructions_end
= end
;
828 spin_lock_irqsave(&dwarf_cie_lock
, flags
);
831 struct dwarf_cie
*cie_tmp
;
833 cie_tmp
= rb_entry(*rb_node
, struct dwarf_cie
, node
);
837 if (cie
->cie_pointer
< cie_tmp
->cie_pointer
)
838 rb_node
= &parent
->rb_left
;
839 else if (cie
->cie_pointer
>= cie_tmp
->cie_pointer
)
840 rb_node
= &parent
->rb_right
;
845 rb_link_node(&cie
->node
, parent
, rb_node
);
846 rb_insert_color(&cie
->node
, &cie_root
);
848 #ifdef CONFIG_MODULES
850 list_add_tail(&cie
->link
, &mod
->arch
.cie_list
);
853 spin_unlock_irqrestore(&dwarf_cie_lock
, flags
);
858 static int dwarf_parse_fde(void *entry
, u32 entry_type
,
859 void *start
, unsigned long len
,
860 unsigned char *end
, struct module
*mod
)
862 struct rb_node
**rb_node
= &fde_root
.rb_node
;
863 struct rb_node
*parent
= *rb_node
;
864 struct dwarf_fde
*fde
;
865 struct dwarf_cie
*cie
;
870 fde
= kzalloc(sizeof(*fde
), GFP_KERNEL
);
877 * In a .eh_frame section the CIE pointer is the
878 * delta between the address within the FDE
880 fde
->cie_pointer
= (unsigned long)(p
- entry_type
- 4);
882 cie
= dwarf_lookup_cie(fde
->cie_pointer
);
886 count
= dwarf_read_encoded_value(p
, &fde
->initial_location
,
889 count
= dwarf_read_addr(p
, &fde
->initial_location
);
894 count
= dwarf_read_encoded_value(p
, &fde
->address_range
,
895 cie
->encoding
& 0x0f);
897 count
= dwarf_read_addr(p
, &fde
->address_range
);
901 if (fde
->cie
->flags
& DWARF_CIE_Z_AUGMENTATION
) {
903 count
= dwarf_read_uleb128(p
, &length
);
907 /* Call frame instructions. */
908 fde
->instructions
= p
;
912 spin_lock_irqsave(&dwarf_fde_lock
, flags
);
915 struct dwarf_fde
*fde_tmp
;
916 unsigned long tmp_start
, tmp_end
;
917 unsigned long start
, end
;
919 fde_tmp
= rb_entry(*rb_node
, struct dwarf_fde
, node
);
921 start
= fde
->initial_location
;
922 end
= fde
->initial_location
+ fde
->address_range
;
924 tmp_start
= fde_tmp
->initial_location
;
925 tmp_end
= fde_tmp
->initial_location
+ fde_tmp
->address_range
;
929 if (start
< tmp_start
)
930 rb_node
= &parent
->rb_left
;
931 else if (start
>= tmp_end
)
932 rb_node
= &parent
->rb_right
;
937 rb_link_node(&fde
->node
, parent
, rb_node
);
938 rb_insert_color(&fde
->node
, &fde_root
);
940 #ifdef CONFIG_MODULES
942 list_add_tail(&fde
->link
, &mod
->arch
.fde_list
);
945 spin_unlock_irqrestore(&dwarf_fde_lock
, flags
);
950 static void dwarf_unwinder_dump(struct task_struct
*task
,
951 struct pt_regs
*regs
,
953 const struct stacktrace_ops
*ops
,
956 struct dwarf_frame
*frame
, *_frame
;
957 unsigned long return_addr
;
963 frame
= dwarf_unwind_stack(return_addr
, _frame
);
966 dwarf_free_frame(_frame
);
970 if (!frame
|| !frame
->return_addr
)
973 return_addr
= frame
->return_addr
;
974 ops
->address(data
, return_addr
, 1);
978 dwarf_free_frame(frame
);
981 static struct unwinder dwarf_unwinder
= {
982 .name
= "dwarf-unwinder",
983 .dump
= dwarf_unwinder_dump
,
987 static void dwarf_unwinder_cleanup(void)
989 struct rb_node
**fde_rb_node
= &fde_root
.rb_node
;
990 struct rb_node
**cie_rb_node
= &cie_root
.rb_node
;
993 * Deallocate all the memory allocated for the DWARF unwinder.
994 * Traverse all the FDE/CIE lists and remove and free all the
995 * memory associated with those data structures.
997 while (*fde_rb_node
) {
998 struct dwarf_fde
*fde
;
1000 fde
= rb_entry(*fde_rb_node
, struct dwarf_fde
, node
);
1001 rb_erase(*fde_rb_node
, &fde_root
);
1005 while (*cie_rb_node
) {
1006 struct dwarf_cie
*cie
;
1008 cie
= rb_entry(*cie_rb_node
, struct dwarf_cie
, node
);
1009 rb_erase(*cie_rb_node
, &cie_root
);
1013 kmem_cache_destroy(dwarf_reg_cachep
);
1014 kmem_cache_destroy(dwarf_frame_cachep
);
1018 * dwarf_parse_section - parse DWARF section
1019 * @eh_frame_start: start address of the .eh_frame section
1020 * @eh_frame_end: end address of the .eh_frame section
1021 * @mod: the kernel module containing the .eh_frame section
1023 * Parse the information in a .eh_frame section.
1025 static int dwarf_parse_section(char *eh_frame_start
, char *eh_frame_end
,
1031 unsigned long len
= 0;
1032 unsigned int c_entries
, f_entries
;
1037 entry
= eh_frame_start
;
1039 while ((char *)entry
< eh_frame_end
) {
1042 count
= dwarf_entry_len(p
, &len
);
1045 * We read a bogus length field value. There is
1046 * nothing we can do here apart from disabling
1047 * the DWARF unwinder. We can't even skip this
1048 * entry and move to the next one because 'len'
1049 * tells us where our next entry is.
1056 /* initial length does not include itself */
1059 entry_type
= get_unaligned((u32
*)p
);
1062 if (entry_type
== DW_EH_FRAME_CIE
) {
1063 err
= dwarf_parse_cie(entry
, p
, len
, end
, mod
);
1069 err
= dwarf_parse_fde(entry
, entry_type
, p
, len
,
1077 entry
= (char *)entry
+ len
+ 4;
1080 printk(KERN_INFO
"DWARF unwinder initialised: read %u CIEs, %u FDEs\n",
1081 c_entries
, f_entries
);
1089 #ifdef CONFIG_MODULES
1090 int module_dwarf_finalize(const Elf_Ehdr
*hdr
, const Elf_Shdr
*sechdrs
,
1093 unsigned int i
, err
;
1094 unsigned long start
, end
;
1095 char *secstrings
= (void *)hdr
+ sechdrs
[hdr
->e_shstrndx
].sh_offset
;
1099 for (i
= 1; i
< hdr
->e_shnum
; i
++) {
1100 /* Alloc bit cleared means "ignore it." */
1101 if ((sechdrs
[i
].sh_flags
& SHF_ALLOC
)
1102 && !strcmp(secstrings
+sechdrs
[i
].sh_name
, ".eh_frame")) {
1103 start
= sechdrs
[i
].sh_addr
;
1104 end
= start
+ sechdrs
[i
].sh_size
;
1109 /* Did we find the .eh_frame section? */
1110 if (i
!= hdr
->e_shnum
) {
1111 INIT_LIST_HEAD(&me
->arch
.cie_list
);
1112 INIT_LIST_HEAD(&me
->arch
.fde_list
);
1113 err
= dwarf_parse_section((char *)start
, (char *)end
, me
);
1115 printk(KERN_WARNING
"%s: failed to parse DWARF info\n",
1125 * module_dwarf_cleanup - remove FDE/CIEs associated with @mod
1126 * @mod: the module that is being unloaded
1128 * Remove any FDEs and CIEs from the global lists that came from
1129 * @mod's .eh_frame section because @mod is being unloaded.
1131 void module_dwarf_cleanup(struct module
*mod
)
1133 struct dwarf_fde
*fde
, *ftmp
;
1134 struct dwarf_cie
*cie
, *ctmp
;
1135 unsigned long flags
;
1137 spin_lock_irqsave(&dwarf_cie_lock
, flags
);
1139 list_for_each_entry_safe(cie
, ctmp
, &mod
->arch
.cie_list
, link
) {
1140 list_del(&cie
->link
);
1141 rb_erase(&cie
->node
, &cie_root
);
1145 spin_unlock_irqrestore(&dwarf_cie_lock
, flags
);
1147 spin_lock_irqsave(&dwarf_fde_lock
, flags
);
1149 list_for_each_entry_safe(fde
, ftmp
, &mod
->arch
.fde_list
, link
) {
1150 list_del(&fde
->link
);
1151 rb_erase(&fde
->node
, &fde_root
);
1155 spin_unlock_irqrestore(&dwarf_fde_lock
, flags
);
1157 #endif /* CONFIG_MODULES */
1160 * dwarf_unwinder_init - initialise the dwarf unwinder
1162 * Build the data structures describing the .dwarf_frame section to
1163 * make it easier to lookup CIE and FDE entries. Because the
1164 * .eh_frame section is packed as tightly as possible it is not
1165 * easy to lookup the FDE for a given PC, so we build a list of FDE
1166 * and CIE entries that make it easier.
1168 static int __init
dwarf_unwinder_init(void)
1172 dwarf_frame_cachep
= kmem_cache_create("dwarf_frames",
1173 sizeof(struct dwarf_frame
), 0,
1174 SLAB_PANIC
| SLAB_HWCACHE_ALIGN
| SLAB_NOTRACK
, NULL
);
1176 dwarf_reg_cachep
= kmem_cache_create("dwarf_regs",
1177 sizeof(struct dwarf_reg
), 0,
1178 SLAB_PANIC
| SLAB_HWCACHE_ALIGN
| SLAB_NOTRACK
, NULL
);
1180 dwarf_frame_pool
= mempool_create(DWARF_FRAME_MIN_REQ
,
1183 dwarf_frame_cachep
);
1185 dwarf_reg_pool
= mempool_create(DWARF_REG_MIN_REQ
,
1190 err
= dwarf_parse_section(__start_eh_frame
, __stop_eh_frame
, NULL
);
1194 err
= unwinder_register(&dwarf_unwinder
);
1201 printk(KERN_ERR
"Failed to initialise DWARF unwinder: %d\n", err
);
1202 dwarf_unwinder_cleanup();
1205 early_initcall(dwarf_unwinder_init
);