[PATCH] memory hotadd fixes: find_next_system_ram catch range fix
[linux-2.6.git] / kernel / unwind.c
1 /*
2  * Copyright (C) 2002-2006 Novell, Inc.
3  *      Jan Beulich <jbeulich@novell.com>
4  * This code is released under version 2 of the GNU GPL.
5  *
6  * A simple API for unwinding kernel stacks.  This is used for
7  * debugging and error reporting purposes.  The kernel doesn't need
8  * full-blown stack unwinding with all the bells and whistles, so there
9  * is not much point in implementing the full Dwarf2 unwind API.
10  */
11
12 #include <linux/unwind.h>
13 #include <linux/module.h>
14 #include <linux/delay.h>
15 #include <linux/stop_machine.h>
16 #include <asm/sections.h>
17 #include <asm/uaccess.h>
18 #include <asm/unaligned.h>
19
20 extern char __start_unwind[], __end_unwind[];
21
22 #define MAX_STACK_DEPTH 8
23
24 #define EXTRA_INFO(f) { \
25                 BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) \
26                                   % FIELD_SIZEOF(struct unwind_frame_info, f)) \
27                 + offsetof(struct unwind_frame_info, f) \
28                   / FIELD_SIZEOF(struct unwind_frame_info, f), \
29                 FIELD_SIZEOF(struct unwind_frame_info, f) \
30         }
31 #define PTREGS_INFO(f) EXTRA_INFO(regs.f)
32
33 static const struct {
34         unsigned offs:BITS_PER_LONG / 2;
35         unsigned width:BITS_PER_LONG / 2;
36 } reg_info[] = {
37         UNW_REGISTER_INFO
38 };
39
40 #undef PTREGS_INFO
41 #undef EXTRA_INFO
42
43 #ifndef REG_INVALID
44 #define REG_INVALID(r) (reg_info[r].width == 0)
45 #endif
46
47 #define DW_CFA_nop                          0x00
48 #define DW_CFA_set_loc                      0x01
49 #define DW_CFA_advance_loc1                 0x02
50 #define DW_CFA_advance_loc2                 0x03
51 #define DW_CFA_advance_loc4                 0x04
52 #define DW_CFA_offset_extended              0x05
53 #define DW_CFA_restore_extended             0x06
54 #define DW_CFA_undefined                    0x07
55 #define DW_CFA_same_value                   0x08
56 #define DW_CFA_register                     0x09
57 #define DW_CFA_remember_state               0x0a
58 #define DW_CFA_restore_state                0x0b
59 #define DW_CFA_def_cfa                      0x0c
60 #define DW_CFA_def_cfa_register             0x0d
61 #define DW_CFA_def_cfa_offset               0x0e
62 #define DW_CFA_def_cfa_expression           0x0f
63 #define DW_CFA_expression                   0x10
64 #define DW_CFA_offset_extended_sf           0x11
65 #define DW_CFA_def_cfa_sf                   0x12
66 #define DW_CFA_def_cfa_offset_sf            0x13
67 #define DW_CFA_val_offset                   0x14
68 #define DW_CFA_val_offset_sf                0x15
69 #define DW_CFA_val_expression               0x16
70 #define DW_CFA_lo_user                      0x1c
71 #define DW_CFA_GNU_window_save              0x2d
72 #define DW_CFA_GNU_args_size                0x2e
73 #define DW_CFA_GNU_negative_offset_extended 0x2f
74 #define DW_CFA_hi_user                      0x3f
75
76 #define DW_EH_PE_FORM     0x07
77 #define DW_EH_PE_native   0x00
78 #define DW_EH_PE_leb128   0x01
79 #define DW_EH_PE_data2    0x02
80 #define DW_EH_PE_data4    0x03
81 #define DW_EH_PE_data8    0x04
82 #define DW_EH_PE_signed   0x08
83 #define DW_EH_PE_ADJUST   0x70
84 #define DW_EH_PE_abs      0x00
85 #define DW_EH_PE_pcrel    0x10
86 #define DW_EH_PE_textrel  0x20
87 #define DW_EH_PE_datarel  0x30
88 #define DW_EH_PE_funcrel  0x40
89 #define DW_EH_PE_aligned  0x50
90 #define DW_EH_PE_indirect 0x80
91 #define DW_EH_PE_omit     0xff
92
93 typedef unsigned long uleb128_t;
94 typedef   signed long sleb128_t;
95
96 static struct unwind_table {
97         struct {
98                 unsigned long pc;
99                 unsigned long range;
100         } core, init;
101         const void *address;
102         unsigned long size;
103         struct unwind_table *link;
104         const char *name;
105 } root_table, *last_table;
106
107 struct unwind_item {
108         enum item_location {
109                 Nowhere,
110                 Memory,
111                 Register,
112                 Value
113         } where;
114         uleb128_t value;
115 };
116
117 struct unwind_state {
118         uleb128_t loc, org;
119         const u8 *cieStart, *cieEnd;
120         uleb128_t codeAlign;
121         sleb128_t dataAlign;
122         struct cfa {
123                 uleb128_t reg, offs;
124         } cfa;
125         struct unwind_item regs[ARRAY_SIZE(reg_info)];
126         unsigned stackDepth:8;
127         unsigned version:8;
128         const u8 *label;
129         const u8 *stack[MAX_STACK_DEPTH];
130 };
131
132 static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 };
133
134 static struct unwind_table *find_table(unsigned long pc)
135 {
136         struct unwind_table *table;
137
138         for (table = &root_table; table; table = table->link)
139                 if ((pc >= table->core.pc
140                      && pc < table->core.pc + table->core.range)
141                     || (pc >= table->init.pc
142                         && pc < table->init.pc + table->init.range))
143                         break;
144
145         return table;
146 }
147
148 static void init_unwind_table(struct unwind_table *table,
149                               const char *name,
150                               const void *core_start,
151                               unsigned long core_size,
152                               const void *init_start,
153                               unsigned long init_size,
154                               const void *table_start,
155                               unsigned long table_size)
156 {
157         table->core.pc = (unsigned long)core_start;
158         table->core.range = core_size;
159         table->init.pc = (unsigned long)init_start;
160         table->init.range = init_size;
161         table->address = table_start;
162         table->size = table_size;
163         table->link = NULL;
164         table->name = name;
165 }
166
167 void __init unwind_init(void)
168 {
169         init_unwind_table(&root_table, "kernel",
170                           _text, _end - _text,
171                           NULL, 0,
172                           __start_unwind, __end_unwind - __start_unwind);
173 }
174
175 #ifdef CONFIG_MODULES
176
177 /* Must be called with module_mutex held. */
178 void *unwind_add_table(struct module *module,
179                        const void *table_start,
180                        unsigned long table_size)
181 {
182         struct unwind_table *table;
183
184         if (table_size <= 0)
185                 return NULL;
186
187         table = kmalloc(sizeof(*table), GFP_KERNEL);
188         if (!table)
189                 return NULL;
190
191         init_unwind_table(table, module->name,
192                           module->module_core, module->core_size,
193                           module->module_init, module->init_size,
194                           table_start, table_size);
195
196         if (last_table)
197                 last_table->link = table;
198         else
199                 root_table.link = table;
200         last_table = table;
201
202         return table;
203 }
204
205 struct unlink_table_info
206 {
207         struct unwind_table *table;
208         int init_only;
209 };
210
211 static int unlink_table(void *arg)
212 {
213         struct unlink_table_info *info = arg;
214         struct unwind_table *table = info->table, *prev;
215
216         for (prev = &root_table; prev->link && prev->link != table; prev = prev->link)
217                 ;
218
219         if (prev->link) {
220                 if (info->init_only) {
221                         table->init.pc = 0;
222                         table->init.range = 0;
223                         info->table = NULL;
224                 } else {
225                         prev->link = table->link;
226                         if (!prev->link)
227                                 last_table = prev;
228                 }
229         } else
230                 info->table = NULL;
231
232         return 0;
233 }
234
235 /* Must be called with module_mutex held. */
236 void unwind_remove_table(void *handle, int init_only)
237 {
238         struct unwind_table *table = handle;
239         struct unlink_table_info info;
240
241         if (!table || table == &root_table)
242                 return;
243
244         if (init_only && table == last_table) {
245                 table->init.pc = 0;
246                 table->init.range = 0;
247                 return;
248         }
249
250         info.table = table;
251         info.init_only = init_only;
252         stop_machine_run(unlink_table, &info, NR_CPUS);
253
254         if (info.table)
255                 kfree(table);
256 }
257
258 #endif /* CONFIG_MODULES */
259
260 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
261 {
262         const u8 *cur = *pcur;
263         uleb128_t value;
264         unsigned shift;
265
266         for (shift = 0, value = 0; cur < end; shift += 7) {
267                 if (shift + 7 > 8 * sizeof(value)
268                     && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
269                         cur = end + 1;
270                         break;
271                 }
272                 value |= (uleb128_t)(*cur & 0x7f) << shift;
273                 if (!(*cur++ & 0x80))
274                         break;
275         }
276         *pcur = cur;
277
278         return value;
279 }
280
281 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
282 {
283         const u8 *cur = *pcur;
284         sleb128_t value;
285         unsigned shift;
286
287         for (shift = 0, value = 0; cur < end; shift += 7) {
288                 if (shift + 7 > 8 * sizeof(value)
289                     && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
290                         cur = end + 1;
291                         break;
292                 }
293                 value |= (sleb128_t)(*cur & 0x7f) << shift;
294                 if (!(*cur & 0x80)) {
295                         value |= -(*cur++ & 0x40) << shift;
296                         break;
297                 }
298         }
299         *pcur = cur;
300
301         return value;
302 }
303
304 static unsigned long read_pointer(const u8 **pLoc,
305                                   const void *end,
306                                   signed ptrType)
307 {
308         unsigned long value = 0;
309         union {
310                 const u8 *p8;
311                 const u16 *p16u;
312                 const s16 *p16s;
313                 const u32 *p32u;
314                 const s32 *p32s;
315                 const unsigned long *pul;
316         } ptr;
317
318         if (ptrType < 0 || ptrType == DW_EH_PE_omit)
319                 return 0;
320         ptr.p8 = *pLoc;
321         switch(ptrType & DW_EH_PE_FORM) {
322         case DW_EH_PE_data2:
323                 if (end < (const void *)(ptr.p16u + 1))
324                         return 0;
325                 if(ptrType & DW_EH_PE_signed)
326                         value = get_unaligned(ptr.p16s++);
327                 else
328                         value = get_unaligned(ptr.p16u++);
329                 break;
330         case DW_EH_PE_data4:
331 #ifdef CONFIG_64BIT
332                 if (end < (const void *)(ptr.p32u + 1))
333                         return 0;
334                 if(ptrType & DW_EH_PE_signed)
335                         value = get_unaligned(ptr.p32s++);
336                 else
337                         value = get_unaligned(ptr.p32u++);
338                 break;
339         case DW_EH_PE_data8:
340                 BUILD_BUG_ON(sizeof(u64) != sizeof(value));
341 #else
342                 BUILD_BUG_ON(sizeof(u32) != sizeof(value));
343 #endif
344         case DW_EH_PE_native:
345                 if (end < (const void *)(ptr.pul + 1))
346                         return 0;
347                 value = get_unaligned(ptr.pul++);
348                 break;
349         case DW_EH_PE_leb128:
350                 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
351                 value = ptrType & DW_EH_PE_signed
352                         ? get_sleb128(&ptr.p8, end)
353                         : get_uleb128(&ptr.p8, end);
354                 if ((const void *)ptr.p8 > end)
355                         return 0;
356                 break;
357         default:
358                 return 0;
359         }
360         switch(ptrType & DW_EH_PE_ADJUST) {
361         case DW_EH_PE_abs:
362                 break;
363         case DW_EH_PE_pcrel:
364                 value += (unsigned long)*pLoc;
365                 break;
366         default:
367                 return 0;
368         }
369         if ((ptrType & DW_EH_PE_indirect)
370             && __get_user(value, (unsigned long *)value))
371                 return 0;
372         *pLoc = ptr.p8;
373
374         return value;
375 }
376
377 static signed fde_pointer_type(const u32 *cie)
378 {
379         const u8 *ptr = (const u8 *)(cie + 2);
380         unsigned version = *ptr;
381
382         if (version != 1)
383                 return -1; /* unsupported */
384         if (*++ptr) {
385                 const char *aug;
386                 const u8 *end = (const u8 *)(cie + 1) + *cie;
387                 uleb128_t len;
388
389                 /* check if augmentation size is first (and thus present) */
390                 if (*ptr != 'z')
391                         return -1;
392                 /* check if augmentation string is nul-terminated */
393                 if ((ptr = memchr(aug = (const void *)ptr, 0, end - ptr)) == NULL)
394                         return -1;
395                 ++ptr; /* skip terminator */
396                 get_uleb128(&ptr, end); /* skip code alignment */
397                 get_sleb128(&ptr, end); /* skip data alignment */
398                 /* skip return address column */
399                 version <= 1 ? (void)++ptr : (void)get_uleb128(&ptr, end);
400                 len = get_uleb128(&ptr, end); /* augmentation length */
401                 if (ptr + len < ptr || ptr + len > end)
402                         return -1;
403                 end = ptr + len;
404                 while (*++aug) {
405                         if (ptr >= end)
406                                 return -1;
407                         switch(*aug) {
408                         case 'L':
409                                 ++ptr;
410                                 break;
411                         case 'P': {
412                                         signed ptrType = *ptr++;
413
414                                         if (!read_pointer(&ptr, end, ptrType) || ptr > end)
415                                                 return -1;
416                                 }
417                                 break;
418                         case 'R':
419                                 return *ptr;
420                         default:
421                                 return -1;
422                         }
423                 }
424         }
425         return DW_EH_PE_native|DW_EH_PE_abs;
426 }
427
428 static int advance_loc(unsigned long delta, struct unwind_state *state)
429 {
430         state->loc += delta * state->codeAlign;
431
432         return delta > 0;
433 }
434
435 static void set_rule(uleb128_t reg,
436                      enum item_location where,
437                      uleb128_t value,
438                      struct unwind_state *state)
439 {
440         if (reg < ARRAY_SIZE(state->regs)) {
441                 state->regs[reg].where = where;
442                 state->regs[reg].value = value;
443         }
444 }
445
446 static int processCFI(const u8 *start,
447                       const u8 *end,
448                       unsigned long targetLoc,
449                       signed ptrType,
450                       struct unwind_state *state)
451 {
452         union {
453                 const u8 *p8;
454                 const u16 *p16;
455                 const u32 *p32;
456         } ptr;
457         int result = 1;
458
459         if (start != state->cieStart) {
460                 state->loc = state->org;
461                 result = processCFI(state->cieStart, state->cieEnd, 0, ptrType, state);
462                 if (targetLoc == 0 && state->label == NULL)
463                         return result;
464         }
465         for (ptr.p8 = start; result && ptr.p8 < end; ) {
466                 switch(*ptr.p8 >> 6) {
467                         uleb128_t value;
468
469                 case 0:
470                         switch(*ptr.p8++) {
471                         case DW_CFA_nop:
472                                 break;
473                         case DW_CFA_set_loc:
474                                 if ((state->loc = read_pointer(&ptr.p8, end, ptrType)) == 0)
475                                         result = 0;
476                                 break;
477                         case DW_CFA_advance_loc1:
478                                 result = ptr.p8 < end && advance_loc(*ptr.p8++, state);
479                                 break;
480                         case DW_CFA_advance_loc2:
481                                 result = ptr.p8 <= end + 2
482                                          && advance_loc(*ptr.p16++, state);
483                                 break;
484                         case DW_CFA_advance_loc4:
485                                 result = ptr.p8 <= end + 4
486                                          && advance_loc(*ptr.p32++, state);
487                                 break;
488                         case DW_CFA_offset_extended:
489                                 value = get_uleb128(&ptr.p8, end);
490                                 set_rule(value, Memory, get_uleb128(&ptr.p8, end), state);
491                                 break;
492                         case DW_CFA_val_offset:
493                                 value = get_uleb128(&ptr.p8, end);
494                                 set_rule(value, Value, get_uleb128(&ptr.p8, end), state);
495                                 break;
496                         case DW_CFA_offset_extended_sf:
497                                 value = get_uleb128(&ptr.p8, end);
498                                 set_rule(value, Memory, get_sleb128(&ptr.p8, end), state);
499                                 break;
500                         case DW_CFA_val_offset_sf:
501                                 value = get_uleb128(&ptr.p8, end);
502                                 set_rule(value, Value, get_sleb128(&ptr.p8, end), state);
503                                 break;
504                         case DW_CFA_restore_extended:
505                         case DW_CFA_undefined:
506                         case DW_CFA_same_value:
507                                 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0, state);
508                                 break;
509                         case DW_CFA_register:
510                                 value = get_uleb128(&ptr.p8, end);
511                                 set_rule(value,
512                                          Register,
513                                          get_uleb128(&ptr.p8, end), state);
514                                 break;
515                         case DW_CFA_remember_state:
516                                 if (ptr.p8 == state->label) {
517                                         state->label = NULL;
518                                         return 1;
519                                 }
520                                 if (state->stackDepth >= MAX_STACK_DEPTH)
521                                         return 0;
522                                 state->stack[state->stackDepth++] = ptr.p8;
523                                 break;
524                         case DW_CFA_restore_state:
525                                 if (state->stackDepth) {
526                                         const uleb128_t loc = state->loc;
527                                         const u8 *label = state->label;
528
529                                         state->label = state->stack[state->stackDepth - 1];
530                                         memcpy(&state->cfa, &badCFA, sizeof(state->cfa));
531                                         memset(state->regs, 0, sizeof(state->regs));
532                                         state->stackDepth = 0;
533                                         result = processCFI(start, end, 0, ptrType, state);
534                                         state->loc = loc;
535                                         state->label = label;
536                                 } else
537                                         return 0;
538                                 break;
539                         case DW_CFA_def_cfa:
540                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
541                                 /*nobreak*/
542                         case DW_CFA_def_cfa_offset:
543                                 state->cfa.offs = get_uleb128(&ptr.p8, end);
544                                 break;
545                         case DW_CFA_def_cfa_sf:
546                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
547                                 /*nobreak*/
548                         case DW_CFA_def_cfa_offset_sf:
549                                 state->cfa.offs = get_sleb128(&ptr.p8, end)
550                                                   * state->dataAlign;
551                                 break;
552                         case DW_CFA_def_cfa_register:
553                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
554                                 break;
555                         /*todo case DW_CFA_def_cfa_expression: */
556                         /*todo case DW_CFA_expression: */
557                         /*todo case DW_CFA_val_expression: */
558                         case DW_CFA_GNU_args_size:
559                                 get_uleb128(&ptr.p8, end);
560                                 break;
561                         case DW_CFA_GNU_negative_offset_extended:
562                                 value = get_uleb128(&ptr.p8, end);
563                                 set_rule(value,
564                                          Memory,
565                                          (uleb128_t)0 - get_uleb128(&ptr.p8, end), state);
566                                 break;
567                         case DW_CFA_GNU_window_save:
568                         default:
569                                 result = 0;
570                                 break;
571                         }
572                         break;
573                 case 1:
574                         result = advance_loc(*ptr.p8++ & 0x3f, state);
575                         break;
576                 case 2:
577                         value = *ptr.p8++ & 0x3f;
578                         set_rule(value, Memory, get_uleb128(&ptr.p8, end), state);
579                         break;
580                 case 3:
581                         set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
582                         break;
583                 }
584                 if (ptr.p8 > end)
585                         result = 0;
586                 if (result && targetLoc != 0 && targetLoc < state->loc)
587                         return 1;
588         }
589
590         return result
591            && ptr.p8 == end
592            && (targetLoc == 0
593             || (/*todo While in theory this should apply, gcc in practice omits
594                   everything past the function prolog, and hence the location
595                   never reaches the end of the function.
596                 targetLoc < state->loc &&*/ state->label == NULL));
597 }
598
599 /* Unwind to previous to frame.  Returns 0 if successful, negative
600  * number in case of an error. */
601 int unwind(struct unwind_frame_info *frame)
602 {
603 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
604         const u32 *fde = NULL, *cie = NULL;
605         const u8 *ptr = NULL, *end = NULL;
606         unsigned long startLoc = 0, endLoc = 0, cfa;
607         unsigned i;
608         signed ptrType = -1;
609         uleb128_t retAddrReg = 0;
610         struct unwind_table *table;
611         struct unwind_state state;
612
613         if (UNW_PC(frame) == 0)
614                 return -EINVAL;
615         if ((table = find_table(UNW_PC(frame))) != NULL
616             && !(table->size & (sizeof(*fde) - 1))) {
617                 unsigned long tableSize = table->size;
618
619                 for (fde = table->address;
620                      tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
621                      tableSize -= sizeof(*fde) + *fde,
622                      fde += 1 + *fde / sizeof(*fde)) {
623                         if (!*fde || (*fde & (sizeof(*fde) - 1)))
624                                 break;
625                         if (!fde[1])
626                                 continue; /* this is a CIE */
627                         if ((fde[1] & (sizeof(*fde) - 1))
628                             || fde[1] > (unsigned long)(fde + 1)
629                                         - (unsigned long)table->address)
630                                 continue; /* this is not a valid FDE */
631                         cie = fde + 1 - fde[1] / sizeof(*fde);
632                         if (*cie <= sizeof(*cie) + 4
633                             || *cie >= fde[1] - sizeof(*fde)
634                             || (*cie & (sizeof(*cie) - 1))
635                             || cie[1]
636                             || (ptrType = fde_pointer_type(cie)) < 0) {
637                                 cie = NULL; /* this is not a (valid) CIE */
638                                 continue;
639                         }
640                         ptr = (const u8 *)(fde + 2);
641                         startLoc = read_pointer(&ptr,
642                                                 (const u8 *)(fde + 1) + *fde,
643                                                 ptrType);
644                         endLoc = startLoc
645                                  + read_pointer(&ptr,
646                                                 (const u8 *)(fde + 1) + *fde,
647                                                 ptrType & DW_EH_PE_indirect
648                                                 ? ptrType
649                                                 : ptrType & (DW_EH_PE_FORM|DW_EH_PE_signed));
650                         if (UNW_PC(frame) >= startLoc && UNW_PC(frame) < endLoc)
651                                 break;
652                         cie = NULL;
653                 }
654         }
655         if (cie != NULL) {
656                 memset(&state, 0, sizeof(state));
657                 state.cieEnd = ptr; /* keep here temporarily */
658                 ptr = (const u8 *)(cie + 2);
659                 end = (const u8 *)(cie + 1) + *cie;
660                 if ((state.version = *ptr) != 1)
661                         cie = NULL; /* unsupported version */
662                 else if (*++ptr) {
663                         /* check if augmentation size is first (and thus present) */
664                         if (*ptr == 'z') {
665                                 /* check for ignorable (or already handled)
666                                  * nul-terminated augmentation string */
667                                 while (++ptr < end && *ptr)
668                                         if (strchr("LPR", *ptr) == NULL)
669                                                 break;
670                         }
671                         if (ptr >= end || *ptr)
672                                 cie = NULL;
673                 }
674                 ++ptr;
675         }
676         if (cie != NULL) {
677                 /* get code aligment factor */
678                 state.codeAlign = get_uleb128(&ptr, end);
679                 /* get data aligment factor */
680                 state.dataAlign = get_sleb128(&ptr, end);
681                 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
682                         cie = NULL;
683                 else {
684                         retAddrReg = state.version <= 1 ? *ptr++ : get_uleb128(&ptr, end);
685                         /* skip augmentation */
686                         if (((const char *)(cie + 2))[1] == 'z')
687                                 ptr += get_uleb128(&ptr, end);
688                         if (ptr > end
689                            || retAddrReg >= ARRAY_SIZE(reg_info)
690                            || REG_INVALID(retAddrReg)
691                            || reg_info[retAddrReg].width != sizeof(unsigned long))
692                                 cie = NULL;
693                 }
694         }
695         if (cie != NULL) {
696                 state.cieStart = ptr;
697                 ptr = state.cieEnd;
698                 state.cieEnd = end;
699                 end = (const u8 *)(fde + 1) + *fde;
700                 /* skip augmentation */
701                 if (((const char *)(cie + 2))[1] == 'z') {
702                         uleb128_t augSize = get_uleb128(&ptr, end);
703
704                         if ((ptr += augSize) > end)
705                                 fde = NULL;
706                 }
707         }
708         if (cie == NULL || fde == NULL) {
709 #ifdef CONFIG_FRAME_POINTER
710                 unsigned long top, bottom;
711 #endif
712
713 #ifdef CONFIG_FRAME_POINTER
714                 top = STACK_TOP(frame->task);
715                 bottom = STACK_BOTTOM(frame->task);
716 # if FRAME_RETADDR_OFFSET < 0
717                 if (UNW_SP(frame) < top
718                     && UNW_FP(frame) <= UNW_SP(frame)
719                     && bottom < UNW_FP(frame)
720 # else
721                 if (UNW_SP(frame) > top
722                     && UNW_FP(frame) >= UNW_SP(frame)
723                     && bottom > UNW_FP(frame)
724 # endif
725                    && !((UNW_SP(frame) | UNW_FP(frame))
726                         & (sizeof(unsigned long) - 1))) {
727                         unsigned long link;
728
729                         if (!__get_user(link,
730                                         (unsigned long *)(UNW_FP(frame)
731                                                           + FRAME_LINK_OFFSET))
732 # if FRAME_RETADDR_OFFSET < 0
733                            && link > bottom && link < UNW_FP(frame)
734 # else
735                            && link > UNW_FP(frame) && link < bottom
736 # endif
737                            && !(link & (sizeof(link) - 1))
738                            && !__get_user(UNW_PC(frame),
739                                           (unsigned long *)(UNW_FP(frame)
740                                                             + FRAME_RETADDR_OFFSET))) {
741                                 UNW_SP(frame) = UNW_FP(frame) + FRAME_RETADDR_OFFSET
742 # if FRAME_RETADDR_OFFSET < 0
743                                         -
744 # else
745                                         +
746 # endif
747                                           sizeof(UNW_PC(frame));
748                                 UNW_FP(frame) = link;
749                                 return 0;
750                         }
751                 }
752 #endif
753                 return -ENXIO;
754         }
755         state.org = startLoc;
756         memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
757         /* process instructions */
758         if (!processCFI(ptr, end, UNW_PC(frame), ptrType, &state)
759            || state.loc > endLoc
760            || state.regs[retAddrReg].where == Nowhere
761            || state.cfa.reg >= ARRAY_SIZE(reg_info)
762            || reg_info[state.cfa.reg].width != sizeof(unsigned long)
763            || state.cfa.offs % sizeof(unsigned long))
764                 return -EIO;
765         /* update frame */
766         cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
767         startLoc = min((unsigned long)UNW_SP(frame), cfa);
768         endLoc = max((unsigned long)UNW_SP(frame), cfa);
769         if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
770                 startLoc = min(STACK_LIMIT(cfa), cfa);
771                 endLoc = max(STACK_LIMIT(cfa), cfa);
772         }
773 #ifndef CONFIG_64BIT
774 # define CASES CASE(8); CASE(16); CASE(32)
775 #else
776 # define CASES CASE(8); CASE(16); CASE(32); CASE(64)
777 #endif
778         for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
779                 if (REG_INVALID(i)) {
780                         if (state.regs[i].where == Nowhere)
781                                 continue;
782                         return -EIO;
783                 }
784                 switch(state.regs[i].where) {
785                 default:
786                         break;
787                 case Register:
788                         if (state.regs[i].value >= ARRAY_SIZE(reg_info)
789                            || REG_INVALID(state.regs[i].value)
790                            || reg_info[i].width > reg_info[state.regs[i].value].width)
791                                 return -EIO;
792                         switch(reg_info[state.regs[i].value].width) {
793 #define CASE(n) \
794                         case sizeof(u##n): \
795                                 state.regs[i].value = FRAME_REG(state.regs[i].value, \
796                                                                 const u##n); \
797                                 break
798                         CASES;
799 #undef CASE
800                         default:
801                                 return -EIO;
802                         }
803                         break;
804                 }
805         }
806         for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
807                 if (REG_INVALID(i))
808                         continue;
809                 switch(state.regs[i].where) {
810                 case Nowhere:
811                         if (reg_info[i].width != sizeof(UNW_SP(frame))
812                            || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
813                               != &UNW_SP(frame))
814                                 continue;
815                         UNW_SP(frame) = cfa;
816                         break;
817                 case Register:
818                         switch(reg_info[i].width) {
819 #define CASE(n) case sizeof(u##n): \
820                                 FRAME_REG(i, u##n) = state.regs[i].value; \
821                                 break
822                         CASES;
823 #undef CASE
824                         default:
825                                 return -EIO;
826                         }
827                         break;
828                 case Value:
829                         if (reg_info[i].width != sizeof(unsigned long))
830                                 return -EIO;
831                         FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
832                                                             * state.dataAlign;
833                         break;
834                 case Memory: {
835                                 unsigned long addr = cfa + state.regs[i].value
836                                                            * state.dataAlign;
837
838                                 if ((state.regs[i].value * state.dataAlign)
839                                     % sizeof(unsigned long)
840                                     || addr < startLoc
841                                     || addr + sizeof(unsigned long) < addr
842                                     || addr + sizeof(unsigned long) > endLoc)
843                                         return -EIO;
844                                 switch(reg_info[i].width) {
845 #define CASE(n)     case sizeof(u##n): \
846                                         __get_user(FRAME_REG(i, u##n), (u##n *)addr); \
847                                         break
848                                 CASES;
849 #undef CASE
850                                 default:
851                                         return -EIO;
852                                 }
853                         }
854                         break;
855                 }
856         }
857
858         return 0;
859 #undef CASES
860 #undef FRAME_REG
861 }
862 EXPORT_SYMBOL(unwind);
863
864 int unwind_init_frame_info(struct unwind_frame_info *info,
865                            struct task_struct *tsk,
866                            /*const*/ struct pt_regs *regs)
867 {
868         info->task = tsk;
869         arch_unw_init_frame_info(info, regs);
870
871         return 0;
872 }
873 EXPORT_SYMBOL(unwind_init_frame_info);
874
875 /*
876  * Prepare to unwind a blocked task.
877  */
878 int unwind_init_blocked(struct unwind_frame_info *info,
879                         struct task_struct *tsk)
880 {
881         info->task = tsk;
882         arch_unw_init_blocked(info);
883
884         return 0;
885 }
886 EXPORT_SYMBOL(unwind_init_blocked);
887
888 /*
889  * Prepare to unwind the currently running thread.
890  */
891 int unwind_init_running(struct unwind_frame_info *info,
892                         asmlinkage int (*callback)(struct unwind_frame_info *,
893                                                    void *arg),
894                         void *arg)
895 {
896         info->task = current;
897
898         return arch_unwind_init_running(info, callback, arg);
899 }
900 EXPORT_SYMBOL(unwind_init_running);
901
902 /*
903  * Unwind until the return pointer is in user-land (or until an error
904  * occurs).  Returns 0 if successful, negative number in case of
905  * error.
906  */
907 int unwind_to_user(struct unwind_frame_info *info)
908 {
909         while (!arch_unw_user_mode(info)) {
910                 int err = unwind(info);
911
912                 if (err < 0)
913                         return err;
914         }
915
916         return 0;
917 }
918 EXPORT_SYMBOL(unwind_to_user);