Debian Codegraph @

tapset/linux/sysc_fadvise64.stp

raw
1 # fadvise64 __________________________________________________
2 # long sys_fadvise64(int fd, loff_t offset, size_t len, int advice)
3 #
4
5 @define _SYSCALL_FADVISE64_NAME
6 %(
7 name = "fadvise64"
8 %)
9
10 @define _SYSCALL_FADVISE64_ARGSTR
11 %(
12 argstr = sprintf("%d, %d, %d, %s", fd, offset, len, _fadvice_advice_str(advice))
13 %)
14
15 probe syscall.fadvise64 = dw_syscall.fadvise64 !, nd_syscall.fadvise64 ? {}
16 probe syscall.fadvise64.return = dw_syscall.fadvise64.return !, nd_syscall.fadvise64.return ? {}
17
18 # dw_fadvise64 _____________________________________________________
19
20 probe dw_syscall.fadvise64 = kernel.function("sys_fadvise64").call ?
21 {
22 @_SYSCALL_FADVISE64_NAME
23 @__syscall_gate_compat_simple
24 fd = __int32(@choose_defined($fd, 0))
25 offset = @choose_defined($offset, 0)
26 len = __long(@choose_defined($len, 0))
27 advice = __int32(@choose_defined($advice, 0))
28 advice_str = _fadvice_advice_str(advice)
29 @_SYSCALL_FADVISE64_ARGSTR
30 }
31 probe dw_syscall.fadvise64.return = kernel.function("sys_fadvise64").return ?
32 {
33 @__syscall_gate_compat_simple
34 @_SYSCALL_FADVISE64_NAME
35 @SYSC_RETVALSTR($return)
36 }
37
38 # nd_fadvise64 _____________________________________________________
39
40 probe nd_syscall.fadvise64 = nd1_syscall.fadvise64!, nd2_syscall.fadvise64!, tp_syscall.fadvise64
41 { }
42
43 probe nd1_syscall.fadvise64 = kprobe.function("sys_fadvise64") ?
44 {
45 asmlinkage()
46 @__syscall_gate_compat_simple
47 @_SYSCALL_FADVISE64_NAME
48 fd = int_arg(1)
49 %( CONFIG_64BIT == "y" %?
50 offset = longlong_arg(2)
51 len = long_arg(3)
52 advice = int_arg(4)
53 %:
54 # On a 32-bit kernel, 'long long' arguments take the space of
55 # 2 arguments, so we have to adjust the following argument
56 # numbers.
57 offset = longlong_arg(2)
58 len = long_arg(4)
59 advice = int_arg(5)
60 %)
61 advice_str = _fadvice_advice_str(advice)
62 @_SYSCALL_FADVISE64_ARGSTR
63 }
64
65 /* kernel 4.17+ */
66 probe nd2_syscall.fadvise64 = kprobe.function(@arch_syscall_prefix "sys_fadvise64") ?
67 {
68 __set_syscall_pt_regs(pointer_arg(1))
69 @_SYSCALL_FADVISE64_NAME
70 fd = int_arg(1)
71 offset = longlong_arg(2)
72 len = long_arg(3)
73 advice = int_arg(4)
74 advice_str = _fadvice_advice_str(advice)
75 @_SYSCALL_FADVISE64_ARGSTR
76 },
77 {
78 %( @_IS_SREG_KERNEL %?
79 if (@probewrite(fd))
80 set_int_arg(1, fd)
81
82 if (@probewrite(offset))
83 set_longlong_arg(2, offset)
84
85 if (@probewrite(len))
86 set_long_arg(3, len)
87
88 if (@probewrite(advice))
89 set_int_arg(4, advice)
90 %)
91 }
92
93 /* kernel 3.5+, but undesirable because it affects all syscalls */
94 probe tp_syscall.fadvise64 = kernel.trace("sys_enter")
95 {
96 __set_syscall_pt_regs($regs)
97 @__syscall_gate(@const("__NR_fadvise64"))
98 @_SYSCALL_FADVISE64_NAME
99 fd = int_arg(1)
100 %( CONFIG_64BIT == "y" %?
101 offset = longlong_arg(2)
102 len = long_arg(3)
103 advice = int_arg(4)
104 %:
105 # On a 32-bit kernel, 'long long' arguments take the space of
106 # 2 arguments, so we have to adjust the following argument
107 # numbers.
108 offset = longlong_arg(2)
109 len = long_arg(4)
110 advice = int_arg(5)
111 %)
112 advice_str = _fadvice_advice_str(advice)
113 @_SYSCALL_FADVISE64_ARGSTR
114 },
115 {
116 %( @_IS_SREG_KERNEL %?
117 if (@probewrite(fd))
118 set_int_arg(1, fd)
119
120 if (@probewrite(offset))
121 set_longlong_arg(2, offset)
122
123 %( CONFIG_64BIT == "y" %?
124 if (@probewrite(len))
125 set_long_arg(3, len)
126
127 if (@probewrite(advice))
128 set_int_arg(4, advice)
129 %:
130 if (@probewrite(len))
131 set_long_arg(4, len)
132
133 if (@probewrite(advice))
134 set_int_arg(5, advice)
135 %)
136 %)
137 }
138
139 probe nd_syscall.fadvise64.return = nd1_syscall.fadvise64.return!, nd2_syscall.fadvise64.return!, tp_syscall.fadvise64.return
140 { }
141
142 probe nd1_syscall.fadvise64.return = kprobe.function("sys_fadvise64").return ?
143 {
144 @__syscall_gate_compat_simple
145 @_SYSCALL_FADVISE64_NAME
146 @SYSC_RETVALSTR(returnval())
147 }
148
149 /* kernel 4.17+ */
150 probe nd2_syscall.fadvise64.return = kprobe.function(@arch_syscall_prefix "sys_fadvise64").return ?
151 {
152 @_SYSCALL_FADVISE64_NAME
153 @SYSC_RETVALSTR(returnval())
154 }
155
156 /* kernel 3.5+, but undesirable because it affects all syscalls */
157 probe tp_syscall.fadvise64.return = kernel.trace("sys_exit")
158 {
159 __set_syscall_pt_regs($regs)
160 @__syscall_gate(@const("__NR_fadvise64"))
161 @_SYSCALL_FADVISE64_NAME
162 @SYSC_RETVALSTR($ret)
163 }
164
165 # fadvise64_64 _______________________________________________
166 # long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
167 #
168
169 probe syscall.fadvise64_64 = dw_syscall.fadvise64_64 !, nd_syscall.fadvise64_64 ? {}
170 probe syscall.fadvise64_64.return = dw_syscall.fadvise64_64.return !, nd_syscall.fadvise64_64.return ? {}
171
172 # dw_fadvise64_64 _____________________________________________________
173
174 probe dw_syscall.fadvise64_64 = kernel.function("sys_fadvise64_64").call ?
175 {
176 @__syscall_gate_compat_simple
177 %( arch != "s390" && arch != "ia64" && arch != "arm" && arch != "arm64" %?
178 # s390x/ia64/arm/arm64 has sys_fadvise64_64() mapped to
179 # __NR_fadvise64 (instead of __NR_fadvise64_64)
180 @__syscall_gate(@const("__NR_fadvise64_64"))
181 %)
182 @_SYSCALL_FADVISE64_NAME
183 fd = __int32(@choose_defined($fd, 0))
184 offset = @choose_defined($offset, 0)
185 len = @choose_defined($len, 0)
186 advice = __int32(@choose_defined($advice, 0))
187 advice_str = _fadvice_advice_str(advice)
188 @_SYSCALL_FADVISE64_ARGSTR
189 }
190 probe dw_syscall.fadvise64_64.return =
191 kernel.function("sys_fadvise64_64").return ?
192 {
193 @__syscall_gate_compat_simple
194 %( arch != "s390" && arch != "ia64" && arch != "arm" && arch != "arm64" %?
195 @__syscall_gate(@const("__NR_fadvise64_64"))
196 %)
197 @_SYSCALL_FADVISE64_NAME
198 # sys_fadvise64_64 appears to miss dwarf on kernels such as 4.3.0-0.rc3.git4.1.fc24.x86_64
199 # and symbol-table-based .return probes don't resolve $return
200 if (@defined($return)) {
201 @SYSC_RETVALSTR($return)
202 } else {
203 @SYSC_RETVALSTR(returnval())
204 }
205 }
206
207 # nd_fadvise64_64 _____________________________________________________
208
209 probe nd_syscall.fadvise64_64 = nd1_syscall.fadvise64_64!, tp_syscall.fadvise64_64
210 { }
211
212 probe nd1_syscall.fadvise64_64 = kprobe.function("sys_fadvise64_64") ?
213 {
214 asmlinkage()
215 @__syscall_gate_compat_simple
216 %( arch != "s390" && arch != "ia64" && arch != "arm" && arch != "arm64" %?
217 # s390x/ia64/arm/arm64 has sys_fadvise64_64() mapped to
218 # __NR_fadvise64 (instead of __NR_fadvise64_64)
219 @__syscall_gate(@const("__NR_fadvise64_64"))
220 %)
221 @_SYSCALL_FADVISE64_NAME
222 fd = int_arg(1)
223 %( CONFIG_64BIT == "y" %?
224 offset = longlong_arg(2)
225 len = longlong_arg(3)
226 advice = int_arg(4)
227 %:
228 %( arch == "arm" %?
229 # arm has some odd rules regarding long long arguments.
230 offset = longlong_arg(3)
231 len = longlong_arg(5)
232 advice = int_arg(7)
233 %:
234 # On a 32-bit kernel, 'long long' arguments take the space of
235 # 2 arguments, so we have to adjust the following argument
236 # numbers.
237 offset = longlong_arg(2)
238 len = longlong_arg(4)
239 advice = int_arg(6)
240 %)
241 %)
242 advice_str = _fadvice_advice_str(advice)
243 @_SYSCALL_FADVISE64_ARGSTR
244 }
245
246 /* kernel 3.5+, but undesirable because it affects all syscalls */
247 probe tp_syscall.fadvise64_64 = kernel.trace("sys_enter")
248 {
249 __set_syscall_pt_regs($regs)
250 @__syscall_gate(@const("__NR_fadvise64_64"))
251 @_SYSCALL_FADVISE64_NAME
252 fd = int_arg(1)
253 %( CONFIG_64BIT == "y" %?
254 offset = longlong_arg(2)
255 len = longlong_arg(3)
256 advice = int_arg(4)
257 %:
258 %( arch == "arm" %?
259 # arm has some odd rules regarding long long arguments.
260 offset = longlong_arg(3)
261 len = longlong_arg(5)
262 advice = int_arg(7)
263 %:
264 # On a 32-bit kernel, 'long long' arguments take the space of
265 # 2 arguments, so we have to adjust the following argument
266 # numbers.
267 offset = longlong_arg(2)
268 len = longlong_arg(4)
269 advice = int_arg(6)
270 %)
271 %)
272 advice_str = _fadvice_advice_str(advice)
273 @_SYSCALL_FADVISE64_ARGSTR
274 },
275 {
276 %( @_IS_SREG_KERNEL %?
277 if (@probewrite(fd))
278 set_int_arg(1, fd)
279
280 %( CONFIG_64BIT == "y" %?
281 if (@probewrite(offset))
282 set_longlong_arg(2, offset)
283
284 if (@probewrite(len))
285 set_longlong_arg(3, len)
286
287 if (@probewrite(advice))
288 set_int_arg(4, advice)
289 %:
290 if (@probewrite(offset))
291 set_longlong_arg(2, offset)
292
293 if (@probewrite(len))
294 set_longlong_arg(4, len)
295
296 if (@probewrite(advice))
297 set_int_arg(6, advice)
298 %)
299 %)
300 }
301
302 probe nd_syscall.fadvise64_64.return = nd1_syscall.fadvise64_64.return!, tp_syscall.fadvise64_64.return
303 { }
304
305 probe nd1_syscall.fadvise64_64.return =
306 kprobe.function("sys_fadvise64_64").return ?
307 {
308 @__syscall_gate_compat_simple
309 %( arch != "s390" && arch != "ia64" && arch != "arm" && arch != "arm64" %?
310 @__syscall_gate(@const("__NR_fadvise64_64"))
311 %)
312 @_SYSCALL_FADVISE64_NAME
313 @SYSC_RETVALSTR(returnval())
314 }
315
316 /* kernel 3.5+, but undesirable because it affects all syscalls */
317 probe tp_syscall.fadvise64_64.return = kernel.trace("sys_exit")
318 {
319 __set_syscall_pt_regs($regs)
320 @__syscall_gate(@const("__NR_fadvise64_64"))
321 @_SYSCALL_FADVISE64_NAME
322 @SYSC_RETVALSTR($ret)
323 }