sh: Fix access to released memory in dwarf_unwinder_cleanup()
[linux-2.6.git] / arch / sh / kernel / dwarf.c
1 /*
2  * Copyright (C) 2009 Matt Fleming <matt@console-pimps.org>
3  *
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
6  * for more details.
7  *
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.
11  *
12  * TODO:
13  *      - DWARF64 doesn't work.
14  *      - Registers with DWARF_VAL_OFFSET rules aren't handled properly.
15  */
16
17 /* #define DEBUG */
18 #include <linux/kernel.h>
19 #include <linux/io.h>
20 #include <linux/list.h>
21 #include <linux/mempool.h>
22 #include <linux/mm.h>
23 #include <linux/elf.h>
24 #include <linux/ftrace.h>
25 #include <asm/dwarf.h>
26 #include <asm/unwinder.h>
27 #include <asm/sections.h>
28 #include <asm/unaligned.h>
29 #include <asm/stacktrace.h>
30
31 /* Reserve enough memory for two stack frames */
32 #define DWARF_FRAME_MIN_REQ     2
33 /* ... with 4 registers per frame. */
34 #define DWARF_REG_MIN_REQ       (DWARF_FRAME_MIN_REQ * 4)
35
36 static struct kmem_cache *dwarf_frame_cachep;
37 static mempool_t *dwarf_frame_pool;
38
39 static struct kmem_cache *dwarf_reg_cachep;
40 static mempool_t *dwarf_reg_pool;
41
42 static LIST_HEAD(dwarf_cie_list);
43 static DEFINE_SPINLOCK(dwarf_cie_lock);
44
45 static LIST_HEAD(dwarf_fde_list);
46 static DEFINE_SPINLOCK(dwarf_fde_lock);
47
48 static struct dwarf_cie *cached_cie;
49
50 /**
51  *      dwarf_frame_alloc_reg - allocate memory for a DWARF register
52  *      @frame: the DWARF frame whose list of registers we insert on
53  *      @reg_num: the register number
54  *
55  *      Allocate space for, and initialise, a dwarf reg from
56  *      dwarf_reg_pool and insert it onto the (unsorted) linked-list of
57  *      dwarf registers for @frame.
58  *
59  *      Return the initialised DWARF reg.
60  */
61 static struct dwarf_reg *dwarf_frame_alloc_reg(struct dwarf_frame *frame,
62                                                unsigned int reg_num)
63 {
64         struct dwarf_reg *reg;
65
66         reg = mempool_alloc(dwarf_reg_pool, GFP_ATOMIC);
67         if (!reg) {
68                 printk(KERN_WARNING "Unable to allocate a DWARF register\n");
69                 /*
70                  * Let's just bomb hard here, we have no way to
71                  * gracefully recover.
72                  */
73                 UNWINDER_BUG();
74         }
75
76         reg->number = reg_num;
77         reg->addr = 0;
78         reg->flags = 0;
79
80         list_add(&reg->link, &frame->reg_list);
81
82         return reg;
83 }
84
85 static void dwarf_frame_free_regs(struct dwarf_frame *frame)
86 {
87         struct dwarf_reg *reg, *n;
88
89         list_for_each_entry_safe(reg, n, &frame->reg_list, link) {
90                 list_del(&reg->link);
91                 mempool_free(reg, dwarf_reg_pool);
92         }
93 }
94
95 /**
96  *      dwarf_frame_reg - return a DWARF register
97  *      @frame: the DWARF frame to search in for @reg_num
98  *      @reg_num: the register number to search for
99  *
100  *      Lookup and return the dwarf reg @reg_num for this frame. Return
101  *      NULL if @reg_num is an register invalid number.
102  */
103 static struct dwarf_reg *dwarf_frame_reg(struct dwarf_frame *frame,
104                                          unsigned int reg_num)
105 {
106         struct dwarf_reg *reg;
107
108         list_for_each_entry(reg, &frame->reg_list, link) {
109                 if (reg->number == reg_num)
110                         return reg;
111         }
112
113         return NULL;
114 }
115
116 /**
117  *      dwarf_read_addr - read dwarf data
118  *      @src: source address of data
119  *      @dst: destination address to store the data to
120  *
121  *      Read 'n' bytes from @src, where 'n' is the size of an address on
122  *      the native machine. We return the number of bytes read, which
123  *      should always be 'n'. We also have to be careful when reading
124  *      from @src and writing to @dst, because they can be arbitrarily
125  *      aligned. Return 'n' - the number of bytes read.
126  */
127 static inline int dwarf_read_addr(unsigned long *src, unsigned long *dst)
128 {
129         u32 val = get_unaligned(src);
130         put_unaligned(val, dst);
131         return sizeof(unsigned long *);
132 }
133
134 /**
135  *      dwarf_read_uleb128 - read unsigned LEB128 data
136  *      @addr: the address where the ULEB128 data is stored
137  *      @ret: address to store the result
138  *
139  *      Decode an unsigned LEB128 encoded datum. The algorithm is taken
140  *      from Appendix C of the DWARF 3 spec. For information on the
141  *      encodings refer to section "7.6 - Variable Length Data". Return
142  *      the number of bytes read.
143  */
144 static inline unsigned long dwarf_read_uleb128(char *addr, unsigned int *ret)
145 {
146         unsigned int result;
147         unsigned char byte;
148         int shift, count;
149
150         result = 0;
151         shift = 0;
152         count = 0;
153
154         while (1) {
155                 byte = __raw_readb(addr);
156                 addr++;
157                 count++;
158
159                 result |= (byte & 0x7f) << shift;
160                 shift += 7;
161
162                 if (!(byte & 0x80))
163                         break;
164         }
165
166         *ret = result;
167
168         return count;
169 }
170
171 /**
172  *      dwarf_read_leb128 - read signed LEB128 data
173  *      @addr: the address of the LEB128 encoded data
174  *      @ret: address to store the result
175  *
176  *      Decode signed LEB128 data. The algorithm is taken from Appendix
177  *      C of the DWARF 3 spec. Return the number of bytes read.
178  */
179 static inline unsigned long dwarf_read_leb128(char *addr, int *ret)
180 {
181         unsigned char byte;
182         int result, shift;
183         int num_bits;
184         int count;
185
186         result = 0;
187         shift = 0;
188         count = 0;
189
190         while (1) {
191                 byte = __raw_readb(addr);
192                 addr++;
193                 result |= (byte & 0x7f) << shift;
194                 shift += 7;
195                 count++;
196
197                 if (!(byte & 0x80))
198                         break;
199         }
200
201         /* The number of bits in a signed integer. */
202         num_bits = 8 * sizeof(result);
203
204         if ((shift < num_bits) && (byte & 0x40))
205                 result |= (-1 << shift);
206
207         *ret = result;
208
209         return count;
210 }
211
212 /**
213  *      dwarf_read_encoded_value - return the decoded value at @addr
214  *      @addr: the address of the encoded value
215  *      @val: where to write the decoded value
216  *      @encoding: the encoding with which we can decode @addr
217  *
218  *      GCC emits encoded address in the .eh_frame FDE entries. Decode
219  *      the value at @addr using @encoding. The decoded value is written
220  *      to @val and the number of bytes read is returned.
221  */
222 static int dwarf_read_encoded_value(char *addr, unsigned long *val,
223                                     char encoding)
224 {
225         unsigned long decoded_addr = 0;
226         int count = 0;
227
228         switch (encoding & 0x70) {
229         case DW_EH_PE_absptr:
230                 break;
231         case DW_EH_PE_pcrel:
232                 decoded_addr = (unsigned long)addr;
233                 break;
234         default:
235                 pr_debug("encoding=0x%x\n", (encoding & 0x70));
236                 UNWINDER_BUG();
237         }
238
239         if ((encoding & 0x07) == 0x00)
240                 encoding |= DW_EH_PE_udata4;
241
242         switch (encoding & 0x0f) {
243         case DW_EH_PE_sdata4:
244         case DW_EH_PE_udata4:
245                 count += 4;
246                 decoded_addr += get_unaligned((u32 *)addr);
247                 __raw_writel(decoded_addr, val);
248                 break;
249         default:
250                 pr_debug("encoding=0x%x\n", encoding);
251                 UNWINDER_BUG();
252         }
253
254         return count;
255 }
256
257 /**
258  *      dwarf_entry_len - return the length of an FDE or CIE
259  *      @addr: the address of the entry
260  *      @len: the length of the entry
261  *
262  *      Read the initial_length field of the entry and store the size of
263  *      the entry in @len. We return the number of bytes read. Return a
264  *      count of 0 on error.
265  */
266 static inline int dwarf_entry_len(char *addr, unsigned long *len)
267 {
268         u32 initial_len;
269         int count;
270
271         initial_len = get_unaligned((u32 *)addr);
272         count = 4;
273
274         /*
275          * An initial length field value in the range DW_LEN_EXT_LO -
276          * DW_LEN_EXT_HI indicates an extension, and should not be
277          * interpreted as a length. The only extension that we currently
278          * understand is the use of DWARF64 addresses.
279          */
280         if (initial_len >= DW_EXT_LO && initial_len <= DW_EXT_HI) {
281                 /*
282                  * The 64-bit length field immediately follows the
283                  * compulsory 32-bit length field.
284                  */
285                 if (initial_len == DW_EXT_DWARF64) {
286                         *len = get_unaligned((u64 *)addr + 4);
287                         count = 12;
288                 } else {
289                         printk(KERN_WARNING "Unknown DWARF extension\n");
290                         count = 0;
291                 }
292         } else
293                 *len = initial_len;
294
295         return count;
296 }
297
298 /**
299  *      dwarf_lookup_cie - locate the cie
300  *      @cie_ptr: pointer to help with lookup
301  */
302 static struct dwarf_cie *dwarf_lookup_cie(unsigned long cie_ptr)
303 {
304         struct dwarf_cie *cie;
305         unsigned long flags;
306
307         spin_lock_irqsave(&dwarf_cie_lock, flags);
308
309         /*
310          * We've cached the last CIE we looked up because chances are
311          * that the FDE wants this CIE.
312          */
313         if (cached_cie && cached_cie->cie_pointer == cie_ptr) {
314                 cie = cached_cie;
315                 goto out;
316         }
317
318         list_for_each_entry(cie, &dwarf_cie_list, link) {
319                 if (cie->cie_pointer == cie_ptr) {
320                         cached_cie = cie;
321                         break;
322                 }
323         }
324
325         /* Couldn't find the entry in the list. */
326         if (&cie->link == &dwarf_cie_list)
327                 cie = NULL;
328 out:
329         spin_unlock_irqrestore(&dwarf_cie_lock, flags);
330         return cie;
331 }
332
333 /**
334  *      dwarf_lookup_fde - locate the FDE that covers pc
335  *      @pc: the program counter
336  */
337 struct dwarf_fde *dwarf_lookup_fde(unsigned long pc)
338 {
339         struct dwarf_fde *fde;
340         unsigned long flags;
341
342         spin_lock_irqsave(&dwarf_fde_lock, flags);
343
344         list_for_each_entry(fde, &dwarf_fde_list, link) {
345                 unsigned long start, end;
346
347                 start = fde->initial_location;
348                 end = fde->initial_location + fde->address_range;
349
350                 if (pc >= start && pc < end)
351                         break;
352         }
353
354         /* Couldn't find the entry in the list. */
355         if (&fde->link == &dwarf_fde_list)
356                 fde = NULL;
357
358         spin_unlock_irqrestore(&dwarf_fde_lock, flags);
359
360         return fde;
361 }
362
363 /**
364  *      dwarf_cfa_execute_insns - execute instructions to calculate a CFA
365  *      @insn_start: address of the first instruction
366  *      @insn_end: address of the last instruction
367  *      @cie: the CIE for this function
368  *      @fde: the FDE for this function
369  *      @frame: the instructions calculate the CFA for this frame
370  *      @pc: the program counter of the address we're interested in
371  *
372  *      Execute the Call Frame instruction sequence starting at
373  *      @insn_start and ending at @insn_end. The instructions describe
374  *      how to calculate the Canonical Frame Address of a stackframe.
375  *      Store the results in @frame.
376  */
377 static int dwarf_cfa_execute_insns(unsigned char *insn_start,
378                                    unsigned char *insn_end,
379                                    struct dwarf_cie *cie,
380                                    struct dwarf_fde *fde,
381                                    struct dwarf_frame *frame,
382                                    unsigned long pc)
383 {
384         unsigned char insn;
385         unsigned char *current_insn;
386         unsigned int count, delta, reg, expr_len, offset;
387         struct dwarf_reg *regp;
388
389         current_insn = insn_start;
390
391         while (current_insn < insn_end && frame->pc <= pc) {
392                 insn = __raw_readb(current_insn++);
393
394                 /*
395                  * Firstly, handle the opcodes that embed their operands
396                  * in the instructions.
397                  */
398                 switch (DW_CFA_opcode(insn)) {
399                 case DW_CFA_advance_loc:
400                         delta = DW_CFA_operand(insn);
401                         delta *= cie->code_alignment_factor;
402                         frame->pc += delta;
403                         continue;
404                         /* NOTREACHED */
405                 case DW_CFA_offset:
406                         reg = DW_CFA_operand(insn);
407                         count = dwarf_read_uleb128(current_insn, &offset);
408                         current_insn += count;
409                         offset *= cie->data_alignment_factor;
410                         regp = dwarf_frame_alloc_reg(frame, reg);
411                         regp->addr = offset;
412                         regp->flags |= DWARF_REG_OFFSET;
413                         continue;
414                         /* NOTREACHED */
415                 case DW_CFA_restore:
416                         reg = DW_CFA_operand(insn);
417                         continue;
418                         /* NOTREACHED */
419                 }
420
421                 /*
422                  * Secondly, handle the opcodes that don't embed their
423                  * operands in the instruction.
424                  */
425                 switch (insn) {
426                 case DW_CFA_nop:
427                         continue;
428                 case DW_CFA_advance_loc1:
429                         delta = *current_insn++;
430                         frame->pc += delta * cie->code_alignment_factor;
431                         break;
432                 case DW_CFA_advance_loc2:
433                         delta = get_unaligned((u16 *)current_insn);
434                         current_insn += 2;
435                         frame->pc += delta * cie->code_alignment_factor;
436                         break;
437                 case DW_CFA_advance_loc4:
438                         delta = get_unaligned((u32 *)current_insn);
439                         current_insn += 4;
440                         frame->pc += delta * cie->code_alignment_factor;
441                         break;
442                 case DW_CFA_offset_extended:
443                         count = dwarf_read_uleb128(current_insn, &reg);
444                         current_insn += count;
445                         count = dwarf_read_uleb128(current_insn, &offset);
446                         current_insn += count;
447                         offset *= cie->data_alignment_factor;
448                         break;
449                 case DW_CFA_restore_extended:
450                         count = dwarf_read_uleb128(current_insn, &reg);
451                         current_insn += count;
452                         break;
453                 case DW_CFA_undefined:
454                         count = dwarf_read_uleb128(current_insn, &reg);
455                         current_insn += count;
456                         regp = dwarf_frame_alloc_reg(frame, reg);
457                         regp->flags |= DWARF_UNDEFINED;
458                         break;
459                 case DW_CFA_def_cfa:
460                         count = dwarf_read_uleb128(current_insn,
461                                                    &frame->cfa_register);
462                         current_insn += count;
463                         count = dwarf_read_uleb128(current_insn,
464                                                    &frame->cfa_offset);
465                         current_insn += count;
466
467                         frame->flags |= DWARF_FRAME_CFA_REG_OFFSET;
468                         break;
469                 case DW_CFA_def_cfa_register:
470                         count = dwarf_read_uleb128(current_insn,
471                                                    &frame->cfa_register);
472                         current_insn += count;
473                         frame->flags |= DWARF_FRAME_CFA_REG_OFFSET;
474                         break;
475                 case DW_CFA_def_cfa_offset:
476                         count = dwarf_read_uleb128(current_insn, &offset);
477                         current_insn += count;
478                         frame->cfa_offset = offset;
479                         break;
480                 case DW_CFA_def_cfa_expression:
481                         count = dwarf_read_uleb128(current_insn, &expr_len);
482                         current_insn += count;
483
484                         frame->cfa_expr = current_insn;
485                         frame->cfa_expr_len = expr_len;
486                         current_insn += expr_len;
487
488                         frame->flags |= DWARF_FRAME_CFA_REG_EXP;
489                         break;
490                 case DW_CFA_offset_extended_sf:
491                         count = dwarf_read_uleb128(current_insn, &reg);
492                         current_insn += count;
493                         count = dwarf_read_leb128(current_insn, &offset);
494                         current_insn += count;
495                         offset *= cie->data_alignment_factor;
496                         regp = dwarf_frame_alloc_reg(frame, reg);
497                         regp->flags |= DWARF_REG_OFFSET;
498                         regp->addr = offset;
499                         break;
500                 case DW_CFA_val_offset:
501                         count = dwarf_read_uleb128(current_insn, &reg);
502                         current_insn += count;
503                         count = dwarf_read_leb128(current_insn, &offset);
504                         offset *= cie->data_alignment_factor;
505                         regp = dwarf_frame_alloc_reg(frame, reg);
506                         regp->flags |= DWARF_VAL_OFFSET;
507                         regp->addr = offset;
508                         break;
509                 case DW_CFA_GNU_args_size:
510                         count = dwarf_read_uleb128(current_insn, &offset);
511                         current_insn += count;
512                         break;
513                 case DW_CFA_GNU_negative_offset_extended:
514                         count = dwarf_read_uleb128(current_insn, &reg);
515                         current_insn += count;
516                         count = dwarf_read_uleb128(current_insn, &offset);
517                         offset *= cie->data_alignment_factor;
518
519                         regp = dwarf_frame_alloc_reg(frame, reg);
520                         regp->flags |= DWARF_REG_OFFSET;
521                         regp->addr = -offset;
522                         break;
523                 default:
524                         pr_debug("unhandled DWARF instruction 0x%x\n", insn);
525                         UNWINDER_BUG();
526                         break;
527                 }
528         }
529
530         return 0;
531 }
532
533 /**
534  *      dwarf_free_frame - free the memory allocated for @frame
535  *      @frame: the frame to free
536  */
537 void dwarf_free_frame(struct dwarf_frame *frame)
538 {
539         dwarf_frame_free_regs(frame);
540         mempool_free(frame, dwarf_frame_pool);
541 }
542
543 /**
544  *      dwarf_unwind_stack - unwind the stack
545  *
546  *      @pc: address of the function to unwind
547  *      @prev: struct dwarf_frame of the previous stackframe on the callstack
548  *
549  *      Return a struct dwarf_frame representing the most recent frame
550  *      on the callstack. Each of the lower (older) stack frames are
551  *      linked via the "prev" member.
552  */
553 struct dwarf_frame * dwarf_unwind_stack(unsigned long pc,
554                                         struct dwarf_frame *prev)
555 {
556         struct dwarf_frame *frame;
557         struct dwarf_cie *cie;
558         struct dwarf_fde *fde;
559         struct dwarf_reg *reg;
560         unsigned long addr;
561
562         /*
563          * If we're starting at the top of the stack we need get the
564          * contents of a physical register to get the CFA in order to
565          * begin the virtual unwinding of the stack.
566          *
567          * NOTE: the return address is guaranteed to be setup by the
568          * time this function makes its first function call.
569          */
570         if (!pc || !prev)
571                 pc = (unsigned long)current_text_addr();
572
573 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
574         /*
575          * If our stack has been patched by the function graph tracer
576          * then we might see the address of return_to_handler() where we
577          * expected to find the real return address.
578          */
579         if (pc == (unsigned long)&return_to_handler) {
580                 int index = current->curr_ret_stack;
581
582                 /*
583                  * We currently have no way of tracking how many
584                  * return_to_handler()'s we've seen. If there is more
585                  * than one patched return address on our stack,
586                  * complain loudly.
587                  */
588                 WARN_ON(index > 0);
589
590                 pc = current->ret_stack[index].ret;
591         }
592 #endif
593
594         frame = mempool_alloc(dwarf_frame_pool, GFP_ATOMIC);
595         if (!frame) {
596                 printk(KERN_ERR "Unable to allocate a dwarf frame\n");
597                 UNWINDER_BUG();
598         }
599
600         INIT_LIST_HEAD(&frame->reg_list);
601         frame->flags = 0;
602         frame->prev = prev;
603         frame->return_addr = 0;
604
605         fde = dwarf_lookup_fde(pc);
606         if (!fde) {
607                 /*
608                  * This is our normal exit path. There are two reasons
609                  * why we might exit here,
610                  *
611                  *      a) pc has no asscociated DWARF frame info and so
612                  *      we don't know how to unwind this frame. This is
613                  *      usually the case when we're trying to unwind a
614                  *      frame that was called from some assembly code
615                  *      that has no DWARF info, e.g. syscalls.
616                  *
617                  *      b) the DEBUG info for pc is bogus. There's
618                  *      really no way to distinguish this case from the
619                  *      case above, which sucks because we could print a
620                  *      warning here.
621                  */
622                 goto bail;
623         }
624
625         cie = dwarf_lookup_cie(fde->cie_pointer);
626
627         frame->pc = fde->initial_location;
628
629         /* CIE initial instructions */
630         dwarf_cfa_execute_insns(cie->initial_instructions,
631                                 cie->instructions_end, cie, fde,
632                                 frame, pc);
633
634         /* FDE instructions */
635         dwarf_cfa_execute_insns(fde->instructions, fde->end, cie,
636                                 fde, frame, pc);
637
638         /* Calculate the CFA */
639         switch (frame->flags) {
640         case DWARF_FRAME_CFA_REG_OFFSET:
641                 if (prev) {
642                         reg = dwarf_frame_reg(prev, frame->cfa_register);
643                         UNWINDER_BUG_ON(!reg);
644                         UNWINDER_BUG_ON(reg->flags != DWARF_REG_OFFSET);
645
646                         addr = prev->cfa + reg->addr;
647                         frame->cfa = __raw_readl(addr);
648
649                 } else {
650                         /*
651                          * Again, we're starting from the top of the
652                          * stack. We need to physically read
653                          * the contents of a register in order to get
654                          * the Canonical Frame Address for this
655                          * function.
656                          */
657                         frame->cfa = dwarf_read_arch_reg(frame->cfa_register);
658                 }
659
660                 frame->cfa += frame->cfa_offset;
661                 break;
662         default:
663                 UNWINDER_BUG();
664         }
665
666         reg = dwarf_frame_reg(frame, DWARF_ARCH_RA_REG);
667
668         /*
669          * If we haven't seen the return address register or the return
670          * address column is undefined then we must assume that this is
671          * the end of the callstack.
672          */
673         if (!reg || reg->flags == DWARF_UNDEFINED)
674                 goto bail;
675
676         UNWINDER_BUG_ON(reg->flags != DWARF_REG_OFFSET);
677
678         addr = frame->cfa + reg->addr;
679         frame->return_addr = __raw_readl(addr);
680
681         return frame;
682
683 bail:
684         dwarf_free_frame(frame);
685         return NULL;
686 }
687
688 static int dwarf_parse_cie(void *entry, void *p, unsigned long len,
689                            unsigned char *end, struct module *mod)
690 {
691         struct dwarf_cie *cie;
692         unsigned long flags;
693         int count;
694
695         cie = kzalloc(sizeof(*cie), GFP_KERNEL);
696         if (!cie)
697                 return -ENOMEM;
698
699         cie->length = len;
700
701         /*
702          * Record the offset into the .eh_frame section
703          * for this CIE. It allows this CIE to be
704          * quickly and easily looked up from the
705          * corresponding FDE.
706          */
707         cie->cie_pointer = (unsigned long)entry;
708
709         cie->version = *(char *)p++;
710         UNWINDER_BUG_ON(cie->version != 1);
711
712         cie->augmentation = p;
713         p += strlen(cie->augmentation) + 1;
714
715         count = dwarf_read_uleb128(p, &cie->code_alignment_factor);
716         p += count;
717
718         count = dwarf_read_leb128(p, &cie->data_alignment_factor);
719         p += count;
720
721         /*
722          * Which column in the rule table contains the
723          * return address?
724          */
725         if (cie->version == 1) {
726                 cie->return_address_reg = __raw_readb(p);
727                 p++;
728         } else {
729                 count = dwarf_read_uleb128(p, &cie->return_address_reg);
730                 p += count;
731         }
732
733         if (cie->augmentation[0] == 'z') {
734                 unsigned int length, count;
735                 cie->flags |= DWARF_CIE_Z_AUGMENTATION;
736
737                 count = dwarf_read_uleb128(p, &length);
738                 p += count;
739
740                 UNWINDER_BUG_ON((unsigned char *)p > end);
741
742                 cie->initial_instructions = p + length;
743                 cie->augmentation++;
744         }
745
746         while (*cie->augmentation) {
747                 /*
748                  * "L" indicates a byte showing how the
749                  * LSDA pointer is encoded. Skip it.
750                  */
751                 if (*cie->augmentation == 'L') {
752                         p++;
753                         cie->augmentation++;
754                 } else if (*cie->augmentation == 'R') {
755                         /*
756                          * "R" indicates a byte showing
757                          * how FDE addresses are
758                          * encoded.
759                          */
760                         cie->encoding = *(char *)p++;
761                         cie->augmentation++;
762                 } else if (*cie->augmentation == 'P') {
763                         /*
764                          * "R" indicates a personality
765                          * routine in the CIE
766                          * augmentation.
767                          */
768                         UNWINDER_BUG();
769                 } else if (*cie->augmentation == 'S') {
770                         UNWINDER_BUG();
771                 } else {
772                         /*
773                          * Unknown augmentation. Assume
774                          * 'z' augmentation.
775                          */
776                         p = cie->initial_instructions;
777                         UNWINDER_BUG_ON(!p);
778                         break;
779                 }
780         }
781
782         cie->initial_instructions = p;
783         cie->instructions_end = end;
784
785         cie->mod = mod;
786
787         /* Add to list */
788         spin_lock_irqsave(&dwarf_cie_lock, flags);
789         list_add_tail(&cie->link, &dwarf_cie_list);
790         spin_unlock_irqrestore(&dwarf_cie_lock, flags);
791
792         return 0;
793 }
794
795 static int dwarf_parse_fde(void *entry, u32 entry_type,
796                            void *start, unsigned long len,
797                            unsigned char *end, struct module *mod)
798 {
799         struct dwarf_fde *fde;
800         struct dwarf_cie *cie;
801         unsigned long flags;
802         int count;
803         void *p = start;
804
805         fde = kzalloc(sizeof(*fde), GFP_KERNEL);
806         if (!fde)
807                 return -ENOMEM;
808
809         fde->length = len;
810
811         /*
812          * In a .eh_frame section the CIE pointer is the
813          * delta between the address within the FDE
814          */
815         fde->cie_pointer = (unsigned long)(p - entry_type - 4);
816
817         cie = dwarf_lookup_cie(fde->cie_pointer);
818         fde->cie = cie;
819
820         if (cie->encoding)
821                 count = dwarf_read_encoded_value(p, &fde->initial_location,
822                                                  cie->encoding);
823         else
824                 count = dwarf_read_addr(p, &fde->initial_location);
825
826         p += count;
827
828         if (cie->encoding)
829                 count = dwarf_read_encoded_value(p, &fde->address_range,
830                                                  cie->encoding & 0x0f);
831         else
832                 count = dwarf_read_addr(p, &fde->address_range);
833
834         p += count;
835
836         if (fde->cie->flags & DWARF_CIE_Z_AUGMENTATION) {
837                 unsigned int length;
838                 count = dwarf_read_uleb128(p, &length);
839                 p += count + length;
840         }
841
842         /* Call frame instructions. */
843         fde->instructions = p;
844         fde->end = end;
845
846         fde->mod = mod;
847
848         /* Add to list. */
849         spin_lock_irqsave(&dwarf_fde_lock, flags);
850         list_add_tail(&fde->link, &dwarf_fde_list);
851         spin_unlock_irqrestore(&dwarf_fde_lock, flags);
852
853         return 0;
854 }
855
856 static void dwarf_unwinder_dump(struct task_struct *task,
857                                 struct pt_regs *regs,
858                                 unsigned long *sp,
859                                 const struct stacktrace_ops *ops,
860                                 void *data)
861 {
862         struct dwarf_frame *frame, *_frame;
863         unsigned long return_addr;
864
865         _frame = NULL;
866         return_addr = 0;
867
868         while (1) {
869                 frame = dwarf_unwind_stack(return_addr, _frame);
870
871                 if (_frame)
872                         dwarf_free_frame(_frame);
873
874                 _frame = frame;
875
876                 if (!frame || !frame->return_addr)
877                         break;
878
879                 return_addr = frame->return_addr;
880                 ops->address(data, return_addr, 1);
881         }
882
883         if (frame)
884                 dwarf_free_frame(frame);
885 }
886
887 static struct unwinder dwarf_unwinder = {
888         .name = "dwarf-unwinder",
889         .dump = dwarf_unwinder_dump,
890         .rating = 150,
891 };
892
893 static void dwarf_unwinder_cleanup(void)
894 {
895         struct dwarf_cie *cie, *cie_tmp;
896         struct dwarf_fde *fde, *fde_tmp;
897
898         /*
899          * Deallocate all the memory allocated for the DWARF unwinder.
900          * Traverse all the FDE/CIE lists and remove and free all the
901          * memory associated with those data structures.
902          */
903         list_for_each_entry_safe(cie, cie_tmp, &dwarf_cie_list, link)
904                 kfree(cie);
905
906         list_for_each_entry_safe(fde, fde_tmp, &dwarf_fde_list, link)
907                 kfree(fde);
908
909         kmem_cache_destroy(dwarf_reg_cachep);
910         kmem_cache_destroy(dwarf_frame_cachep);
911 }
912
913 /**
914  *      dwarf_parse_section - parse DWARF section
915  *      @eh_frame_start: start address of the .eh_frame section
916  *      @eh_frame_end: end address of the .eh_frame section
917  *      @mod: the kernel module containing the .eh_frame section
918  *
919  *      Parse the information in a .eh_frame section.
920  */
921 static int dwarf_parse_section(char *eh_frame_start, char *eh_frame_end,
922                                struct module *mod)
923 {
924         u32 entry_type;
925         void *p, *entry;
926         int count, err = 0;
927         unsigned long len = 0;
928         unsigned int c_entries, f_entries;
929         unsigned char *end;
930
931         c_entries = 0;
932         f_entries = 0;
933         entry = eh_frame_start;
934
935         while ((char *)entry < eh_frame_end) {
936                 p = entry;
937
938                 count = dwarf_entry_len(p, &len);
939                 if (count == 0) {
940                         /*
941                          * We read a bogus length field value. There is
942                          * nothing we can do here apart from disabling
943                          * the DWARF unwinder. We can't even skip this
944                          * entry and move to the next one because 'len'
945                          * tells us where our next entry is.
946                          */
947                         err = -EINVAL;
948                         goto out;
949                 } else
950                         p += count;
951
952                 /* initial length does not include itself */
953                 end = p + len;
954
955                 entry_type = get_unaligned((u32 *)p);
956                 p += 4;
957
958                 if (entry_type == DW_EH_FRAME_CIE) {
959                         err = dwarf_parse_cie(entry, p, len, end, mod);
960                         if (err < 0)
961                                 goto out;
962                         else
963                                 c_entries++;
964                 } else {
965                         err = dwarf_parse_fde(entry, entry_type, p, len,
966                                               end, mod);
967                         if (err < 0)
968                                 goto out;
969                         else
970                                 f_entries++;
971                 }
972
973                 entry = (char *)entry + len + 4;
974         }
975
976         printk(KERN_INFO "DWARF unwinder initialised: read %u CIEs, %u FDEs\n",
977                c_entries, f_entries);
978
979         return 0;
980
981 out:
982         return err;
983 }
984
985 #ifdef CONFIG_MODULES
986 int module_dwarf_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
987                           struct module *me)
988 {
989         unsigned int i, err;
990         unsigned long start, end;
991         char *secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
992
993         start = end = 0;
994
995         for (i = 1; i < hdr->e_shnum; i++) {
996                 /* Alloc bit cleared means "ignore it." */
997                 if ((sechdrs[i].sh_flags & SHF_ALLOC)
998                     && !strcmp(secstrings+sechdrs[i].sh_name, ".eh_frame")) {
999                         start = sechdrs[i].sh_addr;
1000                         end = start + sechdrs[i].sh_size;
1001                         break;
1002                 }
1003         }
1004
1005         /* Did we find the .eh_frame section? */
1006         if (i != hdr->e_shnum) {
1007                 err = dwarf_parse_section((char *)start, (char *)end, me);
1008                 if (err) {
1009                         printk(KERN_WARNING "%s: failed to parse DWARF info\n",
1010                                me->name);
1011                         return err;
1012                 }
1013         }
1014
1015         return 0;
1016 }
1017
1018 /**
1019  *      module_dwarf_cleanup - remove FDE/CIEs associated with @mod
1020  *      @mod: the module that is being unloaded
1021  *
1022  *      Remove any FDEs and CIEs from the global lists that came from
1023  *      @mod's .eh_frame section because @mod is being unloaded.
1024  */
1025 void module_dwarf_cleanup(struct module *mod)
1026 {
1027         struct dwarf_fde *fde;
1028         struct dwarf_cie *cie;
1029         unsigned long flags;
1030
1031         spin_lock_irqsave(&dwarf_cie_lock, flags);
1032
1033 again_cie:
1034         list_for_each_entry(cie, &dwarf_cie_list, link) {
1035                 if (cie->mod == mod)
1036                         break;
1037         }
1038
1039         if (&cie->link != &dwarf_cie_list) {
1040                 list_del(&cie->link);
1041                 kfree(cie);
1042                 goto again_cie;
1043         }
1044
1045         spin_unlock_irqrestore(&dwarf_cie_lock, flags);
1046
1047         spin_lock_irqsave(&dwarf_fde_lock, flags);
1048
1049 again_fde:
1050         list_for_each_entry(fde, &dwarf_fde_list, link) {
1051                 if (fde->mod == mod)
1052                         break;
1053         }
1054
1055         if (&fde->link != &dwarf_fde_list) {
1056                 list_del(&fde->link);
1057                 kfree(fde);
1058                 goto again_fde;
1059         }
1060
1061         spin_unlock_irqrestore(&dwarf_fde_lock, flags);
1062 }
1063 #endif /* CONFIG_MODULES */
1064
1065 /**
1066  *      dwarf_unwinder_init - initialise the dwarf unwinder
1067  *
1068  *      Build the data structures describing the .dwarf_frame section to
1069  *      make it easier to lookup CIE and FDE entries. Because the
1070  *      .eh_frame section is packed as tightly as possible it is not
1071  *      easy to lookup the FDE for a given PC, so we build a list of FDE
1072  *      and CIE entries that make it easier.
1073  */
1074 static int __init dwarf_unwinder_init(void)
1075 {
1076         int err;
1077         INIT_LIST_HEAD(&dwarf_cie_list);
1078         INIT_LIST_HEAD(&dwarf_fde_list);
1079
1080         dwarf_frame_cachep = kmem_cache_create("dwarf_frames",
1081                         sizeof(struct dwarf_frame), 0,
1082                         SLAB_PANIC | SLAB_HWCACHE_ALIGN | SLAB_NOTRACK, NULL);
1083
1084         dwarf_reg_cachep = kmem_cache_create("dwarf_regs",
1085                         sizeof(struct dwarf_reg), 0,
1086                         SLAB_PANIC | SLAB_HWCACHE_ALIGN | SLAB_NOTRACK, NULL);
1087
1088         dwarf_frame_pool = mempool_create(DWARF_FRAME_MIN_REQ,
1089                                           mempool_alloc_slab,
1090                                           mempool_free_slab,
1091                                           dwarf_frame_cachep);
1092
1093         dwarf_reg_pool = mempool_create(DWARF_REG_MIN_REQ,
1094                                          mempool_alloc_slab,
1095                                          mempool_free_slab,
1096                                          dwarf_reg_cachep);
1097
1098         err = dwarf_parse_section(__start_eh_frame, __stop_eh_frame, NULL);
1099         if (err)
1100                 goto out;
1101
1102         err = unwinder_register(&dwarf_unwinder);
1103         if (err)
1104                 goto out;
1105
1106         return 0;
1107
1108 out:
1109         printk(KERN_ERR "Failed to initialise DWARF unwinder: %d\n", err);
1110         dwarf_unwinder_cleanup();
1111         return -EINVAL;
1112 }
1113 early_initcall(dwarf_unwinder_init);