| From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 |
| From: Mohan Srinivasan <srmohan@google.com> |
| Date: Wed, 14 Dec 2016 16:39:51 -0800 |
| Subject: ANDROID: fs: FS tracepoints to track IO. |
| |
| Adds tracepoints in ext4/f2fs/mpage to track readpages/buffered |
| write()s. This allows us to track files that are being read/written |
| to PIDs. |
| |
| Bug: 120445624 |
| Change-Id: I44476230324e9397e292328463f846af4befbd6d |
| [joelaf: Needed for storaged fsync accounting ("storaged --uid" and |
| "storaged --task".)] |
| Signed-off-by: Mohan Srinivasan <srmohan@google.com> |
| [AmitP: Folded following android-4.9 commit changes into this patch |
| a5c4dbb05ab7 ("ANDROID: Replace spaces by '_' for some |
| android filesystem tracepoints.")] |
| Signed-off-by: Amit Pundir <amit.pundir@linaro.org> |
| [adelva: Folded 63066f4acf92 ("ANDROID: fs: Refactor FS |
| readpage/write tracepoints.") into this patch] |
| Signed-off-by: Alistair Delva <adelva@google.com> |
| [maennich: Folded eab894210465 ("ANDROID: fix kernelci build-break") |
| into this patch] |
| Signed-off-by: Matthias Maennich <maennich@google.com> |
| [ebiggers: Folded 05c743211664 ("ANDROID: fix build problem in |
| include/trace/events/android_fs_template.h") into this patch] |
| Signed-off-by: Eric Biggers <ebiggers@google.com> |
| --- |
| fs/ext4/inline.c | 14 +++++ |
| fs/ext4/inode.c | 24 ++++++++ |
| fs/ext4/readpage.c | 47 +++++++++++++-- |
| fs/f2fs/data.c | 42 ++++++++++++++ |
| fs/f2fs/inline.c | 18 ++++++ |
| fs/mpage.c | 36 ++++++++++++ |
| include/trace/events/android_fs.h | 66 ++++++++++++++++++++++ |
| include/trace/events/android_fs_template.h | 64 +++++++++++++++++++++ |
| 8 files changed, 307 insertions(+), 4 deletions(-) |
| create mode 100644 include/trace/events/android_fs.h |
| create mode 100644 include/trace/events/android_fs_template.h |
| |
| diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c |
| --- a/fs/ext4/inline.c |
| +++ b/fs/ext4/inline.c |
| @@ -12,6 +12,7 @@ |
| #include "ext4.h" |
| #include "xattr.h" |
| #include "truncate.h" |
| +#include <trace/events/android_fs.h> |
| |
| #define EXT4_XATTR_SYSTEM_DATA "data" |
| #define EXT4_MIN_INLINE_DATA_SIZE ((sizeof(__le32) * EXT4_N_BLOCKS)) |
| @@ -505,6 +506,17 @@ int ext4_readpage_inline(struct inode *inode, struct page *page) |
| return -EAGAIN; |
| } |
| |
| + if (trace_android_fs_dataread_start_enabled()) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_dataread_start(inode, page_offset(page), |
| + PAGE_SIZE, current->pid, |
| + path, current->comm); |
| + } |
| + |
| /* |
| * Current inline data can only exist in the 1st page, |
| * So for all the other pages, just set them uptodate. |
| @@ -516,6 +528,8 @@ int ext4_readpage_inline(struct inode *inode, struct page *page) |
| SetPageUptodate(page); |
| } |
| |
| + trace_android_fs_dataread_end(inode, page_offset(page), PAGE_SIZE); |
| + |
| up_read(&EXT4_I(inode)->xattr_sem); |
| |
| unlock_page(page); |
| diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c |
| --- a/fs/ext4/inode.c |
| +++ b/fs/ext4/inode.c |
| @@ -47,6 +47,7 @@ |
| #include "truncate.h" |
| |
| #include <trace/events/ext4.h> |
| +#include <trace/events/android_fs.h> |
| |
| static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw, |
| struct ext4_inode_info *ei) |
| @@ -1144,6 +1145,16 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping, |
| if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) |
| return -EIO; |
| |
| + if (trace_android_fs_datawrite_start_enabled()) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_datawrite_start(inode, pos, len, |
| + current->pid, path, |
| + current->comm); |
| + } |
| trace_ext4_write_begin(inode, pos, len, flags); |
| /* |
| * Reserve one block more for addition to orphan list in case |
| @@ -1286,6 +1297,7 @@ static int ext4_write_end(struct file *file, |
| int inline_data = ext4_has_inline_data(inode); |
| bool verity = ext4_verity_in_progress(inode); |
| |
| + trace_android_fs_datawrite_end(inode, pos, len); |
| trace_ext4_write_end(inode, pos, len, copied); |
| if (inline_data) { |
| ret = ext4_write_inline_data_end(inode, pos, len, |
| @@ -1396,6 +1408,7 @@ static int ext4_journalled_write_end(struct file *file, |
| int inline_data = ext4_has_inline_data(inode); |
| bool verity = ext4_verity_in_progress(inode); |
| |
| + trace_android_fs_datawrite_end(inode, pos, len); |
| trace_ext4_journalled_write_end(inode, pos, len, copied); |
| from = pos & (PAGE_SIZE - 1); |
| to = from + len; |
| @@ -2962,6 +2975,16 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping, |
| len, flags, pagep, fsdata); |
| } |
| *fsdata = (void *)0; |
| + if (trace_android_fs_datawrite_start_enabled()) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_datawrite_start(inode, pos, len, |
| + current->pid, |
| + path, current->comm); |
| + } |
| trace_ext4_da_write_begin(inode, pos, len, flags); |
| |
| if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) { |
| @@ -3080,6 +3103,7 @@ static int ext4_da_write_end(struct file *file, |
| return ext4_write_end(file, mapping, pos, |
| len, copied, page, fsdata); |
| |
| + trace_android_fs_datawrite_end(inode, pos, len); |
| trace_ext4_da_write_end(inode, pos, len, copied); |
| start = pos & (PAGE_SIZE - 1); |
| end = start + copied - 1; |
| diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c |
| --- a/fs/ext4/readpage.c |
| +++ b/fs/ext4/readpage.c |
| @@ -46,6 +46,7 @@ |
| #include <linux/cleancache.h> |
| |
| #include "ext4.h" |
| +#include <trace/events/android_fs.h> |
| |
| #define NUM_PREALLOC_POST_READ_CTXS 128 |
| |
| @@ -159,6 +160,17 @@ static bool bio_post_read_required(struct bio *bio) |
| return bio->bi_private && !bio->bi_status; |
| } |
| |
| +static void |
| +ext4_trace_read_completion(struct bio *bio) |
| +{ |
| + struct page *first_page = bio->bi_io_vec[0].bv_page; |
| + |
| + if (first_page != NULL) |
| + trace_android_fs_dataread_end(first_page->mapping->host, |
| + page_offset(first_page), |
| + bio->bi_iter.bi_size); |
| +} |
| + |
| /* |
| * I/O completion handler for multipage BIOs. |
| * |
| @@ -173,6 +185,9 @@ static bool bio_post_read_required(struct bio *bio) |
| */ |
| static void mpage_end_io(struct bio *bio) |
| { |
| + if (trace_android_fs_dataread_start_enabled()) |
| + ext4_trace_read_completion(bio); |
| + |
| if (bio_post_read_required(bio)) { |
| struct bio_post_read_ctx *ctx = bio->bi_private; |
| |
| @@ -221,6 +236,30 @@ static inline loff_t ext4_readpage_limit(struct inode *inode) |
| return i_size_read(inode); |
| } |
| |
| +static void |
| +ext4_submit_bio_read(struct bio *bio) |
| +{ |
| + if (trace_android_fs_dataread_start_enabled()) { |
| + struct page *first_page = bio->bi_io_vec[0].bv_page; |
| + |
| + if (first_page != NULL) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + first_page->mapping->host); |
| + trace_android_fs_dataread_start( |
| + first_page->mapping->host, |
| + page_offset(first_page), |
| + bio->bi_iter.bi_size, |
| + current->pid, |
| + path, |
| + current->comm); |
| + } |
| + } |
| + submit_bio(bio); |
| +} |
| + |
| int ext4_mpage_readpages(struct inode *inode, |
| struct readahead_control *rac, struct page *page) |
| { |
| @@ -363,7 +402,7 @@ int ext4_mpage_readpages(struct inode *inode, |
| if (bio && (last_block_in_bio != blocks[0] - 1 || |
| !fscrypt_mergeable_bio(bio, inode, next_block))) { |
| submit_and_realloc: |
| - submit_bio(bio); |
| + ext4_submit_bio_read(bio); |
| bio = NULL; |
| } |
| if (bio == NULL) { |
| @@ -390,14 +429,14 @@ int ext4_mpage_readpages(struct inode *inode, |
| if (((map.m_flags & EXT4_MAP_BOUNDARY) && |
| (relative_block == map.m_len)) || |
| (first_hole != blocks_per_page)) { |
| - submit_bio(bio); |
| + ext4_submit_bio_read(bio); |
| bio = NULL; |
| } else |
| last_block_in_bio = blocks[blocks_per_page - 1]; |
| goto next_page; |
| confused: |
| if (bio) { |
| - submit_bio(bio); |
| + ext4_submit_bio_read(bio); |
| bio = NULL; |
| } |
| if (!PageUptodate(page)) |
| @@ -409,7 +448,7 @@ int ext4_mpage_readpages(struct inode *inode, |
| put_page(page); |
| } |
| if (bio) |
| - submit_bio(bio); |
| + ext4_submit_bio_read(bio); |
| return 0; |
| } |
| |
| diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c |
| --- a/fs/f2fs/data.c |
| +++ b/fs/f2fs/data.c |
| @@ -27,6 +27,7 @@ |
| #include "segment.h" |
| #include "trace.h" |
| #include <trace/events/f2fs.h> |
| +#include <trace/events/android_fs.h> |
| |
| #define NUM_PREALLOC_POST_READ_CTXS 128 |
| |
| @@ -3397,6 +3398,16 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, |
| block_t blkaddr = NULL_ADDR; |
| int err = 0; |
| |
| + if (trace_android_fs_datawrite_start_enabled()) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_datawrite_start(inode, pos, len, |
| + current->pid, path, |
| + current->comm); |
| + } |
| trace_f2fs_write_begin(inode, pos, len, flags); |
| |
| if (!f2fs_is_checkpoint_ready(sbi)) { |
| @@ -3524,6 +3535,7 @@ static int f2fs_write_end(struct file *file, |
| { |
| struct inode *inode = page->mapping->host; |
| |
| + trace_android_fs_datawrite_end(inode, pos, len); |
| trace_f2fs_write_end(inode, pos, len, copied); |
| |
| /* |
| @@ -3657,6 +3669,29 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) |
| |
| trace_f2fs_direct_IO_enter(inode, offset, count, rw); |
| |
| + if (trace_android_fs_dataread_start_enabled() && |
| + (rw == READ)) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_dataread_start(inode, offset, |
| + count, current->pid, path, |
| + current->comm); |
| + } |
| + if (trace_android_fs_datawrite_start_enabled() && |
| + (rw == WRITE)) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_datawrite_start(inode, offset, count, |
| + current->pid, path, |
| + current->comm); |
| + } |
| + |
| if (rw == WRITE && whint_mode == WHINT_MODE_OFF) |
| iocb->ki_hint = WRITE_LIFE_NOT_SET; |
| |
| @@ -3712,6 +3747,13 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) |
| } |
| |
| out: |
| + if (trace_android_fs_dataread_start_enabled() && |
| + (rw == READ)) |
| + trace_android_fs_dataread_end(inode, offset, count); |
| + if (trace_android_fs_datawrite_start_enabled() && |
| + (rw == WRITE)) |
| + trace_android_fs_datawrite_end(inode, offset, count); |
| + |
| trace_f2fs_direct_IO_exit(inode, offset, count, rw, err); |
| |
| return err; |
| diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c |
| --- a/fs/f2fs/inline.c |
| +++ b/fs/f2fs/inline.c |
| @@ -13,6 +13,7 @@ |
| #include "f2fs.h" |
| #include "node.h" |
| #include <trace/events/f2fs.h> |
| +#include <trace/events/android_fs.h> |
| |
| bool f2fs_may_inline_data(struct inode *inode) |
| { |
| @@ -86,14 +87,29 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page) |
| { |
| struct page *ipage; |
| |
| + if (trace_android_fs_dataread_start_enabled()) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + inode); |
| + trace_android_fs_dataread_start(inode, page_offset(page), |
| + PAGE_SIZE, current->pid, |
| + path, current->comm); |
| + } |
| + |
| ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); |
| if (IS_ERR(ipage)) { |
| + trace_android_fs_dataread_end(inode, page_offset(page), |
| + PAGE_SIZE); |
| unlock_page(page); |
| return PTR_ERR(ipage); |
| } |
| |
| if (!f2fs_has_inline_data(inode)) { |
| f2fs_put_page(ipage, 1); |
| + trace_android_fs_dataread_end(inode, page_offset(page), |
| + PAGE_SIZE); |
| return -EAGAIN; |
| } |
| |
| @@ -105,6 +121,8 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page) |
| if (!PageUptodate(page)) |
| SetPageUptodate(page); |
| f2fs_put_page(ipage, 1); |
| + trace_android_fs_dataread_end(inode, page_offset(page), |
| + PAGE_SIZE); |
| unlock_page(page); |
| return 0; |
| } |
| diff --git a/fs/mpage.c b/fs/mpage.c |
| --- a/fs/mpage.c |
| +++ b/fs/mpage.c |
| @@ -32,6 +32,14 @@ |
| #include <linux/cleancache.h> |
| #include "internal.h" |
| |
| +#define CREATE_TRACE_POINTS |
| +#include <trace/events/android_fs.h> |
| + |
| +EXPORT_TRACEPOINT_SYMBOL(android_fs_datawrite_start); |
| +EXPORT_TRACEPOINT_SYMBOL(android_fs_datawrite_end); |
| +EXPORT_TRACEPOINT_SYMBOL(android_fs_dataread_start); |
| +EXPORT_TRACEPOINT_SYMBOL(android_fs_dataread_end); |
| + |
| /* |
| * I/O completion handler for multipage BIOs. |
| * |
| @@ -49,6 +57,16 @@ static void mpage_end_io(struct bio *bio) |
| struct bio_vec *bv; |
| struct bvec_iter_all iter_all; |
| |
| + if (trace_android_fs_dataread_end_enabled() && |
| + (bio_data_dir(bio) == READ)) { |
| + struct page *first_page = bio->bi_io_vec[0].bv_page; |
| + |
| + if (first_page != NULL) |
| + trace_android_fs_dataread_end(first_page->mapping->host, |
| + page_offset(first_page), |
| + bio->bi_iter.bi_size); |
| + } |
| + |
| bio_for_each_segment_all(bv, bio, iter_all) { |
| struct page *page = bv->bv_page; |
| page_endio(page, bio_op(bio), |
| @@ -60,6 +78,24 @@ static void mpage_end_io(struct bio *bio) |
| |
| static struct bio *mpage_bio_submit(int op, int op_flags, struct bio *bio) |
| { |
| + if (trace_android_fs_dataread_start_enabled() && (op == REQ_OP_READ)) { |
| + struct page *first_page = bio->bi_io_vec[0].bv_page; |
| + |
| + if (first_page != NULL) { |
| + char *path, pathbuf[MAX_TRACE_PATHBUF_LEN]; |
| + |
| + path = android_fstrace_get_pathname(pathbuf, |
| + MAX_TRACE_PATHBUF_LEN, |
| + first_page->mapping->host); |
| + trace_android_fs_dataread_start( |
| + first_page->mapping->host, |
| + page_offset(first_page), |
| + bio->bi_iter.bi_size, |
| + current->pid, |
| + path, |
| + current->comm); |
| + } |
| + } |
| bio->bi_end_io = mpage_end_io; |
| bio_set_op_attrs(bio, op, op_flags); |
| guard_bio_eod(bio); |
| diff --git a/include/trace/events/android_fs.h b/include/trace/events/android_fs.h |
| new file mode 100644 |
| index 000000000000..7edb6bcfe482 |
| --- /dev/null |
| +++ b/include/trace/events/android_fs.h |
| @@ -0,0 +1,66 @@ |
| +#undef TRACE_SYSTEM |
| +#define TRACE_SYSTEM android_fs |
| + |
| +#if !defined(_TRACE_ANDROID_FS_H) || defined(TRACE_HEADER_MULTI_READ) |
| +#define _TRACE_ANDROID_FS_H |
| + |
| +#include <linux/fs.h> |
| +#include <linux/tracepoint.h> |
| +#include <trace/events/android_fs_template.h> |
| + |
| +DEFINE_EVENT(android_fs_data_start_template, android_fs_dataread_start, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes, |
| + pid_t pid, char *pathname, char *command), |
| + TP_ARGS(inode, offset, bytes, pid, pathname, command)); |
| + |
| +DEFINE_EVENT(android_fs_data_end_template, android_fs_dataread_end, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes), |
| + TP_ARGS(inode, offset, bytes)); |
| + |
| +DEFINE_EVENT(android_fs_data_start_template, android_fs_datawrite_start, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes, |
| + pid_t pid, char *pathname, char *command), |
| + TP_ARGS(inode, offset, bytes, pid, pathname, command)); |
| + |
| +DEFINE_EVENT(android_fs_data_end_template, android_fs_datawrite_end, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes), |
| + TP_ARGS(inode, offset, bytes)); |
| + |
| +#endif /* _TRACE_ANDROID_FS_H */ |
| + |
| +/* This part must be outside protection */ |
| +#include <trace/define_trace.h> |
| + |
| +#ifndef ANDROID_FSTRACE_GET_PATHNAME |
| +#define ANDROID_FSTRACE_GET_PATHNAME |
| + |
| +/* Sizes an on-stack array, so careful if sizing this up ! */ |
| +#define MAX_TRACE_PATHBUF_LEN 256 |
| + |
| +static inline char * |
| +android_fstrace_get_pathname(char *buf, int buflen, struct inode *inode) |
| +{ |
| + char *path; |
| + struct dentry *d; |
| + |
| + /* |
| + * d_obtain_alias() will either iput() if it locates an existing |
| + * dentry or transfer the reference to the new dentry created. |
| + * So get an extra reference here. |
| + */ |
| + ihold(inode); |
| + d = d_obtain_alias(inode); |
| + if (likely(!IS_ERR(d))) { |
| + path = dentry_path_raw(d, buf, buflen); |
| + if (unlikely(IS_ERR(path))) { |
| + strcpy(buf, "ERROR"); |
| + path = buf; |
| + } |
| + dput(d); |
| + } else { |
| + strcpy(buf, "ERROR"); |
| + path = buf; |
| + } |
| + return path; |
| +} |
| +#endif |
| diff --git a/include/trace/events/android_fs_template.h b/include/trace/events/android_fs_template.h |
| new file mode 100644 |
| index 000000000000..efc487816e83 |
| --- /dev/null |
| +++ b/include/trace/events/android_fs_template.h |
| @@ -0,0 +1,64 @@ |
| +#if !defined(_TRACE_ANDROID_FS_TEMPLATE_H) || defined(TRACE_HEADER_MULTI_READ) |
| +#define _TRACE_ANDROID_FS_TEMPLATE_H |
| + |
| +#include <linux/tracepoint.h> |
| + |
| +DECLARE_EVENT_CLASS(android_fs_data_start_template, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes, |
| + pid_t pid, char *pathname, char *command), |
| + TP_ARGS(inode, offset, bytes, pid, pathname, command), |
| + TP_STRUCT__entry( |
| + __string(pathbuf, pathname) |
| + __field(loff_t, offset) |
| + __field(int, bytes) |
| + __field(loff_t, i_size) |
| + __string(cmdline, command) |
| + __field(pid_t, pid) |
| + __field(ino_t, ino) |
| + ), |
| + TP_fast_assign( |
| + { |
| + /* |
| + * Replace the spaces in filenames and cmdlines |
| + * because this screws up the tooling that parses |
| + * the traces. |
| + */ |
| + __assign_str(pathbuf, pathname); |
| + (void)strreplace(__get_str(pathbuf), ' ', '_'); |
| + __entry->offset = offset; |
| + __entry->bytes = bytes; |
| + __entry->i_size = i_size_read(inode); |
| + __assign_str(cmdline, command); |
| + (void)strreplace(__get_str(cmdline), ' ', '_'); |
| + __entry->pid = pid; |
| + __entry->ino = inode->i_ino; |
| + } |
| + ), |
| + TP_printk("entry_name %s, offset %llu, bytes %d, cmdline %s," |
| + " pid %d, i_size %llu, ino %lu", |
| + __get_str(pathbuf), __entry->offset, __entry->bytes, |
| + __get_str(cmdline), __entry->pid, __entry->i_size, |
| + (unsigned long) __entry->ino) |
| +); |
| + |
| +DECLARE_EVENT_CLASS(android_fs_data_end_template, |
| + TP_PROTO(struct inode *inode, loff_t offset, int bytes), |
| + TP_ARGS(inode, offset, bytes), |
| + TP_STRUCT__entry( |
| + __field(ino_t, ino) |
| + __field(loff_t, offset) |
| + __field(int, bytes) |
| + ), |
| + TP_fast_assign( |
| + { |
| + __entry->ino = inode->i_ino; |
| + __entry->offset = offset; |
| + __entry->bytes = bytes; |
| + } |
| + ), |
| + TP_printk("ino %lu, offset %llu, bytes %d", |
| + (unsigned long) __entry->ino, |
| + __entry->offset, __entry->bytes) |
| +); |
| + |
| +#endif /* _TRACE_ANDROID_FS_TEMPLATE_H */ |