Debian Codegraph @

tapset/linux/sysc_sendmmsg.stp

raw
1 # sendmmsg ____________________________________________________
2 #
3 # int sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
4 # unsigned int flags)
5 #
6
7 @define _SYSCALL_SENDMMSG_NAME
8 %(
9 name = "sendmmsg"
10 %)
11
12 @define _SYSCALL_SENDMMSG_ARGSTR
13 %(
14 argstr = sprintf("%d, %p, %d, %s", s, mmsg_uaddr, vlen, flags_str)
15 %)
16
17 @define _SYSCALL_SENDMMSG_REGARGS
18 %(
19 s = int_arg(1)
20 mmsg_uaddr = pointer_arg(2)
21 vlen = uint_arg(3)
22 flags = uint_arg(4)
23 %)
24
25 @define _SYSCALL_SENDMMSG_REGARGS_STORE
26 %(
27 if (@probewrite(s))
28 set_int_arg(1, s)
29
30 if (@probewrite(mmsg_uaddr))
31 set_pointer_arg(2, mmsg_uaddr)
32
33 if (@probewrite(vlen))
34 set_uint_arg(3, vlen)
35
36 if (@probewrite(flags))
37 set_uint_arg(4, flags)
38 %)
39
40 @define _SYSCALL_COMPAT_SOCKETCALL_SENDMMSG_REGARGS
41 %(
42 __args = &@uint_cast(pointer_arg(2))
43 s = user_int(&@uint_cast(__args)[0])
44 mmsg_uaddr = user_uint32(&@uint_cast(__args)[1])
45 vlen = user_uint32(&@uint_cast(__args)[2])
46 flags = user_uint32(&@uint_cast(__args)[3])
47 %)
48
49 probe syscall.sendmmsg = dw_syscall.sendmmsg !, nd_syscall.sendmmsg ? {}
50 probe syscall.sendmmsg.return = dw_syscall.sendmmsg.return !,
51 nd_syscall.sendmmsg.return ? {}
52
53 # dw_sendmmsg _____________________________________________________
54
55 probe dw_syscall.sendmmsg = __syscall.sendmmsg ?,
56 __syscall.compat_socketcall.sendmmsg ?, __syscall.compat_sendmmsg ?
57 {
58 @_SYSCALL_SENDMMSG_NAME
59 flags_str = _msg_flags_str(flags)
60 @_SYSCALL_SENDMMSG_ARGSTR
61 }
62 probe __syscall.sendmmsg = kernel.function("sys_sendmmsg").call ?
63 {
64 # Avoid probe hits from compat_sys_socketcall() calling
65 # compat_sys_sendmmsg(), which sometimes calls
66 # sys_sendmmsg(). We could call __syscall_gate2() here with
67 # NR_sendmmsg and NR_socketcall, but all we really need to
68 # check is that we're not in a compat task.
69 @__syscall_gate_compat_simple
70 s = __int32($fd)
71 mmsg_uaddr = $mmsg
72 vlen = __uint32($vlen)
73 flags = __uint32($flags)
74 }
75 probe __syscall.compat_socketcall.sendmmsg =
76 kernel.function("compat_sys_socketcall").call ?
77 {
78 if (__int32($call) != @const("SYS_SENDMMSG")) next
79 s = user_int(&@uint_cast($args)[0])
80 mmsg_uaddr = user_uint32(&@uint_cast($args)[1])
81 vlen = user_uint32(&@uint_cast($args)[2])
82 flags = user_uint32(&@uint_cast($args)[3])
83 }
84 probe __syscall.compat_sendmmsg =
85 kernel.function("compat_sys_sendmmsg").call ?
86 {
87 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
88 s = __int32($fd)
89 mmsg_uaddr = $mmsg
90 vlen = __uint32($vlen)
91 flags = __uint32($flags)
92 }
93 probe dw_syscall.sendmmsg.return = __syscall.sendmmsg.return ?,
94 __syscall.compat_socketcall.sendmmsg.return ?,
95 __syscall.compat_sendmmsg.return ?
96 {
97 @_SYSCALL_SENDMMSG_NAME
98 @SYSC_RETVALSTR($return)
99 }
100 probe __syscall.sendmmsg.return = kernel.function("sys_sendmmsg").return ?
101 {
102 # Avoid probe hits from compat_sys_socketcall() calling
103 # compat_sys_sendmmsg(), which sometimes calls
104 # sys_sendmmsg(). We could call __syscall_gate2() here with
105 # NR_sendmmsg and NR_socketcall, but all we really need to
106 # check is that we're not in a compat task.
107 @__syscall_gate_compat_simple
108 }
109 probe __syscall.compat_socketcall.sendmmsg.return =
110 kernel.function("compat_sys_socketcall").return ?
111 {
112 if (__int32(@entry($call)) != @const("SYS_SENDMMSG")) next
113 }
114 probe __syscall.compat_sendmmsg.return =
115 kernel.function("compat_sys_sendmmsg").return ?
116 {
117 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
118 }
119
120 # nd_sendmmsg _____________________________________________________
121
122 probe nd_syscall.sendmmsg = nd1_syscall.sendmmsg!, nd2_syscall.sendmmsg!, tp_syscall.sendmmsg
123 { }
124
125 probe nd1_syscall.sendmmsg = __nd1_syscall.sendmmsg ?,
126 __nd1_syscall.compat_socketcall.sendmmsg ?,
127 __nd1_syscall.compat_sendmmsg ?
128 {
129 @_SYSCALL_SENDMMSG_NAME
130 flags_str = _msg_flags_str(flags)
131 @_SYSCALL_SENDMMSG_ARGSTR
132 }
133 probe __nd1_syscall.sendmmsg = kprobe.function("sys_sendmmsg").call ?
134 {
135 # Avoid probe hits from compat_sys_socketcall() calling
136 # compat_sys_sendmmsg(), which sometimes calls
137 # sys_sendmmsg(). We could call __syscall_gate2() here with
138 # NR_sendmmsg and NR_socketcall, but all we really need to
139 # check is that we're not in a compat task.
140 @__syscall_gate_compat_simple
141
142 asmlinkage()
143 @_SYSCALL_SENDMMSG_REGARGS
144 }
145 probe __nd1_syscall.compat_socketcall.sendmmsg =
146 kprobe.function("compat_sys_socketcall").call ?
147 {
148 asmlinkage()
149 if (int_arg(1) != @const("SYS_SENDMMSG")) next;
150 @_SYSCALL_COMPAT_SOCKETCALL_SENDMMSG_REGARGS
151 }
152 probe __nd1_syscall.compat_sendmmsg =
153 kprobe.function("compat_sys_sendmmsg").call ?
154 {
155 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
156 asmlinkage()
157 @_SYSCALL_SENDMMSG_REGARGS
158 }
159
160 probe nd2_syscall.sendmmsg = __nd2_syscall.sendmmsg ?,
161 __nd2_syscall.compat_socketcall.sendmmsg ?,
162 __nd2_syscall.compat_sendmmsg ?
163 {
164 @_SYSCALL_SENDMMSG_NAME
165 flags_str = _msg_flags_str(flags)
166 @_SYSCALL_SENDMMSG_ARGSTR
167 }
168 probe __nd2_syscall.sendmmsg = kprobe.function(@arch_syscall_prefix "sys_sendmmsg").call ?
169 {
170 # Avoid probe hits from compat_sys_socketcall() calling
171 # compat_sys_sendmmsg(), which sometimes calls
172 # sys_sendmmsg(). We could call __syscall_gate2() here with
173 # NR_sendmmsg and NR_socketcall, but all we really need to
174 # check is that we're not in a compat task.
175 @__syscall_gate_compat_simple
176
177 __set_syscall_pt_regs(pointer_arg(1))
178 @_SYSCALL_SENDMMSG_REGARGS
179 },
180 {
181 %( @_IS_SREG_KERNEL %? @_SYSCALL_SENDMMSG_REGARGS_STORE %)
182 }
183 probe __nd2_syscall.compat_socketcall.sendmmsg =
184 kprobe.function(@arch_syscall_prefix "compat_sys_socketcall").call ?
185 {
186 __set_syscall_pt_regs(pointer_arg(1))
187 if (int_arg(1) != @const("SYS_SENDMMSG")) next;
188 @_SYSCALL_COMPAT_SOCKETCALL_SENDMMSG_REGARGS
189 }
190 probe __nd2_syscall.compat_sendmmsg =
191 kprobe.function(@arch_syscall_prefix "compat_sys_sendmmsg").call ?
192 {
193 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
194 __set_syscall_pt_regs(pointer_arg(1))
195 @_SYSCALL_SENDMMSG_REGARGS
196 },
197 {
198 %( @_IS_SREG_KERNEL %? @_SYSCALL_SENDMMSG_REGARGS_STORE %)
199 }
200
201 probe tp_syscall.sendmmsg = __tp_syscall.sendmmsg ?,
202 __tp_syscall.compat_socketcall.sendmmsg ?
203 {
204 @_SYSCALL_SENDMMSG_NAME
205 flags_str = _msg_flags_str(flags)
206 @_SYSCALL_SENDMMSG_ARGSTR
207 }
208 probe __tp_syscall.sendmmsg = kernel.trace("sys_enter")
209 {
210 __set_syscall_pt_regs($regs)
211 @__syscall_compat_gate(@const("__NR_sendmmsg"), @const("__NR_compat_sendmmsg"))
212 @_SYSCALL_SENDMMSG_REGARGS
213 },
214 {
215 %( @_IS_SREG_KERNEL %? @_SYSCALL_SENDMMSG_REGARGS_STORE %)
216 }
217 probe __tp_syscall.compat_socketcall.sendmmsg = kernel.trace("sys_enter")
218 {
219 __set_syscall_pt_regs($regs)
220 @__compat_syscall_gate(@const("__NR_compat_socketcall"))
221 if (int_arg(1) != @const("SYS_SENDMMSG")) next;
222 @_SYSCALL_COMPAT_SOCKETCALL_SENDMMSG_REGARGS
223 }
224
225 probe nd_syscall.sendmmsg.return = nd1_syscall.sendmmsg.return!, nd2_syscall.sendmmsg.return!, tp_syscall.sendmmsg.return
226 { }
227
228 probe nd1_syscall.sendmmsg.return = __nd1_syscall.sendmmsg.return ?,
229 __nd1_syscall.compat_socketcall.sendmmsg.return ?,
230 __nd1_syscall.compat_sendmmsg.return ?
231 {
232 @_SYSCALL_SENDMMSG_NAME
233 @SYSC_RETVALSTR(returnval())
234 }
235 probe __nd1_syscall.sendmmsg.return = kprobe.function("sys_sendmmsg").return ?
236 {
237 # Avoid probe hits from compat_sys_socketcall() calling
238 # compat_sys_sendmmsg(), which sometimes calls
239 # sys_sendmmsg(). We could call __syscall_gate2() here with
240 # NR_sendmmsg and NR_socketcall, but all we really need to
241 # check is that we're not in a compat task.
242 @__syscall_gate_compat_simple
243 }
244 probe __nd1_syscall.compat_socketcall.sendmmsg.return =
245 kprobe.function("compat_sys_socketcall").return ?
246 {
247 if (@entry(__asmlinkage_int_arg(1)) != @const("SYS_SENDMMSG")) next;
248 }
249 probe __nd1_syscall.compat_sendmmsg.return =
250 kprobe.function("compat_sys_sendmmsg").return ?
251 {
252 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
253 }
254
255 probe nd2_syscall.sendmmsg.return = __nd2_syscall.sendmmsg.return ?,
256 __nd2_syscall.compat_socketcall.sendmmsg.return ?,
257 __nd2_syscall.compat_sendmmsg.return ?
258 {
259 @_SYSCALL_SENDMMSG_NAME
260 @SYSC_RETVALSTR(returnval())
261 }
262 probe __nd2_syscall.sendmmsg.return = kprobe.function(@arch_syscall_prefix "sys_sendmmsg").return ?
263 {
264 # Avoid probe hits from compat_sys_socketcall() calling
265 # compat_sys_sendmmsg(), which sometimes calls
266 # sys_sendmmsg(). We could call __syscall_gate2() here with
267 # NR_sendmmsg and NR_socketcall, but all we really need to
268 # check is that we're not in a compat task.
269 @__syscall_gate_compat_simple
270 }
271 probe __nd2_syscall.compat_socketcall.sendmmsg.return =
272 kprobe.function(@arch_syscall_prefix "compat_sys_socketcall").return ?
273 {
274 __set_syscall_pt_regs(@entry(pointer_arg(1)))
275 if (int_arg(1) != @const("SYS_SENDMMSG")) next;
276 }
277 probe __nd2_syscall.compat_sendmmsg.return =
278 kprobe.function(@arch_syscall_prefix "compat_sys_sendmmsg").return ?
279 {
280 @__compat_syscall_gate(@const("__NR_compat_sendmmsg"))
281 }
282
283 probe tp_syscall.sendmmsg.return = __tp_syscall.sendmmsg.return ?,
284 __tp_syscall.compat_socketcall.sendmmsg.return ?
285 {
286 @_SYSCALL_SENDMMSG_NAME
287 @SYSC_RETVALSTR($ret)
288 }
289 probe __tp_syscall.sendmmsg.return = kernel.trace("sys_exit")
290 {
291 @__syscall_compat_gate(@const("__NR_sendmmsg"), @const("__NR_compat_sendmmsg"))
292 }
293 probe __tp_syscall.compat_socketcall.sendmmsg.return = kernel.trace("sys_exit")
294 {
295 __set_syscall_pt_regs($regs)
296 @__compat_syscall_gate(@const("__NR_compat_socketcall"))
297 if (int_arg(1) != @const("SYS_SENDMMSG")) next;
298 }