Debian Codegraph @

tapset/linux/sysc_signalfd.stp

raw
1 # signalfd _____________________________________________________
2 #
3 # long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemask)
4 # long sys_signalfd4(int ufd, sigset_t __user *user_mask, size_t sizemask,
5 # int flags)
6 # long compat_sys_signalfd(int ufd, const compat_sigset_t __user *sigmask,
7 # compat_size_t sigsetsize)
8 # long compat_sys_signalfd4(int ufd, const compat_sigset_t __user *sigmask,
9 # compat_size_t sigsetsize, int flags)
10 #
11
12 probe syscall.signalfd = dw_syscall.signalfd !, nd_syscall.signalfd ? {}
13 probe syscall.signalfd.return = dw_syscall.signalfd.return !,
14 nd_syscall.signalfd.return ? {}
15
16 probe syscall.compat_signalfd = dw_syscall.compat_signalfd !,
17 nd_syscall.compat_signalfd ? {}
18 probe syscall.compat_signalfd.return = dw_syscall.compat_signalfd.return !,
19 nd_syscall.compat_signalfd.return ? {}
20
21 @define _SYSCALL_SIGNALFD4_REGARGS_STORE
22 %(
23 if (@probewrite(flags))
24 set_int_arg(4, flags)
25 %)
26
27 # dw_signalfd _____________________________________________________
28
29 probe dw_syscall.signalfd = __syscall.signalfd4 !, __syscall.signalfd ?
30 {
31 flags = __int32(@choose_defined($flags, 0))
32 if (flags == 0) {
33 name = "signalfd"
34 argstr = sprintf("%d, %p, %d", __int32($ufd), @__pointer($user_mask),
35 $sizemask)
36 } else {
37 name = "signalfd4"
38 argstr = sprintf("%d, %p, %d, %s", __int32($ufd), @__pointer($user_mask),
39 $sizemask, _signalfd4_flags_str(flags))
40 }
41 }
42 probe __syscall.signalfd4 = kernel.function("sys_signalfd4").call
43 {
44 @__syscall_gate(@const("__NR_signalfd4"))
45 }
46 probe __syscall.signalfd = kernel.function("sys_signalfd").call
47 {
48 @__syscall_gate(@const("__NR_signalfd"))
49 }
50 probe dw_syscall.signalfd.return = __syscall.signalfd4.return !,
51 __syscall.signalfd.return ?
52 {
53 @SYSC_RETVALSTR($return)
54 }
55 probe __syscall.signalfd4.return = kernel.function("sys_signalfd4").return
56 {
57 @__syscall_gate(@const("__NR_signalfd4"))
58 flags = __int32(@entry($flags))
59 name = (flags == 0) ? "signalfd" : "signalfd4"
60 }
61 probe __syscall.signalfd.return = kernel.function("sys_signalfd").return
62 {
63 @__syscall_gate(@const("__NR_signalfd"))
64 flags = 0
65 name = "signalfd"
66 }
67 probe dw_syscall.compat_signalfd = kernel.function("do_compat_signalfd4") !,
68 kernel.function("compat_sys_signalfd4").call !,
69 kernel.function("compat_sys_signalfd").call ?
70 {
71 flags = __int32(@choose_defined($flags, 0))
72 __sigmask = 0
73 if (@defined($sigmask))
74 __sigmask = @__pointer($sigmask)
75 if (flags == 0) {
76 name = "signalfd"
77 argstr = sprintf("%d, %p, %d", __int32($ufd), __sigmask,
78 $sigsetsize)
79 } else {
80 name = "signalfd4"
81 argstr = sprintf("%d, %p, %d, %s", __int32($ufd), __sigmask,
82 $sigsetsize, _signalfd4_flags_str(flags))
83 }
84 }
85 probe dw_syscall.compat_signalfd.return =
86 kernel.function("do_compat_signalfd4").return !,
87 kernel.function("compat_sys_signalfd4").return !,
88 kernel.function("compat_sys_signalfd").return ?
89 {
90 flags = __int32(@entry(@choose_defined($flags, 0)))
91 name = (flags == 0) ? "signalfd" : "signalfd4"
92 @SYSC_RETVALSTR($return)
93 }
94
95 # nd_signalfd _____________________________________________________
96
97 probe nd_syscall.signalfd = nd1_syscall.signalfd!, nd2_syscall.signalfd!, tp_syscall.signalfd
98 { }
99
100 probe nd1_syscall.signalfd = __nd1_syscall.signalfd4 !,
101 __nd1_syscall.signalfd ?
102 {
103 }
104 probe __nd1_syscall.signalfd4 = kprobe.function("sys_signalfd4")
105 {
106 @__syscall_gate(@const("__NR_signalfd4"))
107 asmlinkage()
108 flags = int_arg(4)
109 if (flags == 0) {
110 name = "signalfd"
111 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
112 ulong_arg(3))
113 } else {
114 name = "signalfd4"
115 argstr = sprintf("%d, %p, %d, %s", int_arg(1), pointer_arg(2),
116 ulong_arg(3), _signalfd4_flags_str(flags))
117 }
118 }
119 probe __nd1_syscall.signalfd = kprobe.function("sys_signalfd")
120 {
121 @__syscall_gate(@const("__NR_signalfd"))
122 name = "signalfd"
123 asmlinkage()
124 flags = 0
125 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
126 ulong_arg(3))
127 }
128
129 /* kernel 4.17+ */
130 probe nd2_syscall.signalfd = __nd2_syscall.signalfd4 !,
131 __nd2_syscall.signalfd ?
132 {
133 }
134 probe __nd2_syscall.signalfd4 = kprobe.function(@arch_syscall_prefix "sys_signalfd4")
135 {
136 __set_syscall_pt_regs(pointer_arg(1))
137 flags = int_arg(4)
138 if (flags == 0) {
139 name = "signalfd"
140 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
141 ulong_arg(3))
142 } else {
143 name = "signalfd4"
144 argstr = sprintf("%d, %p, %d, %s", int_arg(1), pointer_arg(2),
145 ulong_arg(3), _signalfd4_flags_str(flags))
146 }
147 },
148 {
149 %( @_IS_SREG_KERNEL %? @_SYSCALL_SIGNALFD4_REGARGS_STORE %)
150 }
151
152 probe __nd2_syscall.signalfd = kprobe.function(@arch_syscall_prefix "sys_signalfd")
153 {
154 __set_syscall_pt_regs(pointer_arg(1))
155 name = "signalfd"
156 flags = 0
157 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
158 ulong_arg(3))
159 }
160
161 /* kernel 3.5+, but undesirable because it affects all syscalls */
162 probe tp_syscall.signalfd = __tp_syscall.signalfd4 !,
163 __tp_syscall.signalfd ?
164 {
165 }
166 probe __tp_syscall.signalfd4 = kernel.trace("sys_enter")
167 {
168 __set_syscall_pt_regs($regs)
169 @__syscall_gate(@const("__NR_signalfd4"))
170 flags = int_arg(4)
171 if (flags == 0) {
172 name = "signalfd"
173 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
174 ulong_arg(3))
175 } else {
176 name = "signalfd4"
177 argstr = sprintf("%d, %p, %d, %s", int_arg(1), pointer_arg(2),
178 ulong_arg(3), _signalfd4_flags_str(flags))
179 }
180 },
181 {
182 %( @_IS_SREG_KERNEL %? @_SYSCALL_SIGNALFD4_REGARGS_STORE %)
183 }
184 probe __tp_syscall.signalfd = kernel.trace("sys_enter")
185 {
186 __set_syscall_pt_regs($regs)
187 @__syscall_gate(@const("__NR_signalfd"))
188 name = "signalfd"
189 flags = 0
190 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
191 ulong_arg(3))
192 }
193
194 probe nd_syscall.signalfd.return = nd1_syscall.signalfd.return!, nd2_syscall.signalfd.return!, tp_syscall.signalfd.return
195 { }
196
197 probe nd1_syscall.signalfd.return = __nd1_syscall.signalfd4.return !,
198 __nd1_syscall.signalfd.return ?
199 {
200 @SYSC_RETVALSTR(returnval())
201 }
202 probe __nd1_syscall.signalfd4.return = kprobe.function("sys_signalfd4").return
203 {
204 @__syscall_gate(@const("__NR_signalfd4"))
205 flags = @entry(__asmlinkage_int_arg(4))
206 name = (flags == 0) ? "signalfd" : "signalfd4"
207 }
208 probe __nd1_syscall.signalfd.return = kprobe.function("sys_signalfd").return
209 {
210 @__syscall_gate(@const("__NR_signalfd"))
211 flags = 0
212 name = "signalfd"
213 }
214
215 /* kernel 4.17+ */
216 probe nd2_syscall.signalfd.return = __nd2_syscall.signalfd4.return !,
217 __nd2_syscall.signalfd.return ?
218 {
219 @SYSC_RETVALSTR(returnval())
220 }
221 probe __nd2_syscall.signalfd4.return = kprobe.function(@arch_syscall_prefix "sys_signalfd4").return
222 {
223 __set_syscall_pt_regs(@entry(pointer_arg(1)))
224 flags = int_arg(4)
225 name = (flags == 0) ? "signalfd" : "signalfd4"
226 }
227 probe __nd2_syscall.signalfd.return = kprobe.function(@arch_syscall_prefix "sys_signalfd").return
228 {
229 flags = 0
230 name = "signalfd"
231 }
232
233 /* kernel 3.5+, but undesirable because it affects all syscalls */
234 probe tp_syscall.signalfd.return = __tp_syscall.signalfd4.return !,
235 __tp_syscall.signalfd.return ?
236 {
237 @SYSC_RETVALSTR($ret)
238 }
239 probe __tp_syscall.signalfd4.return = kernel.trace("sys_exit")
240 {
241 __set_syscall_pt_regs($regs)
242 @__syscall_gate(@const("__NR_signalfd4"))
243 flags = int_arg(4)
244 name = (flags == 0) ? "signalfd" : "signalfd4"
245 }
246 probe __tp_syscall.signalfd.return = kernel.trace("sys_exit")
247 {
248 __set_syscall_pt_regs($regs)
249 @__syscall_gate(@const("__NR_signalfd4"))
250 flags = 0
251 name = "signalfd"
252 }
253
254 probe nd_syscall.compat_signalfd = nd1_syscall.compat_signalfd!, nd2_syscall.compat_signalfd!, tp_syscall.compat_signalfd
255 { }
256
257 probe nd1_syscall.compat_signalfd = __nd1_syscall.compat_signalfd4 !,
258 __nd1_syscall.compat_signalfd ?
259 {
260 }
261 probe __nd1_syscall.compat_signalfd4 = kprobe.function("compat_sys_signalfd4")
262 {
263 asmlinkage()
264 flags = int_arg(4)
265 if (flags == 0) {
266 name = "signalfd"
267 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
268 u32_arg(3))
269 } else {
270 name = "signalfd4"
271 argstr = sprintf("%d, %p, %d, %s", int_arg(1),
272 pointer_arg(2), u32_arg(3),
273 _signalfd4_flags_str(flags))
274 }
275 }
276 probe __nd1_syscall.compat_signalfd = kprobe.function("compat_sys_signalfd")
277 {
278 asmlinkage()
279 flags = 0
280 name = "signalfd"
281 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
282 u32_arg(3))
283 }
284
285 /* kernel 4.17+ */
286 probe nd2_syscall.compat_signalfd = __nd2_syscall.compat_signalfd4 !,
287 __nd2_syscall.compat_signalfd ?
288 {
289 }
290 probe __nd2_syscall.compat_signalfd4 = kprobe.function(@arch_syscall_prefix "compat_sys_signalfd4")
291 {
292 __set_syscall_pt_regs(pointer_arg(1))
293 flags = int_arg(4)
294 if (flags == 0) {
295 name = "signalfd"
296 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
297 u32_arg(3))
298 } else {
299 name = "signalfd4"
300 argstr = sprintf("%d, %p, %d, %s", int_arg(1),
301 pointer_arg(2), u32_arg(3),
302 _signalfd4_flags_str(flags))
303 }
304 },
305 {
306 %( @_IS_SREG_KERNEL %? @_SYSCALL_SIGNALFD4_REGARGS_STORE %)
307 }
308 probe __nd2_syscall.compat_signalfd = kprobe.function(@arch_syscall_prefix "compat_sys_signalfd")
309 {
310 __set_syscall_pt_regs(pointer_arg(1))
311 flags = 0
312 name = "signalfd"
313 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
314 u32_arg(3))
315 }
316
317 /* kernel 3.5+, but undesirable because it affects all syscalls */
318 probe tp_syscall.compat_signalfd = __tp_syscall.compat_signalfd4 !,
319 __tp_syscall.compat_signalfd ?
320 {
321 }
322 probe __tp_syscall.compat_signalfd4 = kernel.trace("sys_enter")
323 {
324 __set_syscall_pt_regs($regs)
325 @__compat_syscall_gate(@const("__NR_compat_signalfd4"))
326 flags = int_arg(4)
327 if (flags == 0) {
328 name = "signalfd"
329 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
330 u32_arg(3))
331 } else {
332 name = "signalfd4"
333 argstr = sprintf("%d, %p, %d, %s", int_arg(1),
334 pointer_arg(2), u32_arg(3),
335 _signalfd4_flags_str(flags))
336 }
337 },
338 {
339 %( @_IS_SREG_KERNEL %? @_SYSCALL_SIGNALFD4_REGARGS_STORE %)
340 }
341 probe __tp_syscall.compat_signalfd = kernel.function("sys_enter")
342 {
343 __set_syscall_pt_regs($regs)
344 @__compat_syscall_gate(@const("__NR_compat_signalfd"))
345 flags = int_arg(4)
346 flags = 0
347 name = "signalfd"
348 argstr = sprintf("%d, %p, %d", int_arg(1), pointer_arg(2),
349 u32_arg(3))
350 },
351 {
352 %( @_IS_SREG_KERNEL %? @_SYSCALL_SIGNALFD4_REGARGS_STORE %)
353 }
354
355 probe nd_syscall.compat_signalfd.return = nd1_syscall.compat_signalfd.return!, nd2_syscall.compat_signalfd.return!, tp_syscall.compat_signalfd.return
356 { }
357
358 probe nd1_syscall.compat_signalfd.return =
359 __nd1_syscall.compat_signalfd4.return !,
360 __nd1_syscall.compat_signalfd.return ?
361 {
362 }
363 probe __nd1_syscall.compat_signalfd4.return =
364 kprobe.function("compat_sys_signalfd4").return
365 {
366 flags = @entry(__asmlinkage_int_arg(4))
367 name = (flags == 0) ? "signalfd" : "signalfd4"
368 @SYSC_RETVALSTR(returnval())
369 }
370 probe __nd1_syscall.compat_signalfd.return =
371 kprobe.function("compat_sys_signalfd").return
372 {
373 flags = 0
374 name = "signalfd"
375 @SYSC_RETVALSTR(returnval())
376 }
377
378 /* kernel 4.17+ */
379 probe nd2_syscall.compat_signalfd.return =
380 __nd2_syscall.compat_signalfd4.return !,
381 __nd2_syscall.compat_signalfd.return ?
382 {
383 }
384 probe __nd2_syscall.compat_signalfd4.return =
385 kprobe.function(@arch_syscall_prefix "compat_sys_signalfd4").return
386 {
387 __set_syscall_pt_regs(@entry(pointer_arg(1)))
388 flags = int_arg(4)
389 name = (flags == 0) ? "signalfd" : "signalfd4"
390 @SYSC_RETVALSTR(returnval())
391 }
392 probe __nd2_syscall.compat_signalfd.return =
393 kprobe.function(@arch_syscall_prefix "compat_sys_signalfd").return
394 {
395 flags = 0
396 name = "signalfd"
397 @SYSC_RETVALSTR(returnval())
398 }
399
400 /* kernel 3.5+, but undesirable because it affects all syscalls */
401 probe tp_syscall.compat_signalfd.return =
402 __tp_syscall.compat_signalfd4.return !,
403 __tp_syscall.compat_signalfd.return ?
404 {
405 }
406 probe __tp_syscall.compat_signalfd4.return = kernel.trace("sys_exit")
407 {
408 __set_syscall_pt_regs($regs)
409 @__compat_syscall_gate(@const("__NR_compat_signalfd4"))
410 flags = int_arg(4)
411 name = (flags == 0) ? "signalfd" : "signalfd4"
412 @SYSC_RETVALSTR($ret)
413 }
414 probe __tp_syscall.compat_signalfd.return = kernel.trace("sys_exit")
415 {
416 __set_syscall_pt_regs($regs)
417 @__compat_syscall_gate(@const("__NR_compat_signalfd"))
418 flags = 0
419 name = "signalfd"
420 @SYSC_RETVALSTR($ret)
421 }