Debian Codegraph @

tapset/i386/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[17], _r16_offsets[17], _r8_offsets[8],
9 _sp_offset, _ss_offset
10
11 function test_x86_fs:long() %{ /* pure */
12 #if defined(STAPCONF_X86_XFS) || defined (STAPCONF_X86_FS)
13 STAP_RETVALUE = 1;
14 #else
15 STAP_RETVALUE = 0;
16 #endif
17 %}
18
19 function test_x86_gs:long() %{ /* pure */
20 #ifdef STAPCONF_X86_GS
21 STAP_RETVALUE = 1;
22 #else
23 STAP_RETVALUE = 0;
24 #endif
25 %}
26
27 probe init {
28
29 /* Same order as pt_regs */
30 _offset = 0
31 _reg_offsets["ebx"] = _r16_offsets["bx"] = _r8_offsets["bl"] = _offset
32 _r8_offsets["bh"] = _offset + 1
33
34 _reg_offsets["ecx"] = _r16_offsets["cx"] = _r8_offsets["cl"]
35 = (_offset += 4)
36 _r8_offsets["ch"] = _offset + 1
37
38 _reg_offsets["edx"] = _r16_offsets["dx"] = _r8_offsets["dl"]
39 = (_offset += 4)
40 _r8_offsets["dh"] = _offset + 1
41
42 _reg_offsets["esi"] = _r16_offsets["si"] = (_offset += 4)
43 _reg_offsets["edi"] = _r16_offsets["di"] = (_offset += 4)
44 _reg_offsets["ebp"] = _r16_offsets["bp"] = (_offset += 4)
45
46 _reg_offsets["eax"] = _r16_offsets["ax"] = _r8_offsets["al"]
47 = (_offset += 4)
48 _r8_offsets["ah"] = _offset + 1
49
50 _reg_offsets["xds"] = _r16_offsets["ds"] = (_offset += 4)
51 _reg_offsets["xes"] = _r16_offsets["es"] = (_offset += 4)
52 if (test_x86_fs()) {
53 _reg_offsets["xfs"] = _r16_offsets["fs"] = (_offset += 4)
54 }
55 if (test_x86_gs()) {
56 _reg_offsets["xgs"] = _r16_offsets["gs"] = (_offset += 4)
57 }
58 _reg_offsets["orig_eax"] = _r16_offsets["orig_ax"] = (_offset += 4)
59 _reg_offsets["eip"] = _r16_offsets["ip"] = (_offset += 4)
60 _reg_offsets["xcs"] = _r16_offsets["cs"] = (_offset += 4)
61 _reg_offsets["eflags"] = _r16_offsets["flags"] = (_offset += 4)
62 _reg_offsets["esp"] = _r16_offsets["sp"] = _sp_offset = (_offset += 4)
63 _reg_offsets["xss"] = _r16_offsets["ss"] = _ss_offset = (_offset += 4)
64 }
65
66 function _stp_get_register_by_offset:long (offset:long) %{ /* pure */
67 long value;
68 struct pt_regs *regs;
69 regs = (CONTEXT->user_mode_p ? CONTEXT->uregs : CONTEXT->kregs);
70
71 if (!regs) {
72 CONTEXT->last_error = "No registers available in this context";
73 return;
74 }
75 if (STAP_ARG_offset < 0 || STAP_ARG_offset > sizeof(struct pt_regs) - sizeof(long)) {
76 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
77 "Bad register offset: %lld", STAP_ARG_offset);
78 CONTEXT->last_error = CONTEXT->error_buffer;
79 return;
80 }
81 memcpy(&value, ((char *)regs) + STAP_ARG_offset, sizeof(value));
82 STAP_RETVALUE = value;
83 %}
84
85 function _stp_probing_kernel:long () {
86 return !user_mode();
87 }
88
89 function arch_bytes:long() %{ /* pure */
90 STAP_RETVALUE = sizeof(long);
91 %}
92
93 function uarch_bytes:long() {
94 assert(user_mode(), "requires user mode")
95 return 4
96 }
97
98 /*
99 * esp and ss aren't saved on a breakpoint in kernel mode, so
100 * the pre-trap stack pointer is &regs->sp.
101 *
102 * Note that the idea of i386 trap regs is that pt_regs is the very
103 * first thing saved on the stack. Neither sp nor ss are saved, but
104 * pt_regs is aligned on the stack such that the place where sp would
105 * be saved happens to be the top where the sp was when the trap
106 * started. So &regs->sp is that original sp value. See
107 * arch/x86/entry/entry_32.S in the kernel source for more details.
108 */
109 function _stp_kernel_sp:long (sp_offset:long) %{ /* pure */
110 STAP_RETVALUE = ((long) CONTEXT->kregs) + STAP_ARG_sp_offset;
111 %}
112
113 /* Assume ss register hasn't changed since we took the trap. */
114 function _stp_kernel_ss:long () %{ /* pure */
115 unsigned short ss;
116 asm volatile("movw %%ss, %0" : : "m" (ss));
117 STAP_RETVALUE = ss;
118 %}
119
120 /*
121 * _stp_sign_extend32() is callable from a script function.
122 * __stp_sign_extend32() (in regs.c) is callable from a C function.
123 */
124 function _stp_sign_extend32:long (value:long) %{ /* pure */
125 STAP_RETVALUE = __stp_sign_extend32(STAP_ARG_value);
126 %}
127
128 /*
129 * _stp_sign_extend16() is callable from a script function.
130 * __stp_sign_extend16() (in regs.c) is callable from a C function.
131 */
132 function _stp_sign_extend16:long (value:long) %{ /* pure */
133 STAP_RETVALUE = __stp_sign_extend16(STAP_ARG_value);
134 %}
135
136 /*
137 * _stp_sign_extend8() is callable from a script function.
138 * __stp_sign_extend8() (in regs.c) is callable from a C function.
139 */
140 function _stp_sign_extend8:long (value:long) %{ /* pure */
141 STAP_RETVALUE = __stp_sign_extend8(STAP_ARG_value);
142 %}
143
144 function _stp_register:long (name:string, sign_extend:long) {
145 reg16 = 0
146 reg8 = 0
147 assert(registers_valid(), "cannot access CPU registers in this context")
148 offset = _reg_offsets[name]
149 if (offset == 0 && !(name in _reg_offsets)) {
150 offset = _r16_offsets[name]
151 if (offset == 0 && !(name in _r16_offsets)) {
152 offset = _r8_offsets[name]
153 if (offset == 0 && !(name in _r8_offsets)) {
154 assert(0, "Unknown register: " . name)
155 } else {
156 reg8 = 1;
157 }
158 } else {
159 reg16 = 1;
160 }
161 }
162
163 if (_stp_probing_kernel()) {
164 if (offset == _sp_offset)
165 return _stp_kernel_sp(_sp_offset)
166 else if (offset == _ss_offset)
167 return _stp_kernel_ss()
168 }
169
170 value = _stp_get_register_by_offset(offset)
171 if (reg16) {
172 if (sign_extend)
173 value = _stp_sign_extend16(value)
174 else
175 value &= 0xffff
176 } else if (reg8) {
177 if (sign_extend)
178 value = _stp_sign_extend8(value)
179 else
180 value &= 0xff
181 } else {
182 if (sign_extend)
183 value = _stp_sign_extend32(value)
184 else
185 value &= 0xffffffff
186 }
187 return value
188 }
189
190 /* Return the named register value as a signed value. */
191 function register:long (name:string) {
192 return _stp_register (name, 1)
193 }
194
195 /*
196 * Return the named register value as an unsigned value. Specifically,
197 * don't sign-extend the register value when promoting it to 64 bits.
198 */
199 function u_register:long (name:string) {
200 return _stp_register(name, 0)
201 }
202
203 /* Return the value of function arg #argnum (1=first arg) as a signed value. */
204 function _stp_arg:long (argnum:long) %{ /* pure */
205 __label__ deref_fault;
206 long val;
207 int n, nr_regargs, result;
208 struct pt_regs *regs;
209 regs = (CONTEXT->user_mode_p ? CONTEXT->uregs : CONTEXT->kregs);
210 STAP_RETVALUE = 0;
211 if (!regs) {
212 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
213 "cannot access function args in this context");
214 CONTEXT->last_error = CONTEXT->error_buffer;
215 return;
216 }
217 if (STAP_ARG_argnum < 1)
218 goto bad_argnum;
219 n = (int) STAP_ARG_argnum;
220 if (CONTEXT->regparm == 0) {
221 /* Default */
222 if (CONTEXT->user_mode_p)
223 nr_regargs = 0;
224 else
225 nr_regargs = 3;
226 } else
227 nr_regargs = (CONTEXT->regparm & _STP_REGPARM_MASK);
228 result = _stp_get_arg32_by_number(n, nr_regargs, regs, &val);
229 switch (result) {
230 case 0:
231 /* Arg is in register. */
232 STAP_RETVALUE = (int64_t) val;
233 break;
234 case 1:
235 /* Arg is on kernel stack. */
236 STAP_RETVALUE = kread((long *) val);
237 break;
238 case 2:
239 {
240 /* Arg is on user stack. */
241 const char __user *vaddr = (const char __user*) val;
242 if (_stp_copy_from_user((char*)&val, vaddr, sizeof(val)) != 0) {
243 /* Stack page not resident. */
244 _stp_warn("cannot access arg(%d) "
245 "at user stack address %p\n", n, vaddr);
246 STAP_RETVALUE = 0;
247 } else
248 STAP_RETVALUE = (int64_t) val;
249 break;
250 }
251 default:
252 goto bad_argnum;
253 }
254 return;
255
256 bad_argnum:
257 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
258 "cannot access arg(%lld)", STAP_ARG_argnum);
259 CONTEXT->last_error = CONTEXT->error_buffer;
260 return;
261
262 deref_fault: /* branched to from kread() */
263 snprintf (CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
264 "kernel fault at %#lx accessing arg(%lld)", val,
265 STAP_ARG_argnum);
266 CONTEXT->last_error = CONTEXT->error_buffer;
267 %}
268
269 /* Return the value of function arg #argnum as a signed int. */
270 function int_arg:long (argnum:long) {
271 return _stp_arg(argnum)
272 }
273
274 /* Return the value of function arg #argnum as an unsigned int. */
275 function uint_arg:long (argnum:long) {
276 return _stp_arg(argnum) & 0xffffffff;
277 }
278
279 function long_arg:long (argnum:long) {
280 return int_arg(argnum)
281 }
282
283 function ulong_arg:long (argnum:long) {
284 return uint_arg(argnum)
285 }
286
287 function longlong_arg:long (argnum:long) {
288 /*
289 * TODO: If argnum == nr_regarg, gcc puts the whole 64-bit arg
290 * on the stack.
291 */
292 lowbits = uint_arg(argnum)
293 highbits = uint_arg(argnum+1)
294 return ((highbits << 32) | lowbits)
295 }
296
297 function ulonglong_arg:long (argnum:long) {
298 return longlong_arg(argnum)
299 }
300
301 function pointer_arg:long (argnum:long) {
302 return ulong_arg(argnum)
303 }
304
305 function s32_arg:long (argnum:long) {
306 return int_arg(argnum)
307 }
308
309 function u32_arg:long (argnum:long) {
310 return uint_arg(argnum)
311 }
312
313 function s64_arg:long (argnum:long) {
314 return longlong_arg(argnum)
315 }
316
317 function u64_arg:long (argnum:long) {
318 return ulonglong_arg(argnum)
319 }
320
321 function asmlinkage() %{
322 CONTEXT->regparm = _STP_REGPARM | 0;
323 %}
324
325 function fastcall() %{
326 CONTEXT->regparm = _STP_REGPARM | 3;
327 %}
328
329 function regparm(n:long) %{
330 if (STAP_ARG_n < 0 || STAP_ARG_n > 3) {
331 snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
332 "For i386, regparm value must be in the range 0-3.");
333 CONTEXT->last_error = CONTEXT->error_buffer;
334 } else
335 CONTEXT->regparm = _STP_REGPARM | (int) STAP_ARG_n;
336 %}