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