]> sourceware.org Git - systemtap.git/blob - runtime/unwind.c
git://sourceware.org / systemtap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update copyrights
[systemtap.git] / runtime / unwind.c
1 /* -*- linux-c -*-
2 * kernel stack unwinding
3 * Copyright (C) 2008-2011, 2014 Red Hat Inc.
4 *
5 * Based on old kernel code that is
6 * Copyright (C) 2002-2006 Novell, Inc.
7 * Jan Beulich <jbeulich@novell.com>
8 *
9 * This code is released under version 2 of the GNU GPL.
10 *
11 * This code currently does stack unwinding in the kernel and modules.
12 * It has been extended to handle userspace unwinding using systemtap
13 * data structures.
14 */
15
16 #include "unwind/unwind.h"
17
18 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
19 {
20 const u8 *cur = *pcur;
21 uleb128_t value = 0;
22 unsigned shift;
23
24 for (shift = 0; cur < end; shift += 7) {
25 if (shift + 7 > 8 * sizeof(value)
26 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
27 cur = end + 1;
28 break;
29 }
30 value |= (uleb128_t)(*cur & 0x7f) << shift;
31 if (!(*cur++ & 0x80))
32 break;
33 }
34 *pcur = cur;
35
36 return value;
37 }
38
39 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
40 {
41 const u8 *cur = *pcur;
42 sleb128_t value = 0;
43 unsigned shift;
44
45 for (shift = 0; cur < end; shift += 7) {
46 if (shift + 7 > 8 * sizeof(value)
47 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
48 cur = end + 1;
49 break;
50 }
51 value |= (sleb128_t)(*cur & 0x7f) << shift;
52 if (!(*cur & 0x80)) {
53 value |= -(*cur++ & 0x40) << shift;
54 break;
55 }
56 }
57 *pcur = cur;
58
59 return value;
60 }
61
62 /* Whether this is a real CIE. Assumes CIE (length) sane. */
63 static int has_cie_id(const u32 *cie, int is_ehframe)
64 {
65 /* CIE id for eh_frame is 0, otherwise 0xffffffff */
66 if (is_ehframe && cie[1] == 0)
67 return 1;
68 else if (cie[1] == 0xffffffff)
69 return 1;
70 else
71 return 0;
72 }
73
74 /* whether this is a real fde or not */
75 static int is_fde(const u32 *fde, void *table, uint32_t table_len,
76 int is_ehframe)
77 {
78 const u8 *end;
79
80 /* check that length is proper */
81 if (!*fde || (*fde & (sizeof(*fde) - 1))) {
82 _stp_warn("bad fde\n");
83 return 0;
84 }
85
86 if (has_cie_id(fde, is_ehframe))
87 return 0;
88
89 end = (const u8 *)(fde + 1) + *fde;
90
91 /* end should fall within unwind table. */
92 if (((void*)end) < table
93 || ((void *)end) > ((void *)(table + table_len))) {
94 _stp_warn("bad fde length\n");
95 return 0;
96 }
97
98 return 1;
99 }
100
101 /* given an FDE, find its CIE and sanity check */
102 static const u32 *cie_for_fde(const u32 *fde, void *unwind_data,
103 uint32_t table_len, int is_ehframe)
104 {
105 const u32 *cie;
106 unsigned version;
107 const u8 *end;
108
109 /* CIE_pointer must be a proper offset */
110 if ((fde[1] & (sizeof(*fde) - 1)) || fde[1] > (unsigned long)(fde + 1) - (unsigned long)unwind_data) {
111 _stp_warn("invalid fde[1]=%lx fde+1=%lx, unwind_data=%lx %lx\n",
112 (unsigned long)fde[1], (unsigned long)(fde + 1),
113 (unsigned long)unwind_data, (unsigned long)(fde + 1) - (unsigned long)unwind_data);
114 return NULL; /* this is not a valid FDE */
115 }
116
117 /* cie pointer field is different in eh_frame vs debug_frame */
118 if (is_ehframe)
119 cie = fde + 1 - fde[1] / sizeof(*fde);
120 else
121 cie = unwind_data + fde[1];
122
123 /* Make sure address falls in the table */
124 if (((void *)cie) < ((void*)unwind_data)
125 || ((void*)cie) > ((void*)(unwind_data + table_len))) {
126 _stp_warn("cie address falls outside table\n");
127 return NULL;
128 }
129
130 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde)
131 || ! has_cie_id(cie, is_ehframe)) {
132 _stp_warn("cie is not valid %lx %x %x %x\n", (unsigned long)cie, *cie, fde[1], cie[1]);
133 return NULL; /* this is not a (valid) CIE */
134 }
135
136 version = *(const u8 *)(cie + 2);
137 if (version != 1 && version != 3 && version != 4) {
138 _stp_warn ("Unsupported CIE version: %d\n", version);
139 return NULL;
140 }
141
142 end = (const u8 *)(cie + 1) + *cie;
143
144 /* end should fall within unwind table. */
145 if (((void *)end) < (void *)unwind_data
146 || ((void *)end) > ((void *)(unwind_data + table_len))) {
147 _stp_warn ("CIE end falls outside table\n");
148 return NULL;
149 }
150
151 return cie;
152 }
153
154 /* read an encoded pointer and increment *pLoc past the end of the
155 * data read. */
156 static unsigned long read_ptr_sect(const u8 **pLoc, const void *end,
157 signed ptrType, unsigned long textAddr,
158 unsigned long dataAddr, int user, int compat_task, int tableSize)
159 {
160 unsigned long value = 0;
161 union {
162 const u8 *p8;
163 const u16 *p16u;
164 const s16 *p16s;
165 const u32 *p32u;
166 const s32 *p32s;
167 const unsigned long *pul;
168 const unsigned int *pui;
169 } ptr;
170
171 if (ptrType < 0 || ptrType == DW_EH_PE_omit)
172 return 0;
173
174 ptr.p8 = *pLoc;
175 switch (ptrType & DW_EH_PE_FORM) {
176 case DW_EH_PE_data2:
177 if (end < (const void *)(ptr.p16u + 1))
178 return 0;
179 if (ptrType & DW_EH_PE_signed)
180 value = _stp_get_unaligned(ptr.p16s++);
181 else
182 value = _stp_get_unaligned(ptr.p16u++);
183 break;
184 case DW_EH_PE_data4:
185 #ifdef CONFIG_64BIT
186
187 /* If the tableSize matches the length of data we're trying to return
188 * or if specifically set to 0 in the call it means we actually want a
189 * DW_EH_PE_data4 and not a DW_EH_PE_absptr. If this is not the case
190 * then we want to fall through to DW_EH_PE_absptr */
191 if (!compat_task || (compat_task && (tableSize == 4 || tableSize == 0)))
192 {
193 if (end < (const void *)(ptr.p32u + 1))
194 return 0;
195
196 if (ptrType & DW_EH_PE_signed)
197 value = _stp_get_unaligned(ptr.p32s++);
198 else
199 value = _stp_get_unaligned(ptr.p32u++);
200 break;
201 }
202 case DW_EH_PE_data8:
203 BUILD_BUG_ON(sizeof(u64) != sizeof(value));
204 #else
205 BUILD_BUG_ON(sizeof(u32) != sizeof(value));
206 #endif
207 case DW_EH_PE_absptr:
208 if (compat_task)
209 {
210 if (end < (const void *)(ptr.pui + 1))
211 return 0;
212 value = _stp_get_unaligned(ptr.pui++);
213 } else {
214 if (end < (const void *)(ptr.pul + 1))
215 return 0;
216 value = _stp_get_unaligned(ptr.pul++);
217 }
218
219 break;
220 case DW_EH_PE_leb128:
221 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
222 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end)
223 : get_uleb128(&ptr.p8, end);
224 if ((const void *)ptr.p8 > end)
225 return 0;
226 break;
227 default:
228 return 0;
229 }
230 switch (ptrType & DW_EH_PE_ADJUST) {
231 case DW_EH_PE_absptr:
232 break;
233 case DW_EH_PE_pcrel:
234 value += (unsigned long)*pLoc;
235 break;
236 case DW_EH_PE_textrel:
237 value += textAddr;
238 break;
239 case DW_EH_PE_datarel:
240 value += dataAddr;
241 break;
242 default:
243 return 0;
244 }
245 if ((ptrType & DW_EH_PE_indirect)
246 && _stp_read_address(value, (unsigned long *)value,
247 (user ? USER_DS : KERNEL_DS)))
248 return 0;
249 *pLoc = ptr.p8;
250
251 return value;
252 }
253
254 static unsigned long read_pointer(const u8 **pLoc, const void *end, signed ptrType,
255 int user, int compat_task)
256 {
257 return read_ptr_sect(pLoc, end, ptrType, 0, 0, user, compat_task, 0);
258 }
259
260 /* Parse FDE and CIE content. Basic sanity checks should already have
261 been done start/end/version/id (done by is_fde and cie_for_fde).
262 Returns -1 if FDE or CIE cannot be parsed.*/
263 static int parse_fde_cie(const u32 *fde, const u32 *cie,
264 void *unwind_data, uint32_t table_len,
265 unsigned *ptrType, int user,
266 unsigned long *startLoc, unsigned long *locRange,
267 const u8 **fdeStart, const u8 **fdeEnd,
268 const u8 **cieStart, const u8 **cieEnd,
269 uleb128_t *codeAlign, sleb128_t *dataAlign,
270 uleb128_t *retAddrReg, unsigned *call_frame, int compat_task)
271 {
272 const u8 *ciePtr = (const u8 *)(cie + 2);
273 const u8 *fdePtr = (const u8 *)(fde + 2);
274 unsigned version = *ciePtr++;
275 const char *aug = (const void *)ciePtr;
276 uleb128_t augLen = 0; /* Set to non-zero if cie aug starts with z */
277
278 *cieEnd = (const u8 *)(cie + 1) + *cie;
279 *fdeEnd = (const u8 *)(fde + 1) + *fde;
280
281 /* check if augmentation string is nul-terminated */
282 if ((ciePtr = memchr(aug, 0, *cieEnd - ciePtr)) == NULL) {
283 _stp_warn("Unterminated augmentation string\n");
284 return -1;
285 }
286 ciePtr++; /* skip aug terminator */
287
288 *codeAlign = get_uleb128(&ciePtr, *cieEnd);
289 *dataAlign = get_sleb128(&ciePtr, *cieEnd);
290 dbug_unwind(2, "codeAlign=%lx, dataAlign=%lx\n",
291 *codeAlign, *dataAlign);
292 if (*codeAlign == 0 || *dataAlign == 0) {
293 _stp_warn("zero codeAlign or dataAlign values\n");
294 return -1;
295 }
296
297 *retAddrReg = ((version <= 1)
298 ? *ciePtr++ : get_uleb128(&ciePtr, *cieEnd));
299 if(compat_task){
300 dbug_unwind(1, "map retAddrReg value %ld to reg_info idx %ld\n",
301 *retAddrReg, COMPAT_REG_MAP(DWARF_REG_MAP(*retAddrReg)));
302 *retAddrReg = COMPAT_REG_MAP(DWARF_REG_MAP(*retAddrReg));
303 } else {
304 dbug_unwind(1, "map retAddrReg value %ld to reg_info idx %ld\n",
305 *retAddrReg, DWARF_REG_MAP(*retAddrReg));
306 *retAddrReg = DWARF_REG_MAP(*retAddrReg);
307 }
308
309 if (*aug == 'z') {
310 augLen = get_uleb128(&ciePtr, *cieEnd);
311 if (augLen > (const u8 *)cie - *cieEnd
312 || ciePtr + augLen > *cieEnd) {
313 _stp_warn("Bogus CIE augmentation length\n");
314 return -1;
315 }
316 }
317 *cieStart = ciePtr + augLen;
318
319 /* Read augmentation string to determine frame_call and ptrType. */
320 *call_frame = 1;
321 *ptrType = DW_EH_PE_absptr;
322 while (*aug) {
323 if (ciePtr > *cieStart) {
324 _stp_warn("Augmentation data runs past end\n");
325 return -1;
326 }
327 switch (*aug) {
328 case 'z':
329 break;
330 case 'L':
331 ciePtr++;
332 break;
333 case 'P': {
334 /* We are not actually interested in
335 the value, so don't try to deref.
336 Mask off DW_EH_PE_indirect. */
337 signed pType = *ciePtr++ & 0x7F;
338 if (!read_pointer(&ciePtr, *cieStart, pType, user, compat_task)) {
339 _stp_warn("couldn't read personality routine handler\n");
340 return -1;
341 }
342 break;
343 }
344 case 'R':
345 *ptrType = *ciePtr++;
346 break;
347 case 'S':
348 *call_frame = 0;
349 break;
350 default:
351 _stp_warn("Unknown augmentation char '%c'\n", *(aug - 1));
352 return -1;
353 }
354 aug++;
355 }
356 if (ciePtr != *cieStart) {
357 _stp_warn("Bogus CIE augmentation data\n");
358 return -1;
359 }
360
361 /* Now we finally know the type encoding and whether or not the
362 augmentation string starts with 'z' indicating the FDE might also
363 have some augmentation data, so we can parse the FDE. */
364 *startLoc = read_pointer(&fdePtr, *fdeEnd, *ptrType, user, compat_task);
365 *locRange = read_pointer(&fdePtr, *fdeEnd,
366 *ptrType & (DW_EH_PE_FORM | DW_EH_PE_signed),
367 user, compat_task);
368 dbug_unwind(2, "startLoc: %lx, locrange: %lx\n",
369 *startLoc, *locRange);
370
371 /* Skip FDE augmentation length (not interested in data). */
372 if (augLen != 0) {
373 augLen = get_uleb128(&fdePtr, *fdeEnd);
374 if (augLen > (const u8 *)fde - *fdeEnd
375 || fdePtr + augLen > *fdeEnd) {
376 _stp_warn("Bogus FDE augmentation length\n");
377 return -1;
378 }
379 }
380 *fdeStart = fdePtr + augLen;
381
382 return 0;
383 }
384
385 #define REG_STATE state->reg[state->stackDepth]
386
387 static int advance_loc(unsigned long delta, struct unwind_state *state)
388 {
389 state->loc += delta * state->codeAlign;
390 dbug_unwind(1, "state->loc=%lx\n", state->loc);
391 return delta > 0;
392 }
393
394 /* Set Same or Nowhere rule for register. */
395 static void set_no_state_rule(uleb128_t reg, enum item_location where,
396 struct unwind_state *state)
397 {
398 dbug_unwind(1, "reg=%lx, where=%d\n", reg, where);
399 if (reg < ARRAY_SIZE(REG_STATE.regs)) {
400 REG_STATE.regs[reg].where = where;
401 }
402 }
403
404 /* Memory or Value rule */
405 static void set_offset_rule(uleb128_t reg, enum item_location where,
406 sleb128_t svalue, struct unwind_state *state)
407 {
408 dbug_unwind(1, "reg=%lx, where=%d, svalue=%lx\n", reg, where, svalue);
409 if (reg < ARRAY_SIZE(REG_STATE.regs)) {
410 REG_STATE.regs[reg].where = where;
411 REG_STATE.regs[reg].state.off = svalue;
412 }
413 }
414
415 /* Register rule. */
416 static void set_register_rule(uleb128_t reg, uleb128_t value,
417 struct unwind_state *state)
418 {
419 dbug_unwind(1, "reg=%lx, value=%lx\n", reg, value);
420 if (reg < ARRAY_SIZE(REG_STATE.regs)) {
421 REG_STATE.regs[reg].where = Register;
422 REG_STATE.regs[reg].state.reg = value;
423 }
424 }
425
426 /* Expr or ValExpr rule. */
427 static void set_expr_rule(uleb128_t reg, enum item_location where,
428 const u8 **expr, const u8 *end,
429 struct unwind_state *state)
430 {
431 const u8 *const start = *expr;
432 uleb128_t len = get_uleb128(expr, end);
433 dbug_unwind(1, "reg=%lx, where=%d, expr=%lu@%p\n",
434 reg, where, len, *expr);
435 /* Sanity check that expr falls completely inside known data. */
436 if (end - *expr >= len && reg < ARRAY_SIZE(REG_STATE.regs)) {
437 REG_STATE.regs[reg].where = where;
438 REG_STATE.regs[reg].state.expr = start;
439 *expr += len;
440 }
441 }
442
443 /* Limit the number of instructions we process. Arbitrary limit.
444 512 should be enough for anybody... */
445 #define MAX_CFI 512
446
447 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc,
448 signed ptrType, int user, struct unwind_state *state, int compat_task)
449 {
450 union {
451 const u8 *p8;
452 const u16 *p16;
453 const u32 *p32;
454 } ptr;
455 int result = 1;
456
457 if (end - start > MAX_CFI) {
458 _stp_warn("Too many CFI instuctions\n");
459 return 0;
460 }
461
462 dbug_unwind(1, "targetLoc=%lx state->loc=%lx\n", targetLoc, state->loc);
463 for (ptr.p8 = start; result && ptr.p8 < end;) {
464 switch (*ptr.p8 >> 6) {
465 uleb128_t value;
466 uleb128_t value2;
467 sleb128_t svalue;
468 case 0:
469 switch (*ptr.p8++) {
470 case DW_CFA_nop:
471 dbug_unwind(1, "DW_CFA_nop\n");
472 break;
473 case DW_CFA_set_loc:
474 if ((state->loc = read_pointer(&ptr.p8, end, ptrType, user, compat_task)) == 0)
475 result = 0;
476 dbug_unwind(1, "DW_CFA_set_loc %lx (result=%d)\n", state->loc, result);
477 break;
478 case DW_CFA_advance_loc1:
479 result = ptr.p8 < end && advance_loc(*ptr.p8++, state);
480 dbug_unwind(1, "DW_CFA_advance_loc1 (result=%d)\n", result);
481 break;
482 case DW_CFA_advance_loc2:
483 result = ptr.p8 <= end + 2 && advance_loc(*ptr.p16++, state);
484 dbug_unwind(1, "DW_CFA_advance_loc2 (result=%d)\n", result);
485 break;
486 case DW_CFA_advance_loc4:
487 result = ptr.p8 <= end + 4 && advance_loc(*ptr.p32++, state);
488 dbug_unwind(1, "DW_CFA_advance_loc4 (result=%d)\n", result);
489 break;
490 case DW_CFA_offset_extended:
491 value = get_uleb128(&ptr.p8, end);
492 value2 = get_uleb128(&ptr.p8, end);
493 if (compat_task) {
494 dbug_unwind(1, "map DW_CFA_offset_extended value %ld to reg_info idx %ld, with offset %ld\n",
495 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)), value2);
496 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
497 } else {
498 dbug_unwind(1, "map DW_CFA_offset_extended value %ld to reg_info idx %ld, with offset %ld\n",
499 value, DWARF_REG_MAP(value), value2);
500 value = DWARF_REG_MAP(value);
501 }
502 set_offset_rule(value, Memory,
503 value2 * state->dataAlign,
504 state);
505 break;
506 case DW_CFA_val_offset:
507 value = get_uleb128(&ptr.p8, end);
508 value2 = get_uleb128(&ptr.p8, end);
509 if (compat_task) {
510 dbug_unwind(1, "map DW_CFA_val_offset value %ld to reg_info idx %ld\n, with offset: %ld",
511 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)), value2);
512 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
513 } else {
514 dbug_unwind(1, "map DW_CFA_val_offset value %ld to reg_info idx %ld\n, with offset: %ld",
515 value, DWARF_REG_MAP(value), value2);
516 value = DWARF_REG_MAP(value);
517 }
518 set_offset_rule(value, Value,
519 value2 * state->dataAlign,
520 state);
521 break;
522 case DW_CFA_offset_extended_sf:
523 value = get_uleb128(&ptr.p8, end);
524 svalue = get_sleb128(&ptr.p8, end);
525 if (compat_task) {
526 dbug_unwind(1, "map DW_CFA_offset_extended_sf value %ld to reg_info idx %ld, with offset: %ld\n",
527 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)), svalue);
528 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
529 } else {
530 dbug_unwind(1, "map DW_CFA_offset_extended_sf value %ld to reg_info idx %ld, with offset: %ld\n",
531 value, DWARF_REG_MAP(value), svalue);
532 value = DWARF_REG_MAP(value);
533 }
534 set_offset_rule(value, Memory,
535 svalue * state->dataAlign,
536 state);
537 break;
538 case DW_CFA_val_offset_sf:
539 value = get_uleb128(&ptr.p8, end);
540 svalue = get_sleb128(&ptr.p8, end);
541 if (compat_task) {
542 dbug_unwind(1, "map DW_CFA_val_offset_sf value %ld to reg_info idx %ld\n",
543 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
544 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
545 } else {
546 dbug_unwind(1, "map DW_CFA_val_offset_sf value %ld to reg_info idx %ld\n",
547 value, DWARF_REG_MAP(value));
548 value = DWARF_REG_MAP(value);
549 }
550 set_offset_rule(value, Value,
551 svalue * state->dataAlign,
552 state);
553 break;
554 case DW_CFA_same_value:
555 value = get_uleb128(&ptr.p8, end);
556 if (compat_task) {
557 dbug_unwind(1, "map DW_CFA_same_value value %ld to reg_info idx %ld\n",
558 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
559 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
560 } else {
561 dbug_unwind(1, "map DW_CFA_same_value value %ld to reg_info idx %ld\n",
562 value, DWARF_REG_MAP(value));
563 value = DWARF_REG_MAP(value);
564 }
565 set_no_state_rule(value, Same, state);
566 break;
567 case DW_CFA_restore_extended:
568 value = get_uleb128(&ptr.p8, end);
569 if (compat_task) {
570 dbug_unwind(1, "map DW_CFA_restore_extended value %ld to reg_info idx %ld\n",
571 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
572 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
573 } else {
574 dbug_unwind(1, "map DW_CFA_restore_extended value %ld to reg_info idx %ld\n",
575 value, DWARF_REG_MAP(value));
576 value = DWARF_REG_MAP(value);
577 }
578 memcpy(&REG_STATE.regs[value], &state->cie_regs[value], sizeof(struct unwind_item));
579 break;
580 case DW_CFA_undefined:
581 value = get_uleb128(&ptr.p8, end);
582 if (compat_task) {
583 dbug_unwind(1, "map DW_CFA_undefined value %ld to reg_info idx %ld\n",
584 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
585 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
586 } else {
587 dbug_unwind(1, "map DW_CFA_undefined value %ld to reg_info idx %ld\n",
588 value, DWARF_REG_MAP(value));
589 value = DWARF_REG_MAP(value);
590 }
591 set_no_state_rule(value, Nowhere, state);
592 break;
593 case DW_CFA_register: {
594 uleb128_t reg_value;
595 value = get_uleb128(&ptr.p8, end);
596 reg_value = get_uleb128(&ptr.p8, end);
597 if (compat_task) {
598 dbug_unwind(1, "map DW_CFA_register value %ld to reg_info idx %ld (reg_value %ld to reg_info idx %ld)\n",
599 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)), reg_value, COMPAT_REG_MAP(DWARF_REG_MAP(reg_value)));
600 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
601 reg_value = DWARF_REG_MAP(reg_value);
602 } else {
603 dbug_unwind(1, "map DW_CFA_register value %ld to reg_info idx %ld (reg_value %ld to reg_info idx %ld)\n",
604 value, DWARF_REG_MAP(value), reg_value, DWARF_REG_MAP(reg_value));
605 value = DWARF_REG_MAP(value);
606 reg_value = DWARF_REG_MAP(reg_value);
607 }
608 set_register_rule(value, reg_value, state);
609 break;
610 }
611 case DW_CFA_expression:
612 value = get_uleb128(&ptr.p8, end);
613 if (compat_task) {
614 dbug_unwind(1, "map DW_CFA_expression value %ld to reg_info idx %ld\n",
615 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
616 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
617 } else {
618 dbug_unwind(1, "map DW_CFA_expression value %ld to reg_info idx %ld\n",
619 value, DWARF_REG_MAP(value));
620 value = DWARF_REG_MAP(value);
621 }
622 set_expr_rule(value, Expr, &ptr.p8, end, state);
623 break;
624 case DW_CFA_val_expression:
625 value = get_uleb128(&ptr.p8, end);
626 if (compat_task) {
627 dbug_unwind(1, "map DW_CFA_val_expression value %ld to reg_info idx %ld\n",
628 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
629 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
630 } else {
631 dbug_unwind(1, "map DW_CFA_val_expression value %ld to reg_info idx %ld\n",
632 value, DWARF_REG_MAP(value));
633 value = DWARF_REG_MAP(value);
634 }
635 set_expr_rule(value, ValExpr, &ptr.p8, end,
636 state);
637 break;
638 case DW_CFA_remember_state:
639 state->stackDepth++;
640 if (state->stackDepth >= STP_MAX_STACK_DEPTH) {
641 _stp_warn("Too many stacked DW_CFA_remember_state\n");
642 return 0;
643 }
644 memcpy(&REG_STATE,
645 &state->reg[state->stackDepth - 1],
646 sizeof (REG_STATE));
647 dbug_unwind(1, "DW_CFA_remember_state (stackDepth=%d)\n", state->stackDepth);
648 break;
649 case DW_CFA_restore_state:
650 if (state->stackDepth == 0) {
651 _stp_warn("Unbalanced DW_CFA_restore_state\n");
652 return 0;
653 }
654 state->stackDepth--;
655 dbug_unwind(1, "DW_CFA_restore_state (stackDepth=%d)\n", state->stackDepth);
656 break;
657 case DW_CFA_def_cfa:
658 value = get_uleb128(&ptr.p8, end);
659 REG_STATE.cfa_is_expr = 0;
660 if (compat_task) {
661 dbug_unwind(1, "map DW_CFA_def_cfa value %ld to reg_info idx %ld\n",
662 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
663 REG_STATE.cfa.reg = COMPAT_REG_MAP(value);
664 dbug_unwind(1, "DW_CFA_def_cfa reg=%ld\n", COMPAT_REG_MAP(REG_STATE.cfa.reg));
665 } else {
666 dbug_unwind(1, "map DW_CFA_def_cfa value %ld to reg_info idx %ld\n",
667 value, DWARF_REG_MAP(value));
668 REG_STATE.cfa.reg = value;
669 dbug_unwind(1, "DW_CFA_def_cfa reg=%ld\n", REG_STATE.cfa.reg);
670 }
671 /*nobreak */
672 case DW_CFA_def_cfa_offset:
673 if (REG_STATE.cfa_is_expr != 0) {
674 _stp_warn("Unexpected DW_CFA_def_cfa_offset\n");
675 } else {
676 /* non-factored uleb128 */
677 REG_STATE.cfa.off = get_uleb128(&ptr.p8, end);
678 dbug_unwind(1, "DW_CFA_def_cfa_offset offs=%lx\n", REG_STATE.cfa.off);
679 }
680 break;
681 case DW_CFA_def_cfa_sf:
682 value = get_uleb128(&ptr.p8, end);
683 REG_STATE.cfa_is_expr = 0;
684 if (compat_task) {
685 dbug_unwind(1, "map DW_CFA_def_cfa_sf value %ld to reg_info idx %ld\n",
686 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
687 REG_STATE.cfa.reg = COMPAT_REG_MAP(value);
688 } else {
689 dbug_unwind(1, "map DW_CFA_def_cfa_sf value %ld to reg_info idx %ld\n",
690 value, DWARF_REG_MAP(value));
691 REG_STATE.cfa.reg = value;
692 }
693 /*nobreak */
694 case DW_CFA_def_cfa_offset_sf:
695 if (REG_STATE.cfa_is_expr != 0) {
696 _stp_warn("Unexpected DW_CFA_def_cfa_offset_sf\n");
697 } else {
698 /* factored sleb128 */
699 REG_STATE.cfa.off = get_sleb128(&ptr.p8, end) * state->dataAlign;
700 dbug_unwind(1, "DW_CFA_def_cfa_offset_sf offs=%lx\n", REG_STATE.cfa.off);
701 }
702 break;
703 case DW_CFA_def_cfa_register:
704 if (REG_STATE.cfa_is_expr != 0) {
705 _stp_warn("Unexpected DW_CFA_def_cfa_register\n");
706 } else {
707 value = get_uleb128(&ptr.p8, end);
708 if (compat_task) {
709 dbug_unwind(1, "map DW_CFA_def_cfa_register value %ld to reg_info idx %ld (%ld)\n",
710 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)), DWARF_REG_MAP(value));
711 REG_STATE.cfa.reg = COMPAT_REG_MAP(value);
712 } else {
713 dbug_unwind(1, "map DW_CFA_def_cfa_register value %ld to reg_info idx %ld (%ld)\n",
714 value, DWARF_REG_MAP(value), DWARF_REG_MAP(value));
715 REG_STATE.cfa.reg = value;
716 }
717 }
718 break;
719 case DW_CFA_def_cfa_expression: {
720 const u8 *cfa_expr = ptr.p8;
721 value = get_uleb128(&ptr.p8, end);
722 /* Sanity check that cfa_expr falls completely
723 inside known data. */
724 if (ptr.p8 < end && end - ptr.p8 >= value) {
725 REG_STATE.cfa_is_expr = 1;
726 REG_STATE.cfa_expr = cfa_expr;
727 ptr.p8 += value;
728 dbug_unwind(1, "DW_CFA_def_cfa_expression %lu@%p\n", value, cfa_expr);
729 }
730 else
731 _stp_warn("BAD DW_CFA_def_cfa_expression value %lu\n", value);
732 break;
733 }
734 /* Size of all arguments pushed on the stack. */
735 case DW_CFA_GNU_args_size:
736 get_uleb128(&ptr.p8, end);
737 dbug_unwind(1, "DW_CFA_GNU_args_size\n");
738 break;
739 /* This is only produced by GCC before 2002.
740 Like DW_CFA_offset_extended_sf but using an
741 uleb128 that is subtracted from CFA. */
742 case DW_CFA_GNU_negative_offset_extended:
743 value = get_uleb128(&ptr.p8, end);
744 if (compat_task) {
745 dbug_unwind(1, "map DW_CFA_GNU_negative_offset_extended value %ld to reg_info idx %ld\n",
746 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
747 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
748 } else {
749 dbug_unwind(1, "map DW_CFA_GNU_negative_offset_extended value %ld to reg_info idx %ld\n",
750 value, DWARF_REG_MAP(value));
751 value = DWARF_REG_MAP(value);
752 }
753 set_offset_rule(value, Memory,
754 (uleb128_t)0 - get_uleb128(&ptr.p8, end), state);
755 break;
756 case DW_CFA_GNU_window_save:
757 default:
758 _stp_warn("unimplemented call frame instruction: 0x%x\n", *(ptr.p8 - 1));
759 result = 0;
760 break;
761 }
762 break;
763 case 1:
764 result = advance_loc(*ptr.p8++ & 0x3f, state);
765 dbug_unwind(1, "DW_CFA_advance_loc\n");
766 break;
767 case 2:
768 value = *ptr.p8++ & 0x3f;
769 if (compat_task) {
770 dbug_unwind(1, "map DW_CFA_offset value %ld to reg_info idx %ld\n",
771 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
772 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
773 } else {
774 dbug_unwind(1, "map DW_CFA_offset value %ld to reg_info idx %ld\n",
775 value, DWARF_REG_MAP(value));
776 value = DWARF_REG_MAP(value);
777 }
778 value2 = get_uleb128(&ptr.p8, end);
779 set_offset_rule(value, Memory,
780 value2 * state->dataAlign, state);
781 break;
782 case 3:
783 value = *ptr.p8++ & 0x3f;
784 if (compat_task) {
785 dbug_unwind(1, "map DW_CFA_restore value %ld to reg_info idx %ld\n",
786 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
787 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
788 } else {
789 dbug_unwind(1, "map DW_CFA_restore value %ld to reg_info idx %ld\n",
790 value, DWARF_REG_MAP(value));
791 value = DWARF_REG_MAP(value);
792 }
793 memcpy(&REG_STATE.regs[value], &state->cie_regs[value], sizeof(struct unwind_item));
794 break;
795 }
796 dbug_unwind(1, "targetLoc=%lx state->loc=%lx\n", targetLoc, state->loc);
797 dbug_unwind(1, "result: %d\n", result);
798 if (ptr.p8 > end)
799 result = 0;
800 if (result && targetLoc != 0 && targetLoc < state->loc)
801 return 1;
802 }
803 return result && ptr.p8 == end;
804 }
805
806 #ifdef DEBUG_UNWIND
807 static const char *_stp_enc_hi_name[] = {
808 "DW_EH_PE",
809 "DW_EH_PE_pcrel",
810 "DW_EH_PE_textrel",
811 "DW_EH_PE_datarel",
812 "DW_EH_PE_funcrel",
813 "DW_EH_PE_aligned"
814 };
815 static const char *_stp_enc_lo_name[] = {
816 "_absptr",
817 "_uleb128",
818 "_udata2",
819 "_udata4",
820 "_udata8",
821 "_sleb128",
822 "_sdata2",
823 "_sdata4",
824 "_sdata8"
825 };
826 static char *_stp_eh_enc_name(signed type)
827 {
828 static char buf[64];
829 int hi, low;
830 if (type == DW_EH_PE_omit)
831 return "DW_EH_PE_omit";
832
833 hi = (type & DW_EH_PE_ADJUST) >> 4;
834 low = type & DW_EH_PE_FORM;
835 if (hi > 5 || low > 4 || (low == 0 && (type & DW_EH_PE_signed))) {
836 snprintf(buf, sizeof(buf), "ERROR:encoding=0x%x", type);
837 return buf;
838 }
839
840 buf[0] = 0;
841 if (type & DW_EH_PE_indirect)
842 strlcpy(buf, "DW_EH_PE_indirect|", sizeof(buf));
843 strlcat(buf, _stp_enc_hi_name[hi], sizeof(buf));
844
845 if (type & DW_EH_PE_signed)
846 low += 4;
847 strlcat(buf, _stp_enc_lo_name[low], sizeof(buf));
848 return buf;
849 }
850 #endif /* DEBUG_UNWIND */
851
852 // If this is an address inside a module, adjust for section relocation
853 // and the elfutils base relocation done during loading of the .dwarf_frame
854 // in translate.cxx.
855 static unsigned long
856 adjustStartLoc (unsigned long startLoc,
857 struct _stp_module *m,
858 struct _stp_section *s,
859 unsigned ptrType, int is_ehframe, int user)
860 {
861 unsigned long vm_addr = 0;
862
863 /* If we're unwinding the current module, then the addresses
864 we've got don't require adjustment, they didn't come from user
865 space */
866 if(strcmp(THIS_MODULE->name,m->name)==0)
867 return startLoc;
868
869 /* XXX - some, or all, of this should really be done by
870 _stp_module_relocate and/or read_pointer. */
871 dbug_unwind(2, "adjustStartLoc=%lx, ptrType=%s, m=%s, s=%s eh=%d\n",
872 startLoc, _stp_eh_enc_name(ptrType), m->path, s->name, is_ehframe);
873 if (startLoc == 0
874 || strcmp (m->name, "kernel") == 0
875 || (strcmp (s->name, ".absolute") == 0 && !is_ehframe))
876 return startLoc;
877
878 /* eh_frame data has been loaded in the kernel, so readjust offset. */
879 if (is_ehframe) {
880 dbug_unwind(2, "eh_frame=%lx, eh_frame_addr=%lx\n", (unsigned long) m->eh_frame, m->eh_frame_addr);
881 if ((ptrType & DW_EH_PE_ADJUST) == DW_EH_PE_pcrel) {
882 startLoc -= (unsigned long) m->eh_frame;
883 startLoc += m->eh_frame_addr;
884 }
885 /* User space exec */
886 if (strcmp (s->name, ".absolute") == 0)
887 return startLoc;
888 }
889
890 /* User space or kernel dynamic module. */
891 if (user && strcmp (s->name, ".dynamic") == 0)
892 stap_find_vma_map_info_user(current->group_leader, m, &vm_addr, NULL, NULL);
893 else
894 vm_addr = s->static_addr;
895
896 if (is_ehframe)
897 return startLoc + vm_addr;
898 else
899 return startLoc + vm_addr - s->sec_load_offset;
900
901 }
902
903 /* If we previously created an unwind header, then use it now to binary search */
904 /* for the FDE corresponding to pc. */
905 static u32 *_stp_search_unwind_hdr(unsigned long pc,
906 struct _stp_module *m,
907 struct _stp_section *s,
908 int is_ehframe, int user, int compat_task)
909 {
910 const u8 *ptr, *end, *hdr = is_ehframe ? m->unwind_hdr: s->debug_hdr;
911 uint32_t hdr_len = is_ehframe ? m->unwind_hdr_len : s->debug_hdr_len;
912 unsigned long startLoc;
913 u32 *fde = NULL;
914 unsigned num, tableSize, t2;
915 unsigned long eh_hdr_addr = m->unwind_hdr_addr;
916
917 if (hdr == NULL || hdr_len < 4 || hdr[0] != 1) {
918 _stp_warn("no or bad debug frame hdr\n");
919 return NULL;
920 }
921
922 dbug_unwind(1, "binary search for %lx", pc);
923
924 /* table_enc */
925 switch (hdr[3] & DW_EH_PE_FORM) {
926 case DW_EH_PE_absptr:
927 if (!compat_task)
928 tableSize = sizeof(unsigned long);
929 else
930 tableSize = sizeof(unsigned int);
931 break;
932 case DW_EH_PE_data2:
933 tableSize = 2;
934 break;
935 case DW_EH_PE_data4:
936 tableSize = 4;
937 break;
938 case DW_EH_PE_data8:
939 tableSize = 8;
940 break;
941 default:
942 _stp_warn("bad unwind table encoding");
943 return NULL;
944 }
945 ptr = hdr + 4;
946 end = hdr + hdr_len;
947 {
948 // XXX Can the header validity be checked just once?
949 unsigned long eh = read_ptr_sect(&ptr, end, hdr[1], 0,
950 eh_hdr_addr, user, compat_task, tableSize);
951 if ((hdr[1] & DW_EH_PE_ADJUST) == DW_EH_PE_pcrel)
952 eh = eh - (unsigned long)hdr + eh_hdr_addr;
953 if ((is_ehframe && eh != (unsigned long)m->eh_frame_addr)) {
954 _stp_warn("eh_frame_ptr in eh_frame_hdr 0x%lx not valid; eh_frame_addr = 0x%lx", eh, (unsigned long)m->eh_frame_addr);
955 return NULL;
956 }
957 }
958 num = read_ptr_sect(&ptr, end, hdr[2], 0, eh_hdr_addr, user, compat_task, tableSize);
959 if (num == 0 || num != (end - ptr) / (2 * tableSize)
960 || (end - ptr) % (2 * tableSize)) {
961 _stp_warn("unwind Bad num=%d end-ptr=%ld 2*tableSize=%d",
962 num, (long)(end - ptr), 2 * tableSize);
963 return NULL;
964 }
965
966 do {
967 const u8 *cur = ptr + (num / 2) * (2 * tableSize);
968 startLoc = read_ptr_sect(&cur, cur + tableSize, hdr[3], 0,
969 eh_hdr_addr, user, compat_task, tableSize);
970 startLoc = adjustStartLoc(startLoc, m, s, hdr[3],
971 is_ehframe, user);
972 if (pc < startLoc)
973 num /= 2;
974 else {
975 ptr = cur - tableSize;
976 num = (num + 1) / 2;
977 }
978 } while (startLoc && num > 1);
979
980 if (num == 1
981 && (startLoc = adjustStartLoc(read_ptr_sect(&ptr, ptr + tableSize, hdr[3], 0,
982 eh_hdr_addr, user, compat_task, tableSize),
983 m, s, hdr[3], is_ehframe, user)) != 0 && pc >= startLoc) {
984 unsigned long off;
985 off = read_ptr_sect(&ptr, ptr + tableSize, hdr[3],
986 0, eh_hdr_addr, user, compat_task, tableSize);
987 dbug_unwind(1, "fde off=%lx\n", off);
988 /* For real eh_frame_hdr the actual fde address is at the
989 new eh_frame load address. For our own debug_hdr created
990 table the fde is an offset into the debug_frame table. */
991 if (is_ehframe)
992 fde = off - m->eh_frame_addr + m->eh_frame;
993 else
994 fde = m->debug_frame + off;
995 }
996
997 dbug_unwind(1, "returning fde=%lx startLoc=%lx", (unsigned long) fde, startLoc);
998 return fde;
999 }
1000
1001 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
1002
1003 #ifndef CONFIG_64BIT
1004 # define CASES CASE(8); CASE(16); CASE(32)
1005 #else
1006 # define CASES CASE(8); CASE(16); CASE(32); CASE(64)
1007 #endif
1008
1009 #define MAX_EXPR_STACK 8 /* arbitrary */
1010
1011 static int compute_expr(const u8 *expr, struct unwind_frame_info *frame,
1012 unsigned long *result, int user, int compat_task)
1013 {
1014 /*
1015 * We previously validated the length, so we won't read off the end.
1016 * See sanity checks in set_expr() and for DW_CFA_def_cfa_expression.
1017 */
1018 uleb128_t len = get_uleb128(&expr, (const u8 *) -1UL);
1019 const u8 *const start = expr;
1020 const u8 *const end = expr + len;
1021
1022 long stack[MAX_EXPR_STACK]; /* stack slots are signed */
1023 unsigned int sp = 0;
1024 #define PUSH(val) do { \
1025 if (sp == MAX_EXPR_STACK) \
1026 goto overflow; \
1027 stack[sp++] = (val); \
1028 } while (0)
1029 #define POP ({ \
1030 if (sp == 0) \
1031 goto underflow; \
1032 stack[--sp]; \
1033 })
1034 #define NEED(n) do { \
1035 if (end - expr < (n)) \
1036 goto truncated; \
1037 } while (0)
1038
1039 while (expr < end) {
1040 uleb128_t value;
1041 union {
1042 u8 u8;
1043 s8 s8;
1044 u16 u16;
1045 s16 s16;
1046 u32 u32;
1047 s32 s32;
1048 u64 u64;
1049 s64 s64;
1050 } u;
1051 const u8 op = *expr++;
1052 dbug_unwind(3, " expr op 0x%x (%ld left)\n", op, (long)(end - expr));
1053 switch (op) {
1054 case DW_OP_nop:
1055 break;
1056
1057 case DW_OP_bra:
1058 if (POP == 0)
1059 break;
1060 /* Fall through. */
1061 case DW_OP_skip:
1062 NEED(sizeof(u.s16));
1063 memcpy(&u.s16, expr, sizeof(u.s16));
1064 expr += sizeof(u.s16);
1065 if (u.s16 < 0 ?
1066 unlikely(expr - start < -u.s16) :
1067 unlikely(end - expr < u.s16)) {
1068 _stp_warn("invalid skip %d in CFI expression\n", (int) u.s16);
1069 return 1;
1070 }
1071 /*
1072 * A backward branch could lead to an infinite loop.
1073 * So punt it until we find we actually need it.
1074 */
1075 if (u.s16 < 0) {
1076 _stp_warn("backward branch in CFI expression not supported\n");
1077 return 1;
1078 }
1079 expr += u.s16;
1080 break;
1081
1082 case DW_OP_dup:
1083 value = POP;
1084 PUSH(value);
1085 PUSH(value);
1086 break;
1087 case DW_OP_drop:
1088 POP;
1089 break;
1090 case DW_OP_swap: {
1091 unsigned long tos = POP;
1092 unsigned long nos = POP;
1093 PUSH(tos);
1094 PUSH(nos);
1095 break;
1096 };
1097
1098 case DW_OP_over:
1099 value = 1;
1100 goto pick;
1101 case DW_OP_pick:
1102 NEED(1);
1103 value = *expr++;
1104 pick:
1105 if (value >= sp)
1106 goto underflow;
1107 value = stack[sp - value];
1108 PUSH(value);
1109 break;
1110
1111 #define CONSTANT(type) \
1112 NEED(sizeof(u.type)); \
1113 memcpy(&u.type, expr, sizeof(u.type)); \
1114 expr += sizeof(u.type); \
1115 value = u.type; \
1116 PUSH(value); \
1117 break
1118
1119 case DW_OP_addr:
1120 if (sizeof(unsigned long) == 8) { /* XXX 32/64!! */
1121 CONSTANT(u64);
1122 } else {
1123 CONSTANT(u32);
1124 }
1125 break;
1126
1127 case DW_OP_const1u: CONSTANT(u8);
1128 case DW_OP_const1s: CONSTANT(s8);
1129 case DW_OP_const2u: CONSTANT(u16);
1130 case DW_OP_const2s: CONSTANT(s16);
1131 case DW_OP_const4u: CONSTANT(u32);
1132 case DW_OP_const4s: CONSTANT(s32);
1133 case DW_OP_const8u: CONSTANT(u64);
1134 case DW_OP_const8s: CONSTANT(s64);
1135
1136 #undef CONSTANT
1137
1138 case DW_OP_constu:
1139 value = get_uleb128(&expr, end);
1140 PUSH(value);
1141 break;
1142 case DW_OP_consts:
1143 value = get_sleb128(&expr, end);
1144 PUSH(value);
1145 break;
1146
1147 case DW_OP_lit0 ... DW_OP_lit31:
1148 PUSH(op - DW_OP_lit0);
1149 break;
1150
1151 case DW_OP_plus_uconst:
1152 value = get_uleb128(&expr, end);
1153 PUSH(value + POP);
1154 break;
1155
1156 #define BINOP(name, operator) \
1157 case DW_OP_##name: { \
1158 long b = POP; \
1159 long a = POP; \
1160 PUSH(a operator b); \
1161 } break
1162
1163 BINOP(eq, ==);
1164 BINOP(ne, !=);
1165 BINOP(ge, >=);
1166 BINOP(gt, >);
1167 BINOP(le, <=);
1168 BINOP(lt, <);
1169
1170 BINOP(and, &);
1171 BINOP(or, |);
1172 BINOP(xor, ^);
1173 BINOP(plus, +);
1174 BINOP(minus, -);
1175 BINOP(mul, *);
1176 BINOP(shl, <<);
1177 BINOP(shra, >>);
1178 #undef BINOP
1179
1180 case DW_OP_mod: {
1181 unsigned long b = POP;
1182 unsigned long a = POP;
1183 if (b == 0)
1184 goto divzero;
1185 PUSH (a % b);
1186 }
1187
1188 case DW_OP_div: {
1189 long b = POP;
1190 long a = POP;
1191 if (b == 0)
1192 goto divzero;
1193 PUSH (a / b);
1194 }
1195
1196 case DW_OP_shr: {
1197 unsigned long b = POP;
1198 unsigned long a = POP;
1199 PUSH (a >> b);
1200 }
1201
1202 case DW_OP_not:
1203 PUSH(~ POP);
1204 break;
1205 case DW_OP_neg:
1206 PUSH(- POP);
1207 break;
1208 case DW_OP_abs:
1209 value = POP;
1210 value = abs(value);
1211 PUSH(value);
1212 break;
1213
1214 case DW_OP_bregx:
1215 value = get_uleb128(&expr, end);
1216 goto breg;
1217 case DW_OP_breg0 ... DW_OP_breg31:
1218 value = op - DW_OP_breg0;
1219 breg:
1220 if (compat_task) {
1221 dbug_unwind(1, "map DW_OP_breg value %ld to reg_info idx %ld\n",
1222 value, COMPAT_REG_MAP(DWARF_REG_MAP(value)));
1223 value = COMPAT_REG_MAP(DWARF_REG_MAP(value));
1224 } else {
1225 dbug_unwind(1, "map DW_OP_breg value %ld to reg_info idx %ld\n",
1226 value, DWARF_REG_MAP(value));
1227 value = DWARF_REG_MAP(value);
1228 }
1229 if (unlikely(value >= ARRAY_SIZE(reg_info))) {
1230 _stp_warn("invalid register number %lu in CFI expression\n", value);
1231 return 1;
1232 } else {
1233 sleb128_t offset = get_sleb128(&expr, end);
1234 value = FRAME_REG(value, unsigned long);
1235 PUSH(value + offset);
1236 }
1237 break;
1238
1239 case DW_OP_deref:
1240 value = sizeof(long); /* XXX 32/64!! */
1241 goto deref;
1242 case DW_OP_deref_size:
1243 NEED(1);
1244 value = *expr++;
1245 if (unlikely(value > sizeof(stack[0]))) {
1246 bad_deref_size:
1247 _stp_warn("invalid DW_OP_deref_size %lu in CFI expression\n", value);
1248 return 1;
1249 }
1250 deref: {
1251 unsigned long addr = POP;
1252 switch (value) {
1253 #define CASE(n) case sizeof(u##n): \
1254 if (unlikely(_stp_read_address(value, (u##n *)addr, \
1255 (user ? USER_DS : KERNEL_DS)))) \
1256 goto copy_failed; \
1257 break
1258 CASES;
1259 #undef CASE
1260 default:
1261 goto bad_deref_size;
1262 }
1263 }
1264 break;
1265
1266 case DW_OP_rot:
1267 default:
1268 _stp_warn("unimplemented CFI expression operation: 0x%x\n", op);
1269 return 1;
1270 }
1271 }
1272
1273 *result = POP;
1274 return 0;
1275
1276 copy_failed:
1277 _stp_warn("_stp_read_address failed to access memory for deref\n");
1278 return 1;
1279 truncated:
1280 _stp_warn("invalid (truncated) DWARF expression in CFI\n");
1281 return 1;
1282 overflow:
1283 _stp_warn("DWARF expression stack overflow in CFI\n");
1284 return 1;
1285 underflow:
1286 _stp_warn("DWARF expression stack underflow in CFI\n");
1287 return 1;
1288 divzero:
1289 _stp_warn("DWARF expression stack divide by zero in CFI\n");
1290 return 1;
1291
1292 #undef NEED
1293 #undef PUSH
1294 #undef POP
1295 }
1296
1297 /* Unwind to previous to frame. Returns 0 if successful, negative
1298 * number in case of an error. A positive return means unwinding is finished;
1299 * don't try to fallback to dumping addresses on the stack. */
1300 static int unwind_frame(struct unwind_context *context,
1301 struct _stp_module *m, struct _stp_section *s,
1302 void *table, uint32_t table_len, int is_ehframe,
1303 int user, int compat_task)
1304 {
1305 const u32 *fde = NULL, *cie = NULL;
1306 /* The start and end of the CIE CFI instructions. */
1307 const u8 *cieStart = NULL, *cieEnd = NULL;
1308 /* The start and end of the FDE CFI instructions. */
1309 const u8 *fdeStart = NULL, *fdeEnd = NULL;
1310 struct unwind_frame_info *frame = &context->info;
1311 unsigned long pc = UNW_PC(frame) - frame->call_frame;
1312 unsigned long startLoc = 0, endLoc = 0, locRange = 0, cfa;
1313 unsigned i;
1314 signed ptrType = -1, call_frame = 1;
1315 uleb128_t retAddrReg = 0;
1316 struct unwind_state *state = &context->state;
1317 unsigned long addr;
1318
1319 if (unlikely(table_len == 0)) {
1320 // Don't _stp_warn about this, debug_frame and/or eh_frame
1321 // might actually not be there.
1322 dbug_unwind(1, "Module %s: no unwind frame data", m->path);
1323 goto err;
1324 }
1325 if (unlikely(table_len & (sizeof(*fde) - 1))) {
1326 _stp_warn("Module %s: frame_len=%d", m->path, table_len);
1327 goto err;
1328 }
1329
1330 /* Sets all rules to default Same value. */
1331 memset(state, 0, sizeof(*state));
1332
1333 /* All "fake" dwarf registers should start out Nowhere. */
1334 for (i = UNW_NR_REAL_REGS; i < ARRAY_SIZE(REG_STATE.regs); ++i)
1335 set_no_state_rule(i, Nowhere, state);
1336
1337 fde = _stp_search_unwind_hdr(pc, m, s, is_ehframe, user, compat_task);
1338 dbug_unwind(1, "%s: fde=%lx\n", m->path, (unsigned long) fde);
1339
1340 /* found the fde, now set startLoc and endLoc */
1341 if (fde != NULL && is_fde(fde, table, table_len, is_ehframe)) {
1342 cie = cie_for_fde(fde, table, table_len, is_ehframe);
1343 dbug_unwind(1, "%s: cie=%lx\n", m->path, (unsigned long) cie);
1344 if (likely(cie != NULL)) {
1345 if (parse_fde_cie(fde, cie, table, table_len,
1346 &ptrType, user,
1347 &startLoc, &locRange,
1348 &fdeStart, &fdeEnd,
1349 &cieStart, &cieEnd,
1350 &state->codeAlign,
1351 &state->dataAlign,
1352 &retAddrReg,
1353 &call_frame,
1354 compat_task) < 0)
1355 goto err;
1356 startLoc = adjustStartLoc(startLoc, m, s, ptrType, is_ehframe, user);
1357 endLoc = startLoc + locRange;
1358 dbug_unwind(1, "startLoc: %lx, endLoc: %lx\n", startLoc, endLoc);
1359 if (pc > endLoc) {
1360 dbug_unwind(1, "pc (%lx) > endLoc(%lx)\n", pc, endLoc);
1361 goto done;
1362 }
1363 } else {
1364 _stp_warn("fde found in header, but cie is bad!\n");
1365 fde = NULL;
1366 }
1367 } else if ((is_ehframe ? m->unwind_hdr: s->debug_hdr) == NULL) {
1368 /* Only do a linear search if there isn't a search header.
1369 There always should be one, we create it in the translator
1370 if it didn't exist. These should never be missing except
1371 when there are toolchain bugs. */
1372 unsigned long tableSize;
1373 _stp_warn("No binary search table for %s frame, doing slow linear search for %s\n", (is_ehframe ? "eh" : "debug"), m->path);
1374 for (fde = table, tableSize = table_len; cie = NULL, tableSize > sizeof(*fde)
1375 && tableSize - sizeof(*fde) >= *fde; tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
1376 dbug_unwind(3, "fde=%lx tableSize=%d\n", (long)*fde, (int)tableSize);
1377 if (!is_fde(fde, table, table_len, is_ehframe))
1378 continue;
1379 cie = cie_for_fde(fde, table, table_len, is_ehframe);
1380 if (cie == NULL
1381 || parse_fde_cie(fde, cie, table, table_len,
1382 &ptrType, user,
1383 &startLoc, &locRange,
1384 &fdeStart, &fdeEnd,
1385 &cieStart, &cieEnd,
1386 &state->codeAlign,
1387 &state->dataAlign,
1388 &retAddrReg,
1389 &call_frame, compat_task) < 0)
1390 break;
1391 startLoc = adjustStartLoc(startLoc, m, s, ptrType, is_ehframe, user);
1392 if (!startLoc)
1393 continue;
1394 endLoc = startLoc + locRange;
1395 // removal because this is a way of checking if the next fde is in range, if the fde's aren't sorted (which is why we're doing a linear search in the first place, than this check is bogus
1396 /*if (pc > endLoc) {
1397 dbug_unwind(1, "pc (%lx) > endLoc(%lx)\n", pc, endLoc);
1398 goto done;
1399 }*/
1400 dbug_unwind(3, "endLoc=%lx\n", endLoc);
1401 if (pc >= startLoc && pc < endLoc)
1402 break;
1403 }
1404 }
1405
1406 dbug_unwind(1, "cie=%lx fde=%lx startLoc=%lx endLoc=%lx, pc=%lx\n",
1407 (unsigned long) cie, (unsigned long)fde, (unsigned long) startLoc, (unsigned long) endLoc, pc);
1408 if (cie == NULL || fde == NULL)
1409 goto err;
1410
1411 /* found the CIE and FDE */
1412
1413 // Sanity check return address register value.
1414 if (retAddrReg >= ARRAY_SIZE(reg_info)
1415 || REG_INVALID(retAddrReg)
1416 || reg_info[retAddrReg].width != sizeof(unsigned long)) {
1417 _stp_warn("Bad retAddrReg value\n");
1418 goto err;
1419 }
1420
1421 frame->call_frame = call_frame;
1422 state->stackDepth = 0;
1423 state->loc = startLoc;
1424 memcpy(&REG_STATE.cfa, &badCFA, sizeof(REG_STATE.cfa));
1425
1426 /* Common Information Entry (CIE) instructions. */
1427 dbug_unwind (1, "processCFI for CIE\n");
1428 if (!processCFI(cieStart, cieEnd, 0, ptrType, user, state, compat_task))
1429 goto err;
1430
1431 /* Store initial state registers for use with DW_CFA_restore... */
1432 memcpy(&state->cie_regs, &REG_STATE.regs, sizeof (REG_STATE.regs));
1433
1434 /* Process Frame Description Entry (FDE) instructions. */
1435 dbug_unwind (1, "processCFI for FDE\n");
1436 if (!processCFI(fdeStart, fdeEnd, pc, ptrType, user, state, compat_task)
1437 || state->loc > endLoc
1438 || REG_STATE.regs[retAddrReg].where == Nowhere)
1439 goto err;
1440
1441 /* update frame */
1442 if (REG_STATE.cfa_is_expr) {
1443 if (compute_expr(REG_STATE.cfa_expr, frame, &cfa, user, compat_task))
1444 goto err;
1445 }
1446 else {
1447 // We expect the offset to be a multiple of the address size
1448 if(REG_STATE.cfa.reg >= ARRAY_SIZE(reg_info)
1449 || reg_info[REG_STATE.cfa.reg].width != sizeof(unsigned long)
1450 || REG_STATE.cfa.off % (sizeof(unsigned long)/2))
1451 goto err;
1452
1453 dbug_unwind(1, "cfa reg=%ld, off=%lx\n",
1454 REG_STATE.cfa.reg, REG_STATE.cfa.off);
1455 cfa = FRAME_REG(REG_STATE.cfa.reg, unsigned long) + REG_STATE.cfa.off;
1456 }
1457 startLoc = min((unsigned long)UNW_SP(frame), cfa);
1458 endLoc = max((unsigned long)UNW_SP(frame), cfa);
1459 dbug_unwind(1, "cfa=%lx startLoc=%lx, endLoc=%lx\n", cfa, startLoc, endLoc);
1460 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
1461 startLoc = min(STACK_LIMIT(cfa), cfa);
1462 endLoc = max(STACK_LIMIT(cfa), cfa);
1463 dbug_unwind(1, "cfa startLoc=%lx, endLoc=%lx\n",
1464 (unsigned long)startLoc, (unsigned long)endLoc);
1465 }
1466 dbug_unwind(1, "cie=%lx fde=%lx\n", (unsigned long) cie, (unsigned long) fde);
1467 for (i = 0; i < ARRAY_SIZE(REG_STATE.regs); ++i) {
1468 if (REG_INVALID(i)) {
1469 if (REG_STATE.regs[i].where == Nowhere)
1470 continue;
1471 _stp_warn("REG_INVALID %d\n", i);
1472 goto err;
1473 }
1474 dbug_unwind(2, "register %d. where=%d\n", i, REG_STATE.regs[i].where);
1475 switch (REG_STATE.regs[i].where) {
1476 default:
1477 break;
1478 case Register:
1479 if (REG_STATE.regs[i].state.reg >= ARRAY_SIZE(reg_info)
1480 || REG_INVALID(REG_STATE.regs[i].state.reg)
1481 || reg_info[i].width > reg_info[REG_STATE.regs[i].state.reg].width) {
1482 _stp_warn("case Register bad\n");
1483 goto err;
1484 }
1485 switch (reg_info[REG_STATE.regs[i].state.reg].width) {
1486 #define CASE(n) \
1487 case sizeof(u##n): \
1488 REG_STATE.regs[i].state.reg = FRAME_REG(REG_STATE.regs[i].state.reg, \
1489 const u##n); \
1490 break
1491 CASES;
1492 #undef CASE
1493 default:
1494 _stp_warn("bad Register size\n");
1495 goto err;
1496 }
1497 break;
1498 }
1499 }
1500 for (i = 0; i < ARRAY_SIZE(REG_STATE.regs); ++i) {
1501 dbug_unwind(2, "register %d. invalid=%d\n", i, REG_INVALID(i));
1502 if (REG_INVALID(i))
1503 continue;
1504 dbug_unwind(2, "register %d. where=%d\n", i, REG_STATE.regs[i].where);
1505
1506 #if (UNW_SP_FROM_CFA == 1)
1507 if (i == UNW_SP_IDX) {
1508 UNW_SP(frame) = cfa;
1509 continue;
1510 }
1511 #endif
1512
1513 #if (UNW_PC_FROM_RA == 1)
1514 if (i == UNW_PC_IDX) {
1515 UNW_PC(frame) = FRAME_REG(retAddrReg, unsigned long);
1516 continue;
1517 }
1518 #endif
1519
1520 switch (REG_STATE.regs[i].where) {
1521 case Same:
1522 /* Preserve register from current frame. */
1523 break;
1524 case Nowhere:
1525 switch (reg_info[i].width) {
1526 #define CASE(n) case sizeof(u##n): \
1527 FRAME_REG(i, u##n) = 0; \
1528 break
1529 CASES;
1530 #undef CASE
1531 default:
1532 _stp_warn("bad Register size (Nowhere)\n");
1533 goto err;
1534 }
1535 break;
1536 case Register:
1537 switch (reg_info[i].width) {
1538 #define CASE(n) case sizeof(u##n): \
1539 FRAME_REG(i, u##n) = REG_STATE.regs[i].state.reg; \
1540 break
1541 CASES;
1542 #undef CASE
1543 default:
1544 _stp_warn("bad Register size (Register)\n");
1545 goto err;
1546 }
1547 break;
1548 case Expr:
1549 if (compute_expr(REG_STATE.regs[i].state.expr, frame, &addr, user, compat_task))
1550 goto err;
1551 goto memory;
1552 case ValExpr:
1553 if (compute_expr(REG_STATE.regs[i].state.expr, frame, &addr, user, compat_task))
1554 goto err;
1555 goto value;
1556 case Value:
1557 addr = cfa + REG_STATE.regs[i].state.off;
1558 value:
1559 if (reg_info[i].width != sizeof(unsigned long)) {
1560 _stp_warn("bad Register width for value state\n");
1561 goto err;
1562 }
1563 FRAME_REG(i, unsigned long) = addr;
1564 break;
1565 case Memory:
1566 addr = cfa + REG_STATE.regs[i].state.off;
1567 memory:
1568 dbug_unwind(2, "addr=%lx width=%d\n", addr, reg_info[i].width);
1569 /* We only want the lower half of the address defined, however
1570 _stp_read_address will sometimes return garbage in the top half.
1571 for 32-on-64 bit unwinding we need to ensure this is 0xFFFFFFFF */
1572 switch (reg_info[i].width) {
1573 #define CASE(n) case sizeof(u##n): \
1574 if (unlikely(_stp_read_address(FRAME_REG(i, u##n), (u##n *)addr, \
1575 (user ? USER_DS : KERNEL_DS)))) \
1576 goto copy_failed; \
1577 if (compat_task) FRAME_REG(i, u##n) &= 0xFFFFFFFF; \
1578 dbug_unwind(1, "set register %d to %lx\n", i, (long)FRAME_REG(i,u##n)); \
1579 break
1580 CASES;
1581 #undef CASE
1582 default:
1583 _stp_warn("bad Register width\n");
1584 goto err;
1585 }
1586 break;
1587 }
1588 }
1589 dbug_unwind(1, "returning 0 (%lx)\n", UNW_PC(frame));
1590 return 0;
1591
1592 copy_failed:
1593 _stp_warn("_stp_read_address failed to access memory location\n");
1594 err:
1595 return -EIO;
1596
1597 done:
1598 /* PC was in a range convered by a module but no unwind info */
1599 /* found for the specific PC. This seems to happen only for kretprobe */
1600 /* trampolines and at the end of interrupt backtraces. */
1601 return 1;
1602 #undef CASES
1603 #undef FRAME_REG
1604 }
1605
1606 static int unwind(struct unwind_context *context, int user)
1607 {
1608 struct _stp_module *m;
1609 struct _stp_section *s = NULL;
1610 struct unwind_frame_info *frame = &context->info;
1611 unsigned long pc = UNW_PC(frame) - frame->call_frame;
1612 int res;
1613 const char *module_name = 0;
1614 /* compat_task is a flag for 32bit process unwinding on a 64-bit
1615 architecture. If this flag is set, it means a mapping of
1616 register numbers is required, as well as being aware of 32-bit
1617 values on 64-bit registers. */
1618 int compat_task = _stp_is_compat_task();
1619
1620 dbug_unwind(1, "pc=%lx, %lx", pc, UNW_PC(frame));
1621
1622 if (UNW_PC(frame) == 0)
1623 return -EINVAL;
1624
1625 if (user)
1626 {
1627 m = _stp_umod_lookup (pc, current, & module_name, NULL, NULL);
1628 if (m)
1629 s = &m->sections[0];
1630 }
1631 else
1632 {
1633 m = _stp_kmod_sec_lookup (pc, &s);
1634 if (!m) {
1635 #ifdef STAPCONF_MODULE_TEXT_ADDRESS
1636 struct module *ko;
1637 preempt_disable();
1638 ko = __module_text_address (pc);
1639 if (ko) { module_name = ko->name; }
1640 else {
1641 /* Possible heuristic: we could assume we're talking
1642 about the kernel. If __kernel_text_address()
1643 were SYMBOL_EXPORT'd, we could call that and be
1644 more sure. */
1645 }
1646 preempt_enable_no_resched();
1647 #endif
1648 }
1649 }
1650
1651 if (unlikely(m == NULL)) {
1652 if (module_name)
1653 _stp_warn ("Missing unwind data for module, rerun with 'stap -d %s'\n",
1654 module_name);
1655 // Don't _stp_warn about this, will use fallback unwinder.
1656 dbug_unwind(1, "No module found for pc=%lx", pc);
1657 return -EINVAL;
1658 }
1659
1660 dbug_unwind(1, "trying debug_frame\n");
1661 res = unwind_frame (context, m, s, m->debug_frame,
1662 m->debug_frame_len, 0, user, compat_task);
1663 if (res != 0) {
1664 dbug_unwind(1, "debug_frame failed: %d, trying eh_frame\n", res);
1665 res = unwind_frame (context, m, s, m->eh_frame,
1666 m->eh_frame_len, 1, user, compat_task);
1667 }
1668
1669 /* This situation occurs where some unwind data was found, but
1670 it was lacking somehow. */
1671 if (res != 0) {
1672 dbug_unwind (2, "unwinding failed: %d\n", res);
1673 }
1674
1675 return res;
1676 }
systemtap: system-wide probe/trace tool
This page took 0.124163 seconds and 5 git commands to generate.