Debian Codegraph @

tapset/linux/sysc_accept4.stp

raw
1 # accept4 ____________________________________________________
2 #
3 # SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
4 # int __user *, upeer_addrlen, int, flags)
5 #
6
7 @define _SYSCALL_ACCEPT4_NAME
8 %(
9 name = "accept4"
10 %)
11
12 @define _SYSCALL_ACCEPT4_ARGSTR
13 %(
14 argstr = sprintf("%d, %p, %p, %s", sockfd, addr_uaddr, addrlen_uaddr,
15 flags_str)
16 %)
17
18 @define _SYSCALL_ACCEPT4_REGARGS
19 %(
20 sockfd = int_arg(1)
21 addr_uaddr = pointer_arg(2)
22 addrlen_uaddr = pointer_arg(3)
23 flags = int_arg(4)
24 %)
25
26 @define _SYSCALL_ACCEPT4_REGARGS_STORE
27 %(
28 if (@probewrite(sockfd))
29 set_int_arg(1, sockfd)
30
31 if (@probewrite(addr_uaddr))
32 set_pointer_arg(2, addr_uaddr)
33
34 if (@probewrite(addrlen_uaddr))
35 set_pointer_arg(3, addrlen_uaddr)
36
37 if (@probewrite(flags))
38 set_int_arg(4, flags)
39 %)
40
41 @define _SYSCALL_SOCKETCALL_ACCEPT4_REGARGS
42 %(
43 __argsl = &@ulong_cast(pointer_arg(2))
44 sockfd = __int32(user_ulong(&@ulong_cast(__argsl)[0]))
45 addr_uaddr = user_ulong(&@ulong_cast(__argsl)[1])
46 addrlen_uaddr = user_ulong(&@ulong_cast(__argsl)[2])
47 flags = __int32(user_ulong(&@ulong_cast(__argsl)[3]))
48 %)
49
50 @define _SYSCALL_COMPAT_SOCKETCALL_ACCEPT4_REGARGS
51 %(
52 __argsi = &@uint_cast(pointer_arg(2))
53 sockfd = user_int(&@uint_cast(__argsi)[0])
54 addr_uaddr = user_uint32(&@uint_cast(__argsi)[1])
55 addrlen_uaddr = user_uint32(&@uint_cast(__argsi)[2])
56 flags = user_int(&@uint_cast(__argsi)[3])
57 %)
58
59 probe syscall.accept4 = dw_syscall.accept4 !, nd_syscall.accept4 ? {}
60 probe syscall.accept4.return = dw_syscall.accept4.return !, nd_syscall.accept4.return ? {}
61
62 # dw_accept4 _____________________________________________________
63
64 probe dw_syscall.accept4 = __syscall.accept4 ?, __syscall.socketcall.accept4 ?,
65 __syscall.compat_socketcall.accept4 ?
66 {
67 @_SYSCALL_ACCEPT4_NAME
68 flags_str = _sock_flags_str(flags)
69 @_SYSCALL_ACCEPT4_ARGSTR
70 }
71 probe __syscall.accept4 = kernel.function("sys_accept4").call
72 {
73 // On all tested platforms, there wasn't a different syscall
74 // number for the compat version of accept4().
75 @__syscall_nr_gate(@const("__NR_accept4"))
76 sockfd = __int32($fd)
77 addr_uaddr = $upeer_sockaddr
78 addrlen_uaddr = $upeer_addrlen
79 flags = __int32($flags)
80 }
81 probe __syscall.socketcall.accept4 = kernel.function("sys_socketcall").call ?
82 {
83 if (__int32($call) != @const("SYS_ACCEPT4")) next;
84 sockfd = __int32(user_ulong(&@ulong_cast($args)[0]))
85 addr_uaddr = user_ulong(&@ulong_cast($args)[1])
86 addrlen_uaddr = user_ulong(&@ulong_cast($args)[2])
87 flags = __int32(user_ulong(&@ulong_cast($args)[3]))
88 }
89 probe __syscall.compat_socketcall.accept4 =
90 kernel.function("compat_sys_socketcall").call ?
91 {
92 if (__int32($call) != @const("SYS_ACCEPT4")) next;
93 sockfd = user_int(&@uint_cast($args)[0])
94 addr_uaddr = user_uint32(&@uint_cast($args)[1])
95 addrlen_uaddr = user_uint32(&@uint_cast($args)[2])
96 flags = user_int(&@uint_cast($args)[3])
97 }
98 probe dw_syscall.accept4.return = __syscall.accept4.return ?,
99 __syscall.socketcall.accept4.return ?
100 {
101 @_SYSCALL_ACCEPT4_NAME
102 @SYSC_RETVALSTR($return)
103 }
104 probe __syscall.accept4.return = kernel.function("sys_accept4").return ?
105 {
106 @__syscall_nr_gate(@const("__NR_accept4"))
107 }
108 probe __syscall.socketcall.accept4.return =
109 kernel.function("sys_socketcall").return ?,
110 kernel.function("compat_sys_socketcall").return ?
111 {
112 if (__int32(@entry($call)) != @const("SYS_ACCEPT4")) next;
113 }
114
115 # nd_accept4 _____________________________________________________
116
117 probe nd_syscall.accept4 = nd1_syscall.accept4!, nd2_syscall.accept4!, tp_syscall.accept4
118 { }
119
120 probe nd1_syscall.accept4 = __nd1_syscall.accept4 ?,
121 __nd1_syscall.socketcall.accept4 ?,
122 __nd1_syscall.compat_socketcall.accept4 ?
123 {
124 @_SYSCALL_ACCEPT4_NAME
125 flags_str = _sock_flags_str(flags)
126 @_SYSCALL_ACCEPT4_ARGSTR
127 }
128 probe __nd1_syscall.accept4 = kprobe.function("sys_accept4").call
129 {
130 asmlinkage()
131 // On all tested platforms, there wasn't a different syscall
132 // number for the compat version of accept4().
133 @__syscall_nr_gate(@const("__NR_accept4"))
134 @_SYSCALL_ACCEPT4_REGARGS
135 }
136 probe __nd1_syscall.socketcall.accept4 = kprobe.function("sys_socketcall").call ?
137 {
138 asmlinkage()
139 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
140 @_SYSCALL_SOCKETCALL_ACCEPT4_REGARGS
141 }
142 probe __nd1_syscall.compat_socketcall.accept4 =
143 kprobe.function("compat_sys_socketcall").call ?
144 {
145 asmlinkage()
146 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
147 @_SYSCALL_COMPAT_SOCKETCALL_ACCEPT4_REGARGS
148 }
149
150 /* kernel 4.17+ */
151 probe nd2_syscall.accept4 = __nd2_syscall.accept4 ?,
152 __nd2_syscall.socketcall.accept4 ?,
153 __nd2_syscall.compat_socketcall.accept4 ?
154 {
155 @_SYSCALL_ACCEPT4_NAME
156 flags_str = _sock_flags_str(flags)
157 @_SYSCALL_ACCEPT4_ARGSTR
158 }
159 probe __nd2_syscall.accept4 = kprobe.function(@arch_syscall_prefix "sys_accept4").call
160 {
161 __set_syscall_pt_regs(pointer_arg(1))
162 @_SYSCALL_ACCEPT4_REGARGS
163 },
164 {
165 %( @_IS_SREG_KERNEL %? @_SYSCALL_ACCEPT4_REGARGS_STORE %)
166 }
167 probe __nd2_syscall.socketcall.accept4 = kprobe.function(@arch_syscall_prefix "sys_socketcall").call ?
168 {
169 __set_syscall_pt_regs(pointer_arg(1))
170 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
171 @_SYSCALL_SOCKETCALL_ACCEPT4_REGARGS
172 }
173 probe __nd2_syscall.compat_socketcall.accept4 =
174 kprobe.function(@arch_syscall_prefix "compat_sys_socketcall").call ?
175 {
176 __set_syscall_pt_regs(pointer_arg(1))
177 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
178 @_SYSCALL_COMPAT_SOCKETCALL_ACCEPT4_REGARGS
179 }
180
181 /* kernel 3.5+, but undesirable because it affects all syscalls */
182 probe tp_syscall.accept4 = __tp_syscall.accept4 ?,
183 __tp_syscall.socketcall.accept4 ?
184 {
185 @_SYSCALL_ACCEPT4_NAME
186 flags_str = _sock_flags_str(flags)
187 @_SYSCALL_ACCEPT4_ARGSTR
188 }
189 probe __tp_syscall.accept4 = kernel.trace("sys_enter")
190 {
191 __set_syscall_pt_regs($regs)
192 @__syscall_gate(@const("__NR_accept4"))
193 @_SYSCALL_ACCEPT4_REGARGS
194 },
195 {
196 %( @_IS_SREG_KERNEL %? @_SYSCALL_ACCEPT4_REGARGS_STORE %)
197 }
198 probe __tp_syscall.socketcall.accept4 = kernel.trace("sys_enter")
199 {
200 __set_syscall_pt_regs($regs)
201 @__syscall_compat_gate(@const("__NR_socketcall"), @const("__NR_compat_socketcall"))
202 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
203 if (@__compat_task) {
204 @_SYSCALL_COMPAT_SOCKETCALL_ACCEPT4_REGARGS
205 }
206 else {
207 @_SYSCALL_SOCKETCALL_ACCEPT4_REGARGS
208 }
209 }
210
211 probe nd_syscall.accept.return = nd1_syscall.accept.return!, nd2_syscall.accept.return!, tp_syscall.accept.return
212 { }
213
214 probe nd1_syscall.accept4.return = __nd1_syscall.accept4.return ?,
215 __nd1_syscall.socketcall.accept4.return ?
216 {
217 @_SYSCALL_ACCEPT4_NAME
218 @SYSC_RETVALSTR(returnval())
219 }
220 probe __nd1_syscall.accept4.return = kprobe.function("sys_accept4").return ?
221 {
222 @__syscall_nr_gate(@const("__NR_accept4"))
223 }
224 probe __nd1_syscall.socketcall.accept4.return =
225 kprobe.function("sys_socketcall").return ?,
226 kprobe.function("compat_sys_socketcall").return ?
227 {
228 if (@entry(__asmlinkage_int_arg(1)) != @const("SYS_ACCEPT4")) next;
229 }
230
231 /* kernel 4.17+ */
232 probe nd2_syscall.accept4.return =
233 kprobe.function(@arch_syscall_prefix "sys_accept4").return ?,
234 __nd2_syscall.socketcall.accept4.return ?
235 {
236 @_SYSCALL_ACCEPT4_NAME
237 @SYSC_RETVALSTR(returnval())
238 }
239 probe __nd2_syscall.socketcall.accept4.return =
240 kprobe.function(@arch_syscall_prefix "sys_socketcall").return ?,
241 kprobe.function(@arch_syscall_prefix "compat_sys_socketcall").return ?
242 {
243 __set_syscall_pt_regs(@entry(pointer_arg(1)))
244 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
245 }
246
247 /* kernel 3.5+, but undesirable because it affects all syscalls */
248 probe tp_syscall.accept4.return = __tp_syscall.accept4.return ?,
249 __tp_syscall.socketcall.accept4.return ?
250 {
251 @_SYSCALL_ACCEPT4_NAME
252 @SYSC_RETVALSTR($ret)
253 }
254 probe __tp_syscall.accept4.return = kernel.trace("sys_exit")
255 {
256 @__syscall_nr_gate(@const("__NR_accept4"))
257 }
258 probe __tp_syscall.accept4.return = kernel.trace("sys_exit")
259 {
260 __set_syscall_pt_regs($regs)
261 @__syscall_compat_gate(@const("__NR_socketcall"), @const("__NR_compat_socketcall"))
262 if (int_arg(1) != @const("SYS_ACCEPT4")) next;
263 }