Debian Codegraph @

tapset/x86_64/registers.stp

raw
1 %{
2 /* Set to include regparm field in probe context in translate.cxx. */
3 #ifndef STAP_NEED_REGPARM
4 #define STAP_NEED_REGPARM 1
5 #endif
6 %}
7
8 @__private30 global _reg_offsets[21], _r32_offsets[10], _r16_offsets[13],
9 _r8_offsets[8]
10
11 probe init {
12 /* Same order as pt_regs */
13 _reg_offsets["r15"] = 0
14 _reg_offsets["r14"] = 8
15 _reg_offsets["r13"] = 16
16 _reg_offsets["r12"] = 24
17 _reg_offsets["rbp"] = 32
18 _reg_offsets["rbx"] = 40
19 _reg_offsets["r11"] = 48
20 _reg_offsets["r10"] = 56
21 _reg_offsets["r9"] = 64
22 _reg_offsets["r8"] = 72
23 _reg_offsets["rax"] = 80
24 _reg_offsets["rcx"] = 88
25 _reg_offsets["rdx"] = 96
26 _reg_offsets["rsi"] = 104
27 _reg_offsets["rdi"] = 112
28 _reg_offsets["orig_rax"] = 120
29 _reg_offsets["rip"] = 128
30 _reg_offsets["xcs"] = 136
31 _reg_offsets["eflags"] = 144
32 _reg_offsets["rsp"] = 152
33 _reg_offsets["xss"] = 160
34
35 _r32_offsets["ebp"] = 32
36 _r32_offsets["ebx"] = 40
37 _r32_offsets["eax"] = 80
38 _r32_offsets["ecx"] = 88
39 _r32_offsets["edx"] = 96
40 _r32_offsets["esi"] = 104
41 _r32_offsets["edi"] = 112
42 _r32_offsets["orig_eax"] = 120
43 _r32_offsets["eip"] = 128
44 _r32_offsets["esp"] = 152
45
46 _r16_offsets["bp"] = 32
47 _r16_offsets["bx"] = 40
48 _r16_offsets["ax"] = 80
49 _r16_offsets["cx"] = 88
50 _r16_offsets["dx"] = 96
51 _r16_offsets["si"] = 104
52 _r16_offsets["di"] = 112
53 _r16_offsets["orig_ax"] = 120
54 _r16_offsets["ip"] = 128
55 _r16_offsets["cs"] = 136
56 _r16_offsets["flags"] = 144
57 _r16_offsets["sp"] = 152
58 _r16_offsets["ss"] = 160
59
60 _r8_offsets["al"] = 80
61 _r8_offsets["ah"] = 81
62 _r8_offsets["bl"] = 40
63 _r8_offsets["bh"] = 41
64 _r8_offsets["cl"] = 88
65 _r8_offsets["ch"] = 89
66 _r8_offsets["dl"] = 96
67 _r8_offsets["dh"] = 97
68 }
69
70 function _stp_get_register_by_offset:long (offset:long) %{ /* pure */
71 long value;
72 struct pt_regs *regs;
73 regs = (CONTEXT->user_mode_p ? CONTEXT->uregs : CONTEXT->kregs);
74 if (!regs) {
75 CONTEXT->last_error = "No registers available in this context";
76 return;
77 }
78 if (STAP_ARG_offset < 0 || STAP_ARG_offset > sizeof(struct pt_regs) - sizeof(long)) {
79 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
80 "Bad register offset: %lld", (long long) STAP_ARG_offset);
81 CONTEXT->last_error = CONTEXT->error_buffer;
82 return;
83 }
84 memcpy(&value, ((char *)regs) + STAP_ARG_offset, sizeof(value));
85 STAP_RETVALUE = value;
86 %}
87
88 /*
89 * _stp_sign_extend32() is callable from a script function.
90 * __stp_sign_extend32() (in regs.c) is callable from a C function.
91 */
92 function _stp_sign_extend32:long (value:long) %{ /* pure */
93 STAP_RETVALUE = __stp_sign_extend32(STAP_ARG_value);
94 %}
95
96 /*
97 * _stp_sign_extend16() is callable from a script function.
98 * __stp_sign_extend16() (in regs.c) is callable from a C function.
99 */
100 function _stp_sign_extend16:long (value:long) %{ /* pure */
101 STAP_RETVALUE = __stp_sign_extend16(STAP_ARG_value);
102 %}
103
104 /*
105 * _stp_sign_extend8() is callable from a script function.
106 * __stp_sign_extend8() (in regs.c) is callable from a C function.
107 */
108 function _stp_sign_extend8:long (value:long) %{ /* pure */
109 STAP_RETVALUE = __stp_sign_extend8(STAP_ARG_value);
110 %}
111
112 function _stp_register:long (name:string, sign_extend:long) {
113 reg32 = 0
114 reg16 = 0
115 reg8 = 0
116 assert(registers_valid(), "cannot access CPU registers in this context")
117 offset = _reg_offsets[name]
118 if (offset == 0 && !(name in _reg_offsets)) {
119 offset = _r32_offsets[name]
120 if (offset == 0 && !(name in _r32_offsets)) {
121 offset = _r16_offsets[name]
122 if (offset == 0 && !(name in _r16_offsets)) {
123 offset = _r8_offsets[name]
124 if (offset == 0 && !(name in _r8_offsets)) {
125 assert(0, "Unknown register: " . name)
126 } else {
127 reg8 = 1;
128 }
129 } else {
130 reg16 = 1;
131 }
132
133 } else {
134 reg32 = 1
135 }
136 }
137 value = _stp_get_register_by_offset(offset)
138 if (reg32) {
139 if (sign_extend)
140 value = _stp_sign_extend32(value)
141 else
142 value &= 0xffffffff
143 } else if (reg16) {
144 if (sign_extend)
145 value = _stp_sign_extend16(value)
146 else
147 value &= 0xffff
148 } else if (reg8) {
149 if (sign_extend)
150 value = _stp_sign_extend8(value)
151 else
152 value &= 0xff
153 }
154 return value
155 }
156
157 /* Return the named register value as a signed value. */
158 function register:long (name:string) {
159 return _stp_register(name, 1)
160 }
161
162 /*
163 * Return the named register value as an unsigned value. Specifically,
164 * don't sign-extend the register value when promoting it to 64 bits.
165 */
166 function u_register:long (name:string) {
167 return _stp_register(name, 0)
168 }
169
170 /*
171 * Return the value of function arg #argnum (1=first arg).
172 * If truncate=1, mask off the top 32 bits.
173 * If sign_extend=1 and (truncate=1 or the probepoint we've hit is in a
174 * 32-bit app), sign-extend the 32-bit value.
175 * If force64=1, return a 64-bit value even if we're in a 32-bit app.
176 */
177 function _stp_arg:long (argnum:long, sign_extend:long, truncate:long)
178 {
179 return _stp_arg2(argnum, sign_extend, truncate, 0)
180 }
181 function _stp_arg2:long (argnum:long, sign_extend:long, truncate:long,
182 force64:long)
183 %{ /* pure */
184 __label__ deref_fault;
185 long val;
186 struct pt_regs *regs;
187 int result, n, nr_regargs;
188 size_t argsz = sizeof(long);
189
190 if (CONTEXT->sregs) { /* syscall-in-pt_regs mode: kernel 4.17+ or similar */
191 void* valptr;
192 int is_32bit = _stp_is_compat_task();
193 regs = CONTEXT->sregs;
194
195 /* NB: kread() is probably unnecessary paranoia w.r.t. the sregs pointer. */
196 if (is_32bit) switch (STAP_ARG_argnum) {
197 /* SC_IA32_REGS_TO_ARGS / SC_X86_64_REGS_TO_ARGS */
198 case 1: valptr = &(RREG(bx, regs)); break;
199 case 2: valptr = &(RREG(cx, regs)); break;
200 case 3: valptr = &(RREG(dx, regs)); break;
201 case 4: valptr = &(RREG(si, regs)); break;
202 case 5: valptr = &(RREG(di, regs)); break;
203 case 6: valptr = &(RREG(bp, regs)); break;
204 default:
205 goto bad_argnum;
206 }
207 else switch (STAP_ARG_argnum) {
208 /* SC_IA32_REGS_TO_ARGS / SC_X86_64_REGS_TO_ARGS */
209 case 1: valptr = &(RREG(di, regs)); break;
210 case 2: valptr = &(RREG(si, regs)); break;
211 case 3: valptr = &(RREG(dx, regs)); break;
212 case 4: valptr = &(regs->r10); break;
213 case 5: valptr = &(regs->r8); break;
214 case 6: valptr = &(regs->r9); break;
215 default:
216 goto bad_argnum;
217 }
218
219 val = kread((long *)valptr);
220
221 /* Here, we do sign extension / truncation, ignoring CONTEXT->user_mode_p. */
222 if ((STAP_ARG_truncate || _stp_is_compat_task())
223 && !STAP_ARG_force64) {
224 if (STAP_ARG_sign_extend)
225 STAP_RETVALUE = (int64_t) __stp_sign_extend32(val);
226 else
227 /* High bits may be garbage. */
228 STAP_RETVALUE = (int64_t) (val & 0xffffffff);
229 } else
230 STAP_RETVALUE = (int64_t) val;
231
232 return;
233 }
234
235 // fall through in the non-sycall-mode case
236
237 regs = (CONTEXT->user_mode_p ? CONTEXT->uregs : CONTEXT->kregs);
238
239 STAP_RETVALUE = 0;
240 if (!regs) {
241 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
242 "cannot access function args in this context");
243 CONTEXT->last_error = CONTEXT->error_buffer;
244 return;
245 }
246 if (STAP_ARG_argnum < 1)
247 goto bad_argnum;
248 n = (int) STAP_ARG_argnum;
249 if (CONTEXT->regparm == 0) {
250 /* Default */
251 if (CONTEXT->user_mode_p && _stp_is_compat_task())
252 nr_regargs = 0;
253 else
254 nr_regargs = 6;
255 } else
256 nr_regargs = (CONTEXT->regparm & _STP_REGPARM_MASK);
257
258 if (!STAP_ARG_force64 && CONTEXT->user_mode_p && _stp_is_compat_task()) {
259 argsz = sizeof(int);
260 result = _stp_get_arg32_by_number(n, nr_regargs, regs, &val);
261 } else {
262 result = _stp_get_arg64_by_number(n, nr_regargs, regs, &val);
263 }
264 switch (result) {
265 case 0:
266 /* Arg is in register. */
267 break;
268 case 1:
269 /* Arg is on kernel stack. */
270 val = kread((long *) val);
271 break;
272 case 2:
273 {
274 /* Arg is on user stack. */
275 const char __user *vaddr = (const char __user*) val;
276 if (_stp_copy_from_user((char*)&val, vaddr, argsz) != 0) {
277 /* Stack page not resident. */
278 _stp_warn("cannot access arg(%d) "
279 "at user stack address %p\n", n, vaddr);
280 STAP_RETVALUE = 0;
281 return;
282 }
283 break;
284 }
285 default:
286 goto bad_argnum;
287 }
288
289 /* Sign-extend etc. as needed, depending on process 32-bitness. */
290 if ((STAP_ARG_truncate || (CONTEXT->user_mode_p && _stp_is_compat_task()))
291 && !STAP_ARG_force64) {
292 if (STAP_ARG_sign_extend)
293 STAP_RETVALUE = (int64_t) __stp_sign_extend32(val);
294 else
295 /* High bits may be garbage. */
296 STAP_RETVALUE = (int64_t) (val & 0xffffffff);
297 } else
298 STAP_RETVALUE = (int64_t) val;
299 return;
300
301 bad_argnum:
302 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
303 "cannot access arg(%lld)", STAP_ARG_argnum);
304 CONTEXT->last_error = CONTEXT->error_buffer;
305 return;
306
307 deref_fault: /* branched to from kread() */
308 snprintf (CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
309 "kernel fault at %#lx accessing arg(%lld)", val,
310 STAP_ARG_argnum);
311 CONTEXT->last_error = CONTEXT->error_buffer;
312 %}
313
314 /* For use with syscall-in-pt_regs mode: kernel 4.17+ or similar */
315 function _stp_get_arg_ptr:long (argnum:long) %{
316 void* regptr;
317 struct pt_regs *regs;
318 int is_32bit = _stp_is_compat_task();
319
320 if (!CONTEXT->sregs) {
321 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
322 "cannot access function args in this context");
323 CONTEXT->last_error = CONTEXT->error_buffer;
324 return;
325 }
326
327 regs = CONTEXT->sregs;
328
329 if (is_32bit) switch (STAP_ARG_argnum) {
330 case 1: regptr = &(RREG(bx, regs)); break;
331 case 2: regptr = &(RREG(cx, regs)); break;
332 case 3: regptr = &(RREG(dx, regs)); break;
333 case 4: regptr = &(RREG(si, regs)); break;
334 case 5: regptr = &(RREG(di, regs)); break;
335 case 6: regptr = &(RREG(bp, regs)); break;
336 default:
337 goto bad_argnum;
338 }
339 else switch (STAP_ARG_argnum) {
340 case 1: regptr = &(RREG(di, regs)); break;
341 case 2: regptr = &(RREG(si, regs)); break;
342 case 3: regptr = &(RREG(dx, regs)); break;
343 case 4: regptr = &(regs->r10); break;
344 case 5: regptr = &(regs->r8); break;
345 case 6: regptr = &(regs->r9); break;
346 default:
347 goto bad_argnum;
348 }
349
350 STAP_RETVALUE = (unsigned long) regptr;
351 return;
352
353 bad_argnum:
354 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
355 "cannot access arg(%lld)", STAP_ARG_argnum);
356 CONTEXT->last_error = CONTEXT->error_buffer;
357 return;
358 %}
359
360 function probing_32bit_app:long() %{ /* pure */
361 STAP_RETVALUE = (CONTEXT->user_mode_p && _stp_is_compat_task());
362 %}
363
364 function arch_bytes:long() %{ /* pure */
365 STAP_RETVALUE = sizeof(long);
366 %}
367
368 function uarch_bytes:long() {
369 assert(user_mode(), "requires user mode")
370 return probing_32bit_app() ? 4 : 8
371 }
372
373 /* Set the #value of function arg #argnum (1=first arg) as a signed int. */
374 function set_int_arg (argnum:long, value:long) {
375 set_kernel_int(_stp_get_arg_ptr(argnum), value);
376 return
377 }
378
379 /* Return the value of function arg #argnum (1=first arg) as a signed int. */
380 function int_arg:long (argnum:long) {
381 return _stp_arg2(argnum, 1, 1, 0)
382 }
383
384 /* Set the #value of function arg #argnum (1=first arg) as an unsigned int. */
385 function set_uint_arg (argnum:long, value:long) {
386 set_int_arg(argnum, value);
387 return
388 }
389
390 /* Return the value of function arg #argnum (1=first arg) as an unsigned int. */
391 function uint_arg:long (argnum:long) {
392 return _stp_arg2(argnum, 0, 1, 0)
393 }
394
395 function set_long_arg (argnum:long, value:long) {
396 set_kernel_long(_stp_get_arg_ptr(argnum), value);
397 return
398 }
399
400 function long_arg:long (argnum:long) {
401 return _stp_arg2(argnum, 1, 0, 0)
402 }
403
404 function set_ulong_arg (argnum:long, value:long) {
405 set_kernel_long(_stp_get_arg_ptr(argnum), value);
406 return
407 }
408
409 function ulong_arg:long (argnum:long) {
410 return _stp_arg2(argnum, 0, 0, 0)
411 }
412
413 function set_longlong_arg (argnum:long, value:long) {
414 if (probing_32bit_app()) {
415 highbits = value >> 32
416 lowbits = value & 0xffffffff
417 set_u32_arg(argnum, lowbits)
418 set_u32_arg(argnum+1, highbits)
419 } else
420 set_long_arg(argnum, value)
421 }
422
423 function longlong_arg:long (argnum:long) {
424 if (probing_32bit_app()) {
425 lowbits = _stp_arg2(argnum, 0, 1, 0)
426 highbits = _stp_arg2(argnum+1, 0, 1, 0)
427 return ((highbits << 32) | lowbits)
428 } else
429 return _stp_arg2(argnum, 0, 0, 1)
430 }
431
432 function set_ulonglong_arg (argnum:long, value:long) {
433 set_longlong_arg(argnum, value)
434 return
435 }
436
437 function ulonglong_arg:long (argnum:long) {
438 return longlong_arg(argnum)
439 }
440
441 function set_pointer_arg (argnum:long, value:long) {
442 set_kernel_pointer(_stp_get_arg_ptr(argnum), value);
443 return
444 }
445
446 function pointer_arg:long (argnum:long) {
447 return _stp_arg2(argnum, 0, 0, 0)
448 }
449
450 function set_s32_arg:long (argnum:long, value:long) {
451 set_int_arg(argnum, value);
452 return
453 }
454
455 function s32_arg:long (argnum:long) {
456 return int_arg(argnum)
457 }
458
459 function set_u32_arg (argnum:long, value:long) {
460 set_uint_arg(argnum, value);
461 return
462 }
463
464 function u32_arg:long (argnum:long) {
465 return uint_arg(argnum)
466 }
467
468 function set_s64_arg (argnum:long, value:long) {
469 set_longlong_arg(argnum, value);
470 return
471 }
472
473 function s64_arg:long (argnum:long) {
474 return longlong_arg(argnum)
475 }
476
477 function set_u64_arg (argnum:long, value:long) {
478 set_ulonglong_arg(argnum, value);
479 return
480 }
481
482 function u64_arg:long (argnum:long) {
483 return ulonglong_arg(argnum)
484 }
485
486 function asmlinkage() %{ /* pure */ %}
487
488 function fastcall() %{ /* pure */ %}
489
490 function regparm(n:long) %{
491 if (CONTEXT->user_mode_p && _stp_is_compat_task()
492 && (STAP_ARG_n < 0 || STAP_ARG_n > 3)) {
493 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
494 "For -m32 programs, "
495 "regparm value must be in the range 0-3.");
496 CONTEXT->last_error = CONTEXT->error_buffer;
497 } else if (STAP_ARG_n < 0 || STAP_ARG_n > 6) {
498 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
499 "For x86_64, regparm value must be in the range 0-6.");
500 CONTEXT->last_error = CONTEXT->error_buffer;
501 } else
502 CONTEXT->regparm = _STP_REGPARM | (int) STAP_ARG_n;
503 %}