Debian Codegraph @

tapset/linux/vfs.stp

raw
1 // vfs tapset
2 // Copyright (C) 2006-2007 IBM Corp.
3 // Copyright (C) 2007 Intel Corporation.
4 // Copyright (C) 2007 Bull S.A.S
5 // Copyright (c) 2008-2015 Red Hat Inc.
6 //
7 // This file is part of systemtap, and is free software. You can
8 // redistribute it and/or modify it under the terms of the GNU General
9 // Public License (GPL); either version 2, or (at your option) any
10 // later version.
11
12 %{
13 #include <linux/uaccess.h> /* For VERIFY_READ/VERIFY_WRITE */
14 #include <linux/uio.h> /* For ITER_IOVEC */
15 #include <linux/types.h> /* For struct list_head */
16 #include <linux/mm_types.h> /* For struct page */
17
18 /* Define our own page size macro. */
19 #ifdef PAGE_CACHE_SIZE
20 #define _STP_PAGE_SIZE PAGE_CACHE_SIZE
21 #else
22 #define _STP_PAGE_SIZE PAGE_SIZE
23 #endif
24 %}
25
26 /* generic vfs probes */
27 /*
28 We don't want to have to do a bdevname() call every time
29 we want a devname, so we'll hash them here.
30 */
31 function __find_bdevname:string(dev:long, bdev:long)
32 {
33 /* bdevname() can't do anything without an actual bdev, so let's just
34 * return the same result early without wasting space in __devnames. */
35 if (bdev == 0)
36 return "N/A"
37
38 return bdevname(bdev)
39 }
40
41 %(systemtap_v < "2.3" %?
42 /* deprecated */
43 function ppos_pos:long (ppos:long)
44 {
45 return kernel_pointer(ppos)
46 }
47 %)
48
49 @__private30 function __address_inode:long (page:long)
50 {
51 mapping = page? @cast(page, "page", "kernel")->mapping : 0
52 if (mapping == 0)
53 return -1
54 else
55 return @cast(mapping, "address_space", "kernel")->host
56 }
57
58 function __page_ino:long (page:long)
59 {
60 host = __address_inode(page)
61 if (host == -1)
62 return -1
63 else
64 return @cast(host, "inode", "kernel")->i_ino
65 }
66
67 function __page_dev:long (page:long)
68 {
69 host = __address_inode(page)
70 if (host == -1)
71 return -1
72 return @cast(host, "inode", "kernel")->i_sb->s_dev
73 }
74
75 function __page_bdev:long (page:long)
76 {
77 host = __address_inode(page)
78 if (host == -1)
79 return 0
80 return @cast(host, "inode", "kernel")->i_sb->s_bdev
81 }
82
83 @__private30 function __page_index:long (page:long)
84 {
85 return @cast(page, "page", "kernel")->index
86 }
87
88 function __file_dev:long (file:long)
89 {
90 d_inode = __file_inode(file)
91 if (d_inode == 0)
92 return 0
93 return @cast(d_inode, "inode", "kernel")->i_sb->s_dev
94 }
95
96 @__private30 function __file_bdev:long (file:long)
97 {
98 d_inode = __file_inode(file)
99 if (d_inode == 0)
100 return 0
101 return @cast(d_inode, "inode", "kernel")->i_sb->s_bdev
102 }
103
104 function __file_ino:long (file:long)
105 {
106 d_inode = __file_inode(file)
107 if (d_inode == 0)
108 return 0
109 return @cast(d_inode, "inode", "kernel")->i_ino
110 }
111
112 function __file_maxbytes:long (file:long)
113 {
114 d_inode = __file_inode(file)
115 if (d_inode == 0)
116 return 0
117 return @cast(d_inode, "inode", "kernel")->i_sb->s_maxbytes
118 }
119
120 function __file_filename:string (file:long)
121 {
122 dentry = file
123 ? @choose_defined(@cast(file, "file", "kernel")->f_path->dentry,
124 @cast(file, "file", "kernel")->f_dentry)
125 : 0
126 name = dentry? @cast(dentry, "dentry", "kernel")->d_name->name : 0
127 if (name == 0)
128 return "NULL"
129 else
130 return kernel_string(name)
131 }
132
133 @__private30 function _get_fopv_size:long (iovp:long, nr_segs:long)
134 {
135 if (iovp) {
136 val = 0
137 for (i = 0; i < nr_segs; i++)
138 val += @cast(iovp, "iovec")[i]->iov_len
139 return val
140 }
141 return -1
142 }
143
144 %(systemtap_v < "2.3" %?
145 /* deprecated */
146 function _dev_minor:long (dev:long)
147 {
148 return MINOR(dev)
149 }
150
151 /* deprecated */
152 function _dev_major:long (dev:long)
153 {
154 return MAJOR(dev)
155 }
156 %)
157
158 @__private30 function __get_first_page:long (pages:long)
159 %{ /* pure */
160 struct list_head *pages = (struct list_head *)(uintptr_t)STAP_ARG_pages;
161
162 /* We call kderef_buffer() here to ensure the memory is valid
163 * to read. Note the result is thrown away, then we use the
164 * "real" list_entry() function now that we know the address
165 * is safe. */
166 (void)kderef_buffer(NULL, pages, sizeof(*pages));
167 STAP_RETVALUE = (uintptr_t)list_entry(pages->prev, struct page, lru);
168 CATCH_DEREF_FAULT();
169 %}
170
171 probe generic.fop.llseek = kernel.function("generic_file_llseek")
172 {
173 dev = __file_dev($file)
174 devname = __find_bdevname(dev, __file_bdev($file))
175 ino = __file_ino($file)
176 file = $file
177 pathname = fullpath_struct_file(task_current(), $file)
178
179 offset = $offset
180 %(systemtap_v < "2.3" %?
181 origin = @choose_defined($whence, $origin)
182 %)
183 whence = @choose_defined($whence, $origin)
184 whence_str = _seek_whence_str(@choose_defined($whence, $origin))
185
186 maxbyte = __file_maxbytes($file)
187
188 name = "generic_file_llseek"
189 argstr = sprintf("%d, %d", $offset, @choose_defined($whence, $origin))
190 }
191 probe generic.fop.llseek.return = kernel.function("generic_file_llseek").return
192 {
193 name = "generic_file_llseek"
194 retstr = sprintf("%d", $return)
195 file = @entry($file)
196 pathname = fullpath_struct_file(task_current(), @entry($file))
197 offset = @entry($offset)
198 %(systemtap_v < "2.3" %?
199 origin = @entry(@choose_defined($whence, $origin))
200 %)
201 whence = @entry(@choose_defined($whence, $origin))
202 whence_str = @entry(_seek_whence_str(@choose_defined($whence, $origin)))
203
204 error = $return < 0 ? $return : 0
205 error_str = error ? errno_str(error) : ""
206 }
207
208 probe generic.fop.aio_read =
209 kernel.function("__generic_file_aio_read") !,
210 kernel.function("generic_file_aio_read") ?
211 {
212 file = $iocb->ki_filp
213 pathname = fullpath_struct_file(task_current(), $iocb->ki_filp)
214 dev = __file_dev($iocb->ki_filp)
215 devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
216 ino = __file_ino($iocb->ki_filp)
217
218 pos = @choose_defined($pos, kernel_pointer($ppos))
219 buf = $iov->iov_base
220 count = __iov_length($iov, $nr_segs, 1, @const("VERIFY_WRITE"))
221 name = "generic_file_aio_read"
222 argstr = sprintf("%d, %d, %p", count, pos, buf)
223
224 size = count
225 units = "bytes"
226 }
227 probe generic.fop.aio_read.return =
228 kernel.function("__generic_file_aio_read").return !,
229 kernel.function("generic_file_aio_read").return ?
230 {
231 file = @entry($iocb->ki_filp)
232 pathname = fullpath_struct_file(task_current(), @entry($iocb->ki_filp))
233 nr_segs = @entry($nr_segs)
234 name = "generic_file_aio_read"
235 retstr = sprintf("%d", $return)
236
237 bytes_read = $return > 0 ? $return : 0
238 error = $return < 0 ? $return : 0
239 error_str = error ? errno_str(error) : ""
240
241 if ($return > 0) {
242 size = $return
243 units = "bytes"
244 }
245 }
246
247 probe generic.fop.read_iter = kernel.function("generic_file_read_iter") ?
248 {
249 file = $iocb->ki_filp
250 pathname = fullpath_struct_file(task_current(), $iocb->ki_filp)
251 dev = __file_dev($iocb->ki_filp)
252 devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
253 ino = __file_ino($iocb->ki_filp)
254
255 pos = $iter->iov_offset
256 if ($iter->type & @const("ITER_IOVEC")) {
257 buf = $iter->iov->iov_base
258 count = __iov_length($iter->iov, $iter->nr_segs, 1,
259 @const("VERIFY_WRITE"))
260 }
261 else {
262 buf = 0
263 count = 0
264 }
265
266 name = "generic_file_read_iter"
267 argstr = sprintf("%d, %d, %p", count, pos, buf)
268
269 size = count
270 units = "bytes"
271 }
272 probe generic.fop.read_iter.return =
273 kernel.function("generic_file_read_iter").return ?
274 {
275 file = @entry($iocb->ki_filp)
276 pathname = fullpath_struct_file(task_current(), @entry($iocb->ki_filp))
277 nr_segs = @entry($iter->nr_segs)
278 name = "generic_file_read_iter"
279 retstr = sprintf("%d", $return)
280
281 bytes_read = $return > 0 ? $return : 0
282 error = $return < 0 ? $return : 0
283 error_str = error ? errno_str(error) : ""
284
285 if ($return > 0) {
286 size = $return
287 units = "bytes"
288 }
289 }
290
291 probe generic.fop.aio_write = kernel.function("generic_file_aio_write") ?
292 {
293 file = $iocb->ki_filp
294 pathname = fullpath_struct_file(task_current(), $iocb->ki_filp)
295 dev = __file_dev($iocb->ki_filp)
296 devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
297 ino = __file_ino($iocb->ki_filp)
298
299 pos = $pos
300
301 count = (@defined($iov)
302 ? __iov_length($iov, $nr_segs, 1, @const("VERIFY_READ"))
303 : $count)
304 buf = @choose_defined($iov->iov_base, $buf)
305 name = "generic_file_aio_write"
306 argstr = sprintf("%d, %d, %p", count, pos, buf)
307
308 size = count
309 units = "bytes"
310 }
311 probe generic.fop.aio_write.return =
312 kernel.function("generic_file_aio_write").return ?
313 {
314 file = @entry($iocb->ki_filp)
315 pathname = fullpath_struct_file(task_current(), @entry($iocb->ki_filp))
316 name = "generic_file_aio_write"
317 retstr = sprintf("%d", $return)
318
319 if ($return > 0) {
320 size = $return
321 units = "bytes"
322 }
323 }
324
325 probe generic.fop.write_iter = kernel.function("generic_file_write_iter") ?
326 {
327 file = $iocb->ki_filp
328 pathname = fullpath_struct_file(task_current(), $iocb->ki_filp)
329 dev = __file_dev($iocb->ki_filp)
330 devname = __find_bdevname(dev, __file_bdev($iocb->ki_filp))
331 ino = __file_ino($iocb->ki_filp)
332
333 pos = $from->iov_offset
334 if ($from->type & @const("ITER_IOVEC")) {
335 buf = $from->iov->iov_base
336 count = __iov_length($from->iov, $from->nr_segs, 1,
337 @const("VERIFY_READ"))
338 }
339 else {
340 buf = 0
341 count = 0
342 }
343
344 name = "generic_file_write_iter"
345 argstr = sprintf("%d, %d, %p", count, pos, buf)
346
347 size = count
348 units = "bytes"
349 }
350 probe generic.fop.write_iter.return =
351 kernel.function("generic_file_write_iter").return ?
352 {
353 file = @entry($iocb->ki_filp)
354 pathname = fullpath_struct_file(task_current(), @entry($iocb->ki_filp))
355 name = "generic_file_write_iter"
356 retstr = sprintf("%d", $return)
357
358 if ($return > 0) {
359 size = $return
360 units = "bytes"
361 }
362 }
363
364 probe generic.fop.readv = kernel.function("generic_file_readv") ?
365 {
366 dev = __file_dev($filp)
367 devname = __find_bdevname(dev, __file_bdev($filp))
368 ino = __file_ino($filp)
369 file = $filp
370 pathname = fullpath_struct_file(task_current(), $filp)
371
372 nr_segs = $nr_segs
373 pos = kernel_pointer($ppos)
374
375 name = "generic_file_readv"
376 argstr = sprintf("%d, %d", $nr_segs, pos)
377
378 size = nr_segs
379 units = "segs"
380 }
381 probe generic.fop.readv.return = kernel.function("generic_file_readv").return ?
382 {
383 file = @entry($filp)
384 pathname = fullpath_struct_file(task_current(), @entry($filp))
385 name = "generic_file_readv"
386 retstr = sprintf("%d", $return)
387
388 bytes_read = $return > 0 ? $return : 0
389 error = $return < 0 ? $return : 0
390 error_str = error ? errno_str(error) : ""
391
392 if ($return > 0) {
393 size = $return
394 units = "bytes"
395 }
396 }
397
398 /* calls __generic_file_write_nolock */
399 probe generic.fop.writev = kernel.function("generic_file_writev") ?
400 {
401 dev = __file_dev($file)
402 devname = __find_bdevname(dev, __file_bdev($file))
403 ino = __file_ino($file)
404 file = $file
405 pathname = fullpath_struct_file(task_current(), $file)
406
407 nr_segs = $nr_segs
408 pos = kernel_pointer($ppos)
409
410 name = "generic_file_writev"
411 argstr = sprintf("%d, %d", $nr_segs, pos)
412
413 size = nr_segs
414 units = "segs"
415 }
416 probe generic.fop.writev.return =
417 kernel.function("generic_file_writev").return ?
418 {
419 file = @entry($file)
420 pathname = fullpath_struct_file(task_current(), @entry($file))
421 name = "generic_file_writev"
422 retstr = sprintf("%d", $return)
423
424 bytes_written = $return > 0 ? $return : 0
425 error = $return < 0 ? $return : 0
426 error_str = error ? errno_str(error) : ""
427
428 if ($return > 0) {
429 size = $return
430 units = "bytes"
431 }
432 }
433
434 /* checks for aops->readpage, if not defined, return -ENOEXEC
435 else assigns generic_file_vm_ops to vma
436 add filemap_nopage, filemap_populate */
437 probe generic.fop.mmap = kernel.function("generic_file_mmap")
438 {
439 file = $file
440 pathname = fullpath_struct_file(task_current(), $file)
441 dev = __file_dev($file)
442 devname = __find_bdevname(dev, __file_bdev($file))
443 ino = __file_ino($file)
444
445 vm_start = $vma->vm_start
446 vm_end = $vma->vm_end
447 vm_flags = $vma->vm_flags
448
449 name = "generic_file_mmap"
450 argstr = sprintf("0x%x, 0x%x, 0x%x", $vma->vm_start,
451 $vma->vm_end, $vma->vm_flags)
452 }
453 probe generic.fop.mmap.return = kernel.function("generic_file_mmap").return
454 {
455 file = @entry($file)
456 pathname = fullpath_struct_file(task_current(), @entry($file))
457 name = "generic_file_mmap"
458 retstr = sprintf("%d", $return)
459
460 error = $return < 0 ? $return : 0
461 error_str = error ? errno_str(error) : ""
462 }
463
464 probe generic.fop.open = kernel.function("generic_file_open")
465 {
466 dev = __file_dev($filp)
467 devname = __find_bdevname(dev, __file_bdev($filp))
468 ino = $inode->i_ino
469 file = $filp
470 filename = __file_filename($filp)
471 pathname = fullpath_struct_file(task_current(), $filp)
472
473 flag = $filp->f_flags
474 size = $inode->i_size
475
476 name = "generic_file_open"
477 argstr = sprintf("%d, %d, %s", $inode->i_ino, $filp->f_flags, filename)
478 }
479 probe generic.fop.open.return = kernel.function("generic_file_open").return
480 {
481 name = "generic_file_open"
482 retstr = sprintf("%d", $return)
483 }
484
485 probe generic.fop.sendfile = kernel.function("generic_file_sendfile") ?
486 {
487 dev = __file_dev($in_file)
488 devname = __find_bdevname($in_file, __file_bdev($in_file))
489 ino = __file_ino($in_file)
490 file = $in_file
491 pathname = fullpath_struct_file(task_current(), $in_file)
492
493 count = $count
494 ppos = $ppos
495
496 name = "generic_file_sendfile"
497 argstr = sprintf("%d", $count)
498
499 size = $count
500 units = "bytes"
501 }
502 probe generic.fop.sendfile.return =
503 kernel.function("generic_file_sendfile").return ?
504 {
505 name = "generic_file_sendfile"
506 retstr = sprintf("%d", $return)
507
508 if ($return > 0) {
509 size = $return
510 units = "bytes"
511 }
512 }
513
514 probe generic.fop.splice_read = kernel.function("generic_file_splice_read") ?
515 {
516 dev = __file_dev($in)
517 devname = __find_bdevname(dev, __file_bdev($in))
518 ino = __file_ino($in)
519 file = $in
520 pathname = fullpath_struct_file(task_current(), $in)
521 dev_major = MAJOR(dev)
522 dev_minor = MINOR(dev)
523
524 len = $len
525 flags = $flags
526
527 name = "generic_file_splice_read"
528 argstr = sprintf("%d, %x", $len, $flags)
529
530 size = $len
531 units = "bytes"
532 }
533 probe generic.fop.splice_read.return =
534 kernel.function("generic_file_splice_read").return ?
535 {
536 name = "generic_file_splice_read"
537 retstr = sprintf("%d", $return)
538 file = @entry($in)
539 pathname = fullpath_struct_file(task_current(), @entry($in))
540 ino = __file_ino(@entry($in))
541 dev = __file_dev(@entry($in))
542 dev_major = MAJOR(dev)
543 dev_minor = MINOR(dev)
544
545 ret = $return
546 error = $return < 0 ? $return : 0
547 error_str = error ? errno_str(error) : ""
548
549 if ($return > 0) {
550 size = $return
551 units = "bytes"
552 }
553 }
554
555 probe generic.fop.splice_write = kernel.function("generic_file_splice_write") ?
556 {
557 dev = __file_dev($out)
558 devname = __find_bdevname(dev, __file_bdev($out))
559 ino = __file_ino($out)
560 file = $out
561 pathname = fullpath_struct_file(task_current(), $out)
562
563 len = $len
564 flags = $flags
565
566 name = "generic_file_splice_write"
567 argstr = sprintf("%d, %x", $len, $flags)
568
569 size = $len
570 units = "bytes"
571 }
572 probe generic.fop.splice_write.return =
573 kernel.function("generic_file_splice_write").return ?
574 {
575 name = "generic_file_splice_write"
576 retstr = sprintf("%d", $return)
577
578 file = @entry($out)
579 pathname = fullpath_struct_file(task_current(), @entry($out))
580
581 error = $return < 0 ? $return : 0
582 error_str = error ? errno_str(error) : ""
583
584 if (error) {
585 size = $return
586 units = "bytes"
587 }
588 }
589
590 probe generic.fop.read = kernel.function("generic_file_read") ?
591 {
592 dev = __file_dev($filp)
593 devname = __find_bdevname(dev, __file_bdev($filp))
594 ino = __file_ino($filp)
595 file = $filp
596 pathname = fullpath_struct_file(task_current(), $filp)
597
598 count = $count
599
600 name = "generic_file_read"
601 argstr = sprintf("%d", $count)
602
603 size = $count
604 units = "bytes"
605 }
606 probe generic.fop.read.return = kernel.function("generic_file_read").return ?
607 {
608 name = "generic_file_read"
609 retstr = sprintf("%d", $return)
610
611 if ($return > 0) {
612 size = $return
613 units = "bytes"
614 }
615 }
616
617 probe generic.fop.write = kernel.function("generic_file_write") ?
618 {
619 dev = __file_dev($file)
620 devname = __find_bdevname(dev, __file_bdev($file))
621 ino = __file_ino($file)
622 file = $file
623 pathname = fullpath_struct_file(task_current(), $file)
624
625 count = $count
626
627 name = "generic_file_write"
628 argstr = sprintf("%d", $count)
629
630 size = $count
631 units = "bytes"
632 }
633 probe generic.fop.write.return = kernel.function("generic_file_write").return ?
634 {
635 name = "generic_file_write"
636 retstr = sprintf("%d", $return)
637
638 if ($return > 0) {
639 size = $return
640 units = "bytes"
641 }
642 }
643
644 /* generic_writepages calls mpage_writepages(mapping, wbc, NULL) */
645 probe generic.aop.writepages = kernel.function("mpage_writepages")
646 {
647 dev = $mapping->host->i_sb->s_dev
648 devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
649 ino = $mapping->host->i_ino
650
651 nr_to_write = $wbc->nr_to_write
652
653 name = "generic_writepages"
654 argstr = sprintf("%d", $wbc->nr_to_write)
655
656 size = $wbc->nr_to_write
657 units = "pages"
658 }
659 probe generic.aop.writepages.return = kernel.function("mpage_writepages").return
660 {
661 name = "generic_writepages"
662 retstr = sprintf("%d", $return)
663 }
664
665 probe vfs.do_sync_read = kernel.function("do_sync_read") !,
666 __vfs.__vfs_read
667 {
668 dev = __file_dev(@choose_defined($filp, $file))
669 devname = __find_bdevname(dev,
670 __file_bdev(@choose_defined($filp, $file)))
671 ino = __file_ino(@choose_defined($filp, $file))
672 file = @choose_defined($filp, $file)
673 pathname = @defined($filp) ? fullpath_struct_file(task_current(), $filp) : fullpath_struct_file(task_current(), $file)
674
675 len = @choose_defined($len, $count)
676 pos = kernel_pointer(@choose_defined($ppos, $pos))
677 buf = $buf
678
679 name = "do_sync_read"
680 argstr = sprintf("%d, %d, %p", @choose_defined($len, $count),
681 pos, $buf)
682
683 size = @choose_defined($len, $count)
684 units = "bytes"
685 bytes_to_read = @choose_defined($len, $count)
686 }
687 # We'd really like to probe new_sync_read() here, but it is typically
688 # inlined. So, we'll probe its caller, __vfs_read().
689 probe __vfs.__vfs_read = kernel.function("__vfs_read")!, kernel.function("vfs_read")
690 {
691 # Skip the call if new_sync_read() wouldn't be called.
692 if ($file->f_op->read || !$file->f_op->read_iter) next
693 }
694 probe vfs.do_sync_read.return = kernel.function("do_sync_read").return !,
695 __vfs.__vfs_read.return
696 {
697 name = "do_sync_read"
698 retstr = sprintf("%d", $return)
699
700 bytes_to_read = @entry(@choose_defined($len, $count))
701 ret = $return
702 bytes_read = $return > 0 ? $return : 0
703 error = $return < 0 ? $return : 0
704 error_str = error ? errno_str(error) : ""
705
706 if ($return > 0) {
707 size = $return
708 units = "bytes"
709 }
710 }
711 probe __vfs.__vfs_read.return = kernel.function("__vfs_read").return! , kernel.function("vfs_read").return
712 {
713 # Skip the call if new_sync_read() wouldn't be called.
714 if (@entry($file->f_op->read) || !@entry($file->f_op->read_iter)) next
715 }
716
717 probe vfs.do_sync_write = kernel.function("do_sync_write") !,
718 __vfs.__vfs_write
719 {
720 dev = __file_dev(@choose_defined($filp, $file))
721 devname = __find_bdevname(dev,
722 __file_bdev(@choose_defined($filp, $file)))
723 ino = __file_ino(@choose_defined($filp, $file))
724 file = @choose_defined($filp, $file)
725 pathname = @defined($filp) ? fullpath_struct_file(task_current(), $filp) : fullpath_struct_file(task_current(), $file)
726
727 len = @choose_defined($len, $count)
728 pos = kernel_pointer(@choose_defined($ppos, $pos))
729 buf = @choose_defined($buf, $p)
730 bytes_to_write = @choose_defined($len, $count)
731
732 name = "do_sync_write"
733 argstr = sprintf("%d, %d , %p", @choose_defined($len, $count),
734 pos, @choose_defined($buf, $p))
735
736 size = @choose_defined($len, $count)
737 units = "bytes"
738 }
739 # We'd really like to probe new_sync_read() here, but it is typically
740 # inlined. So, we'll probe its caller, __vfs_write().
741 probe __vfs.__vfs_write = kernel.function("__vfs_write")!, kernel.function("vfs_write")
742 {
743 # Skip the call if new_sync_write() wouldn't be called.
744 if ($file->f_op->write || !$file->f_op->write_iter) next
745 }
746 probe vfs.do_sync_write.return = kernel.function("do_sync_write").return !,
747 __vfs.__vfs_write.return
748 {
749 name = "do_sync_write"
750 retstr = sprintf("%d", $return)
751
752 bytes_to_write = @entry(@choose_defined($len, $count))
753 pos = kernel_pointer(@entry(@choose_defined($ppos, $pos)))
754 ret = $return
755 bytes_written = $return > 0 ? $return : 0
756 error = $return < 0 ? $return : 0
757 error_str = error ? errno_str(error) : ""
758
759 if (error) {
760 size = $return
761 units = "bytes"
762 }
763 }
764 probe __vfs.__vfs_write.return = kernel.function("__vfs_write").return!, kernel.function("vfs_write").return
765 {
766 # Skip the call if new_sync_write() wouldn't be called.
767 if (@entry($file->f_op->write) || !@entry($file->f_op->write_iter)) next
768 }
769
770 probe vfs.block_sync_page = kernel.function("block_sync_page") ?
771 {
772 dev = __page_dev($page)
773 devname = __find_bdevname(dev, __page_bdev($page))
774 ino = __page_ino($page)
775
776 %(systemtap_v < "2.3" %?
777 # 'page_index' is deprecated
778 page_index = __page_index($page)
779 %)
780 index = __page_index($page)
781
782 name = "block_sync_page"
783 argstr = sprintf("%d", index)
784
785 size = 1
786 units = "pages"
787 }
788 probe vfs.block_sync_page.return = kernel.function("block_sync_page").return ?
789 {
790 name = "block_sync_page"
791 retstr = sprintf("N/A")
792 }
793
794 probe vfs.buffer_migrate_page = kernel.function("buffer_migrate_page") ?
795 {
796 dev = __page_dev($page)
797 ino = __page_ino($page)
798 devname = __find_bdevname(dev,__page_bdev($page))
799
800 %(systemtap_v < "2.3" %?
801 # 'page_index' is deprecated
802 page_index = __page_index($page)
803 %)
804 index = __page_index($page)
805
806 name = "buffer_migrate_page"
807 argstr = sprintf("%d", index)
808
809 size = 1
810 units = "pages"
811 }
812 probe vfs.buffer_migrate_page.return =
813 kernel.function("buffer_migrate_page").return ?
814 {
815 name = "buffer_migrate_page"
816 retstr = sprintf("%d", $return)
817
818 if ($return == 0) {
819 size = 1
820 units = "pages"
821 }
822 }
823
824 /* default if aop not set, __set_page_dirty_nobuffers usually used if set */
825 /* block_dirty_folio related to kernel commit e621900ad28b748e058b81d6078 */
826 probe vfs.__set_page_dirty_buffers = kernel.function("__set_page_dirty_buffers")!,
827 kernel.function("block_dirty_folio")
828 {
829 dev = __page_dev(@choose_defined($page, $folio))
830 devname = __find_bdevname(dev, __page_bdev(@choose_defined($page, $folio)))
831 ino = __page_ino(@choose_defined($page, $folio))
832
833 index = __page_index(@choose_defined($page, $folio))
834
835 name = "__set_page_dirty_buffers"
836 argstr = sprintf("%d", index)
837
838 size = 1
839 units = "pages"
840 }
841 probe vfs.__set_page_dirty_buffers.return =
842 kernel.function("__set_page_dirty_buffers").return!,
843 kernel.function("block_dirty_folio")
844 {
845 name = "__set_page_dirty_buffers"
846 retstr = sprintf("%d", $return)
847
848 %( kernel_v >= "2.6.17" %?
849 if ($return == 1)
850 %:
851 if ($return == 0)
852 %)
853 {
854 size = 1
855 units = "pages"
856 }
857 }
858
859 probe vfs.do_mpage_readpage = __vfs.do_mpage_readpage,
860 __vfs.ext4_mpage_readpages ?
861 {
862 name = "do_mpage_readpage"
863 argstr = sprintf("%d", index)
864 units = "pages"
865 }
866 probe __vfs.do_mpage_readpage = kernel.function("do_mpage_readpage")
867 {
868 dev = __page_dev($page)
869 devname = __find_bdevname(dev, __page_bdev($page))
870 ino = __page_ino($page)
871
872 index = __page_index($page)
873
874 size = 1
875 }
876 probe __vfs.ext4_mpage_readpages = kernel.function("ext4_mpage_readpages") ?
877 {
878 size = $nr_pages
879 if ($nr_pages == 1 && $page != 0) {
880 dev = __page_dev($page)
881 devname = __find_bdevname(dev, __page_bdev($page))
882 ino = __page_ino($page)
883 index = __page_index($page)
884 }
885 else {
886 # Note that we're going to return information about
887 # the first page from the list of pages. It is the best
888 # we can do here.
889 __page = __get_first_page($pages)
890 dev = __page_dev(__page)
891 devname = __find_bdevname(dev, __page_bdev(__page))
892 ino = __page_ino(__page)
893 index = __page_index(__page)
894 }
895 }
896 probe vfs.do_mpage_readpage.return = __vfs.do_mpage_readpage.return,
897 __vfs.ext4_mpage_readpages.return ?
898 {
899 name = "do_mpage_readpage"
900 retstr = sprintf("0x%x", $return)
901 units = "pages"
902 }
903 probe __vfs.do_mpage_readpage.return =
904 kernel.function("do_mpage_readpage").return
905 {
906 size = 1
907 }
908 probe __vfs.ext4_mpage_readpages.return =
909 kernel.function("ext4_mpage_readpages").return ?
910 {
911 if (@defined($rac)) {
912 size = @entry($rac) ? @entry($rac->_nr_pages) : 1
913 } else {
914 size = @entry($nr_pages)
915 }
916 }
917
918
919 /* newer style */
920 /* add_to_page_cache_locked removed per kernel commit f00654007fe1c15 */
921 probe vfs.__add_to_page_cache =
922 kernel.function("add_to_page_cache_locked") !,
923 kernel.function("add_to_page_cache_lru")
924 { }
925
926 probe vfs.add_to_page_cache =
927 vfs.__add_to_page_cache !,
928 kernel.function("add_to_page_cache") /* older style */
929 {
930 dev = $mapping->host->i_sb->s_dev
931 devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
932 ino = $mapping->host->i_ino
933
934 index = $offset
935 nrpages = $mapping->nrpages
936 size = $mapping->nrpages
937 units = "pages"
938
939 name = "vfs.add_to_page_cache"
940 argstr = sprintf("%d, %d", ino, $offset)
941 }
942
943
944 /* newer style */
945 probe vfs.__add_to_page_cache.return =
946 kernel.function("add_to_page_cache_locked").return !,
947 kernel.function("add_to_page_cache_lru").return
948 { }
949
950 probe vfs.add_to_page_cache.return =
951 vfs.__add_to_page_cache.return !,
952 kernel.function("add_to_page_cache").return /* older style */
953 {
954 name = "vfs.add_to_page_cache"
955 retstr = sprintf("%d", $return)
956
957 if ($return == 0) {
958 size = 1
959 units = "pages"
960 }
961 }
962
963 probe vfs.remove_from_page_cache =
964 kernel.function("__delete_from_page_cache") !,
965 kernel.function("__remove_from_page_cache") ?
966 {
967 dev = __page_dev($page)
968 devname = __find_bdevname(dev, __page_bdev($page))
969 ino = __page_ino($page)
970
971 index = __page_index($page)
972
973 name = "vfs.remove_from_page_cache"
974 argstr = sprintf("%d", ino)
975 }
976 probe vfs.remove_from_page_cache.return =
977 kernel.function("__delete_from_page_cache").return !,
978 kernel.function("__remove_from_page_cache").return ?
979 {
980 name = "vfs.remove_from_page_cache"
981 retstr = sprintf("N/A")
982 }
983
984 probe vfs.read = kernel.function("vfs_read")
985 {
986 file = $file
987 pathname = fullpath_struct_file(task_current(), $file)
988 pos = $pos
989 buf = $buf
990 bytes_to_read = $count
991 dev = __file_dev($file)
992 devname = __find_bdevname(dev, __file_bdev($file))
993 ino = __file_ino($file)
994
995 name = "vfs.read"
996 argstr = sprintf("%d, %d, %p", $count, $pos, $buf)
997 }
998
999 probe vfs.read.return = kernel.function("vfs_read").return
1000 {
1001 name = "vfs.read"
1002 retstr = sprintf("%d", $return)
1003
1004 file = @entry($file)
1005 pathname = fullpath_struct_file(task_current(), @entry($file))
1006 pos = @entry($pos)
1007 buf = @entry($buf)
1008 bytes_to_read = @entry($count)
1009 dev = __file_dev(@entry($file))
1010 devname = __find_bdevname(dev, __file_bdev(@entry($file)))
1011 ino = __file_ino(@entry($file))
1012
1013 ret = $return
1014 bytes_read = $return > 0 ? $return : 0
1015 error = $return < 0 ? $return : 0
1016 error_str = error ? errno_str(error) : ""
1017 }
1018
1019 probe vfs.readv = kernel.function("vfs_readv")
1020 {
1021 file = $file
1022 pathname = fullpath_struct_file(task_current(), $file)
1023 dev = __file_dev($file)
1024 devname = __find_bdevname(dev, __file_bdev($file))
1025 ino = __file_ino($file)
1026 pos = $pos
1027 vec = $vec
1028 vlen = $vlen
1029 bytes_to_read = _get_fopv_size($vec, $vlen)
1030
1031 name = "vfs.readv"
1032 argstr = sprintf("%d, %d, %p", bytes_to_read, $pos, $vec)
1033 }
1034
1035 probe vfs.readv.return = kernel.function("vfs_readv").return
1036 {
1037 name = "vfs.readv"
1038 retstr = sprintf("%d", $return)
1039
1040 file = @entry($file)
1041 pathname = fullpath_struct_file(task_current(), @entry($file))
1042 dev = __file_dev(@entry($file))
1043 devname = __find_bdevname(dev, __file_bdev(@entry($file)))
1044 ino = __file_ino(@entry($file))
1045 pos = @entry($pos)
1046 vec = @entry($vec)
1047 vlen = @entry($vlen)
1048 bytes_to_read = _get_fopv_size(vec, vlen)
1049
1050 ret = $return
1051 bytes_read = $return > 0 ? $return : 0
1052 error = $return < 0 ? $return : 0
1053 error_str = error ? errno_str(error) : ""
1054 }
1055
1056 probe vfs.write = kernel.function("vfs_write")
1057 {
1058 file = $file
1059 pathname = fullpath_struct_file(task_current(), $file)
1060 pos = $pos
1061 buf = $buf
1062 bytes_to_write = $count
1063 dev = __file_dev($file)
1064 devname = __find_bdevname(dev, __file_bdev($file))
1065 ino = __file_ino($file)
1066
1067 name = "vfs.write"
1068 argstr = sprintf("%d, %d, %p", $count, $pos, $buf)
1069 }
1070
1071 probe vfs.write.return = kernel.function("vfs_write").return
1072 {
1073 name = "vfs.write"
1074 retstr = sprintf("%d", $return)
1075
1076 file = @entry($file)
1077 pathname = fullpath_struct_file(task_current(), @entry($file))
1078 pos = @entry($pos)
1079 buf = @entry($buf)
1080 bytes_to_write = @entry($count)
1081 dev = __file_dev(@entry($file))
1082 devname = __find_bdevname(dev, __file_bdev(@entry($file)))
1083 ino = __file_ino(@entry($file))
1084
1085 ret = $return
1086 bytes_written = $return > 0 ? $return : 0
1087 error = $return < 0 ? $return : 0
1088 error_str = error ? errno_str(error) : ""
1089 }
1090
1091 probe vfs.writev = kernel.function("vfs_writev")
1092 {
1093 file = $file
1094 pathname = fullpath_struct_file(task_current(), $file)
1095 dev = __file_dev($file)
1096 devname = __find_bdevname(dev, __file_bdev($file))
1097 ino = __file_ino($file)
1098 pos = $pos
1099 vlen = $vlen
1100 vec = $vec
1101 bytes_to_write = _get_fopv_size($vec, $vlen)
1102
1103 name = "vfs.writev"
1104 argstr = sprintf("%d, %d, %p", bytes_to_write, $pos, $vec)
1105 }
1106
1107 probe vfs.writev.return = kernel.function("vfs_writev").return
1108 {
1109 name = "vfs.writev"
1110 retstr = sprintf("%d", $return)
1111
1112 file = @entry($file)
1113 pathname = fullpath_struct_file(task_current(), @entry($file))
1114 dev = __file_dev(@entry($file))
1115 devname = __find_bdevname(dev, __file_bdev(@entry($file)))
1116 ino = __file_ino(@entry($file))
1117 pos = @entry($pos)
1118 vlen = @entry($vlen)
1119 vec = @entry($vec)
1120 bytes_to_write = _get_fopv_size(vec, vlen)
1121
1122 ret = $return
1123 bytes_written = $return > 0 ? $return : 0
1124 error = $return < 0 ? $return : 0
1125 error_str = error ? errno_str(error) : ""
1126 }
1127
1128 probe _vfs.generic_file_readonly_mmap =
1129 kernel.function("generic_file_readonly_mmap")
1130 {
1131 file = $file
1132 pathname = fullpath_struct_file(task_current(), $file)
1133 vma = $vma
1134
1135 name = "_vfs.generic_file_readonly_mmap"
1136 argstr = sprintf("%p, %p", $file, $vma)
1137 }
1138
1139 probe _vfs.generic_file_readonly_mmap.return =
1140 kernel.function("generic_file_readonly_mmap").return
1141 {
1142 name = "_vfs.generic_file_readonly_mmap"
1143 retstr = sprintf("%d", $return)
1144
1145 file = @entry($file)
1146 pathname = fullpath_struct_file(task_current(), @entry($file))
1147 vma = @entry($vma)
1148
1149 ret = $return
1150 error = $return < 0 ? $return : 0
1151 error_str = error ? errno_str(error) : ""
1152 }
1153
1154 probe _vfs.generic_block_bmap = kernel.function("generic_block_bmap")
1155 {
1156 mapping = $mapping
1157 block = $block
1158 get_block = $get_block
1159
1160 name = "_vfs.generic_block_bmap"
1161 argstr = sprintf("%p, %p, %p", $mapping, $block, $get_block)
1162 }
1163
1164 probe _vfs.generic_commit_write = kernel.function("generic_commit_write") ?
1165 {
1166 file = $file
1167 pathname = fullpath_struct_file(task_current(), $file)
1168 page = $page
1169 from = $from
1170 to = $to
1171
1172 name = "_vfs.generic_commit_write"
1173 argstr = sprintf("%p, %p, %d, %d", $file, $page, $from, $to)
1174 }
1175
1176 probe _vfs.block_prepare_write = kernel.function("__block_write_begin_int") !,
1177 kernel.function("__block_write_begin") !,
1178 kernel.function("__block_prepare_write")
1179 {
1180 page = $page
1181 if (@defined($pos)) {
1182 _inode = __page_ino($page)
1183 from = $pos & (@const("_STP_PAGE_SIZE") - 1)
1184 to = from + $len
1185 %(systemtap_v < "2.3" %?
1186 # write_from and write_upto are deprecated
1187 write_from = from
1188 write_upto = to
1189 %)
1190 }
1191 else {
1192 _inode = $inode
1193 %(systemtap_v < "2.3" %?
1194 # write_from and write_upto are deprecated
1195 write_from = $from
1196 write_upto = $to
1197 %)
1198 from = $from
1199 to = $to
1200 }
1201
1202 name = "_vfs.generic_commit_write"
1203 argstr = sprintf("%p, %d, %d", $page, from, to)
1204 }
1205
1206 probe _vfs.block_prepare_write.return =
1207 kernel.function("__block_write_begin_int").return !,
1208 kernel.function("__block_write_begin").return !,
1209 kernel.function("__block_prepare_write").return
1210 {
1211 name = "_vfs.block_prepare_write"
1212 retstr = sprintf("%d", $return)
1213
1214 page = @entry($page)
1215 if (@defined(@entry($pos))) {
1216 _inode = __page_ino(@entry($page))
1217 from = @entry($pos) & (@const("_STP_PAGE_SIZE") - 1)
1218 to = from + @entry($len)
1219 %(systemtap_v < "2.3" %?
1220 # write_from and write_upto are deprecated
1221 write_from = from
1222 write_upto = to
1223 %)
1224 }
1225 else {
1226 _inode = @entry($inode)
1227 %(systemtap_v < "2.3" %?
1228 # write_from and write_upto are deprecated
1229 write_from = @entry($from)
1230 write_upto = @entry($to)
1231 %)
1232 from = @entry($from)
1233 to = @entry($to)
1234 }
1235 page = @entry($page)
1236
1237 ret = $return
1238 error = ret < 0 ? ret : 0
1239 error_str = error ? errno_str(error) : ""
1240 }
1241
1242 probe _vfs.block_write_begin = kernel.function("block_write_begin") ?
1243 {
1244 file = @choose_defined($file, 0)
1245 pathname = @defined($file) ? fullpath_struct_file(task_current(), $file) : ""
1246 pos = $pos
1247 len = $len
1248 flags = $flags
1249
1250 _inode = __address_inode($mapping)
1251
1252 name = "_vfs.block_write_begin"
1253 argstr = sprintf("%p, %d, %d, %x", file, $pos, $len, $flags)
1254 }
1255
1256 probe _vfs.block_write_begin.return =
1257 kernel.function("block_write_begin").return ?
1258 {
1259 name = "_vfs.block_write_begin"
1260 retstr = sprintf("%d", $return)
1261
1262 file = @choose_defined(@entry($file), "")
1263 pathname = @defined(@entry($file)) ? fullpath_struct_file(task_current(), @entry($file)) : ""
1264 pos = @entry($pos)
1265 len = @entry($len)
1266 flags = @entry($flags)
1267
1268 _inode = __address_inode(@entry($mapping))
1269
1270 ret = $return
1271 error = $return < 0 ? $return : 0
1272 error_str = error ? errno_str(error) : ""
1273 }
1274
1275 probe _vfs.block_write_end = kernel.function("block_write_end") ?
1276 {
1277 file = $file
1278 pathname = fullpath_struct_file(task_current(), $file)
1279 pos = $pos
1280 len = $len
1281 page = $page
1282 _inode = __address_inode($mapping)
1283
1284 name = "_vfs.block_write_end"
1285 argstr = sprintf("%p, %d, %d, %p", $file, $pos, $len, $page)
1286 }
1287
1288 probe _vfs.block_write_end.return = kernel.function("block_write_end").return ?
1289 {
1290 name = "_vfs.block_write_end"
1291 retstr = sprintf("%d", $return)
1292
1293 file = @entry($file)
1294 pathname = fullpath_struct_file(task_current(), @entry($file))
1295 pos = @entry($pos)
1296 len = @entry($len)
1297 page = @entry($page)
1298 _inode = __address_inode(@entry($mapping))
1299 ret = $return
1300 }
1301
1302
1303 probe vfs.open = kernel.function("vfs_open") ?
1304 {
1305 name = "vfs.open"
1306 path = $path
1307 cred = @defined($cred) ? $cred : $file->f_cred
1308 pathname = fullpath_struct_path($path)
1309 argstr = sprintf("%s, %p", pathname, cred)
1310 }
1311
1312 probe vfs.open.return = kernel.function("vfs_open").return ?
1313 {
1314 name = "vfs.open"
1315 retstr = sprintf("%d", $return)
1316
1317 ret = $return
1318 error = $return < 0 ? $return : 0
1319 error_str = error ? errno_str(error) : ""
1320
1321 path = @entry($path)
1322 cred = @entry(@defined($cred) ? $cred : $file->f_cred)
1323 pathname = fullpath_struct_path(@entry($path))
1324 }