f2fs: introduce data read/write showing path info
Subsystems (2)
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: introduce data read/write showing path info
This was used in Android for a long time. Let's upstream it.
--- fs/f2fs/f2fs.h | 29 ++++++++++++ fs/f2fs/file.c | 43 ++++++++++++++--- include/trace/events/f2fs.h | 94 +++++++++++++++++++++++++++++++++++++ 3 files changed, 159 insertions(+), 7 deletions(-)
fs/f2fs/f2fs.h +29 -0
@@ -4537,4 +4537,33 @@ static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi)#define EFSBADCRC EBADMSG/* Bad CRC detected */ #define EFSCORRUPTED EUCLEAN/* Filesystem is corrupted */ +/* Sizes an on-stack array, so careful if sizing this up ! */ +#define MAX_TRACE_PATHBUF_LEN 256 + +static inline char *f2fs_get_pathname (char *buf,int len,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, len); +if (unlikely (IS_ERR (path))) { +strcpy (buf,"ERROR" ); + path = buf; + } +dput (d); + }else { +strcpy (buf,"ERROR" ); + path = buf; + } +return path; +} +#endif /* _LINUX_F2FS_H */
fs/f2fs/file.c +36 -7
67 lines not on this page · raw message
include/trace/events/f2fs.h +94 -0
100 lines not on this page · raw message
Signature · 8 lines
2.35.1.894.gb6a874cedc-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 2 lines · Jaegeuk Kim
This was used in Android for a long time. Let's upstream it.
You still need to explain why this is useful.
fs/f2fs/f2fs.h static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi) · line 4554
Quoted 12 lines
fs/f2fs/f2fs.h +12
-0+static inline char *f2fs_get_pathname (char *buf,int len,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);
Why does this use d_obtain_alias() to get a dentry instead of just using the dentry of the open file?
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerQuoted 6 lines · Eric Biggers
Quoted 2 lines · Jaegeuk Kim
This was used in Android for a long time. Let's upstream it.
You still need to explain why this is useful.
Quoted 15 lines
fs/f2fs/f2fs.h static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi) · line 4554
Quoted 12 lines
fs/f2fs/f2fs.h +12
-0+static inline char *f2fs_get_pathname (char *buf,int len,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);Why does this use
d_obtain_alias()to get a dentry instead of just using the dentry of the open file?
:( I shouldn't copy the code from aosp simply.
Quoted 2 lines
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerThis was used in Android for a long time. Let's upstream it.
---
Change log from v1:
- remove unnecessary path lookup
fs/f2fs/file.c | 48 ++++++++++++++++--- include/trace/events/f2fs.h | 94 +++++++++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 7 deletions(-)
fs/f2fs/file.c +41 -7
@@ -4329,17 +4329,34 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)static ssize_t f2fs_file_read_iter (struct kiocb *iocb,struct iov_iter *to) {struct inode *inode =file_inode (iocb->ki_filp); +const loff_t pos = iocb->ki_pos;ssize_t ret;if (!f2fs_is_compress_backend_ready (inode))return -EOPNOTSUPP ; -if (f2fs_should_use_dio (inode, iocb, to)) -return f2fs_dio_read_iter (iocb, to); +if (trace_f2fs_dataread_start_enabled ()) { +char *path, *p =kmalloc (PATH_MAX ,GFP_KERNEL ); +if (!p) + goto skip_read_trace; + + path =dentry_path_raw (file_dentry (iocb->ki_filp), p,PATH_MAX ); +if (IS_ERR (path)) + goto skip_read_trace; - ret =filemap_read (iocb, to,0 ); -if (ret >0 ) -f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); +trace_f2fs_dataread_start (inode, pos,iov_iter_count (to), + current->pid, path, current->comm); +kfree (p); + } +skip_read_trace: +if (f2fs_should_use_dio (inode, iocb, to)) { + ret =f2fs_dio_read_iter (iocb, to); + }else { + ret =filemap_read (iocb, to,0 ); +if (ret >0 ) +f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); + } +trace_f2fs_dataread_end (inode, pos, ret);return ret; }
@@ -4637,14 +4654,31 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)/* Possibly preallocate the blocks for the write. */ target_size = iocb->ki_pos +iov_iter_count (from); preallocated =f2fs_preallocate_blocks (iocb, from, dio); -if (preallocated <0 ) +if (preallocated <0 ) { ret = preallocated; -else + }else { +if (trace_f2fs_datawrite_start_enabled ()) { +char *path, *p =kmalloc (PATH_MAX ,GFP_KERNEL ); +if (!p) + goto skip_write_trace; + path =dentry_path_raw (file_dentry (iocb->ki_filp), + p,PATH_MAX ); +if (IS_ERR (path)) + goto skip_write_trace; +trace_f2fs_datawrite_start (inode, orig_pos, orig_count, + current->pid, path, current->comm); +kfree (p); + } +skip_write_trace:/* Do the actual write. */ ret = dio ?f2fs_dio_write_iter (iocb, from, &may_need_sync):f2fs_buffered_write_iter (iocb, from); +if (trace_f2fs_datawrite_end_enabled ()) +trace_f2fs_datawrite_end (inode, orig_pos, ret); + } +/* Don't leave any preallocated blocks around past i_size. */ if (preallocated &&i_size_read (inode) < target_size) {f2fs_down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]);
include/trace/events/f2fs.h +94 -0
100 lines not on this page · raw message
Signature · 8 lines
2.35.1.894.gb6a874cedc-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Chao Yu
maintainerQuoted 20 lines · Jaegeuk Kim
This was used in Android for a long time. Let's upstream it.
Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v1:
- remove unnecessary path lookupfs/f2fs/file.c | 48 ++++++++++++++++--- include/trace/events/f2fs.h | 94 +++++++++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 7 deletions(-)fs/f2fs/file.c +0
-0@@ -4329,17 +4329,34 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)static ssize_t f2fs_file_read_iter (struct kiocb *iocb,struct iov_iter *to) {struct inode *inode =file_inode (iocb->ki_filp);
fs/f2fs/file.c static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 4339
Quoted 10 lines
fs/f2fs/file.c +3
-2+const loff_t pos = iocb->ki_pos;ssize_t ret;if (!f2fs_is_compress_backend_ready (inode))return -EOPNOTSUPP ; -if (f2fs_should_use_dio (inode, iocb, to)) -return f2fs_dio_read_iter (iocb, to); +if (trace_f2fs_dataread_start_enabled ()) { +char *path, *p =kmalloc (PATH_MAX ,GFP_KERNEL );
f2fs_kmalloc();
fs/f2fs/file.c static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 4344
Quoted 5 lines
fs/f2fs/file.c +5
-0+if (!p) + goto skip_read_trace; + + path =dentry_path_raw (file_dentry (iocb->ki_filp), p,PATH_MAX ); +if (IS_ERR (path))
kfree();
Quoted 7 lines
fs/f2fs/file.c +3
-3+ goto skip_read_trace; - ret =filemap_read (iocb, to,0 ); -if (ret >0 ) -f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); +trace_f2fs_dataread_start (inode, pos,iov_iter_count (to), + current->pid, path, current->comm);
fs/f2fs/file.c static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 4358
Quoted 10 lines
fs/f2fs/file.c +10
-0+kfree (p); + } +skip_read_trace: +if (f2fs_should_use_dio (inode, iocb, to)) { + ret =f2fs_dio_read_iter (iocb, to); + }else { + ret =filemap_read (iocb, to,0 ); +if (ret >0 ) +f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); + }
if (trace_f2fs_dataread_end_enabled())
Thanks,
Quoted 5 lines
fs/f2fs/file.c +1
-0+trace_f2fs_dataread_end (inode, pos, ret);return ret; }
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4661
Quoted 10 lines
fs/f2fs/file.c +4
-2@@ -4637,14 +4654,31 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)/* Possibly preallocate the blocks for the write. */ target_size = iocb->ki_pos +iov_iter_count (from); preallocated =f2fs_preallocate_blocks (iocb, from, dio); -if (preallocated <0 ) +if (preallocated <0 ) { ret = preallocated; -else + }else { +if (trace_f2fs_datawrite_start_enabled ()) { +char *path, *p =kmalloc (PATH_MAX ,GFP_KERNEL );
f2fs_kmalloc()
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4666
Quoted 5 lines
fs/f2fs/file.c +5
-0+if (!p) + goto skip_write_trace; + path =dentry_path_raw (file_dentry (iocb->ki_filp), + p,PATH_MAX ); +if (IS_ERR (path))
kfree();
Quoted 123 lines
fs/f2fs/file.c +10
-0+ goto skip_write_trace; +trace_f2fs_datawrite_start (inode, orig_pos, orig_count, + current->pid, path, current->comm); +kfree (p); + } +skip_write_trace:/* Do the actual write. */ ret = dio ?f2fs_dio_write_iter (iocb, from, &may_need_sync):f2fs_buffered_write_iter (iocb, from); +if (trace_f2fs_datawrite_end_enabled ()) +trace_f2fs_datawrite_end (inode, orig_pos, ret); + } +/* Don't leave any preallocated blocks around past i_size. */ if (preallocated &&i_size_read (inode) < target_size) {f2fs_down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]);include/trace/events/f2fs.h +94
-0@@ -2068,6 +2068,100 @@ TRACE_EVENT(f2fs_fiemap, __entry->ret) ); +DECLARE_EVENT_CLASS (f2fs__rw_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), + +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 (f2fs__rw_end, + + 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) +); + +DEFINE_EVENT (f2fs__rw_start, f2fs_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 (f2fs__rw_end, f2fs_dataread_end, + + TP_PROTO(struct inode *inode, loff_t offset, int bytes), + +TP_ARGS (inode, offset, bytes) +); + +DEFINE_EVENT (f2fs__rw_start, f2fs_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 (f2fs__rw_end, f2fs_datawrite_end, + + TP_PROTO(struct inode *inode, loff_t offset, int bytes), + +TP_ARGS (inode, offset, bytes) +); +#endif /* _TRACE_F2FS_H */ /* This part must be outside protection */
Jaegeuk Kim
maintainerThis was used in Android for a long time. Let's upstream it.
---
change log from v2:
- fix missing kfree
- add condition check
fs/f2fs/file.c | 58 ++++++++++++++++++++--- include/trace/events/f2fs.h | 94 +++++++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+), 7 deletions(-)
fs/f2fs/file.c +51 -7
@@ -4329,17 +4329,39 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)static ssize_t f2fs_file_read_iter (struct kiocb *iocb,struct iov_iter *to) {struct inode *inode =file_inode (iocb->ki_filp); +const loff_t pos = iocb->ki_pos;ssize_t ret;if (!f2fs_is_compress_backend_ready (inode))return -EOPNOTSUPP ; -if (f2fs_should_use_dio (inode, iocb, to)) -return f2fs_dio_read_iter (iocb, to); +if (trace_f2fs_dataread_start_enabled ()) { +char *p =f2fs_kmalloc (F2FS_I_SB (inode),PATH_MAX ,GFP_KERNEL ); +char *path; + +if (!p) + goto skip_read_trace; + + path =dentry_path_raw (file_dentry (iocb->ki_filp), p,PATH_MAX ); +if (IS_ERR (path)) { +kfree (p); + goto skip_read_trace; + } - ret =filemap_read (iocb, to,0 ); -if (ret >0 ) -f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); +trace_f2fs_dataread_start (inode, pos,iov_iter_count (to), + current->pid, path, current->comm); +kfree (p); + } +skip_read_trace: +if (f2fs_should_use_dio (inode, iocb, to)) { + ret =f2fs_dio_read_iter (iocb, to); + }else { + ret =filemap_read (iocb, to,0 ); +if (ret >0 ) +f2fs_update_iostat (F2FS_I_SB (inode),APP_BUFFERED_READ_IO , ret); + } +if (trace_f2fs_dataread_end_enabled ()) +trace_f2fs_dataread_end (inode, pos, ret);return ret; }
@@ -4637,14 +4659,36 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)/* Possibly preallocate the blocks for the write. */ target_size = iocb->ki_pos +iov_iter_count (from); preallocated =f2fs_preallocate_blocks (iocb, from, dio); -if (preallocated <0 ) +if (preallocated <0 ) { ret = preallocated; -else + }else { +if (trace_f2fs_datawrite_start_enabled ()) { +char *p =f2fs_kmalloc (F2FS_I_SB (inode), +PATH_MAX ,GFP_KERNEL ); +char *path; + +if (!p) + goto skip_write_trace; + path =dentry_path_raw (file_dentry (iocb->ki_filp), + p,PATH_MAX ); +if (IS_ERR (path)) { +kfree (p); + goto skip_write_trace; + } +trace_f2fs_datawrite_start (inode, orig_pos, orig_count, + current->pid, path, current->comm); +kfree (p); + } +skip_write_trace:/* Do the actual write. */ ret = dio ?f2fs_dio_write_iter (iocb, from, &may_need_sync):f2fs_buffered_write_iter (iocb, from); +if (trace_f2fs_datawrite_end_enabled ()) +trace_f2fs_datawrite_end (inode, orig_pos, ret); + } +/* Don't leave any preallocated blocks around past i_size. */ if (preallocated &&i_size_read (inode) < target_size) {f2fs_down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]);
include/trace/events/f2fs.h +94 -0
100 lines not on this page · raw message
Signature · 1 line
2.35.1.1021.g381101b075-goog
Quoted 1 line · Jaegeuk Kim
This was used in Android for a long time. Let's upstream it.
Could you please explain more about its usage?
Quoted 2 lines
Signed-off-by Jaegeuk Kim <[email protected]>
The code part looks clean.
Thanks,
Jaegeuk Kim
maintainerQuoted 4 lines · Chao Yu
Quoted 1 line · Jaegeuk Kim
This was used in Android for a long time. Let's upstream it.
Could you please explain more about its usage?
I found ioblame and ioshark in android are using it to understand app/file/IO traffic. Once we have this in AOSP, I'm thinking to change one by one. The android-mainline is also deprecating the custom tracepoints as well.
https://android-review.googlesource.com/c/kernel/common/+/2045529
Quoted 9 lines
Quoted 3 lines
Signed-off-by Jaegeuk Kim <[email protected]>The code part looks clean.
Reviewed-by Chao Yu <[email protected]>Thanks,