ANDROID: Refactor fs readpage/write tracepoints.

Refactor the fs readpage/write tracepoints to move the
inode->path lookup outside the tracepoint code, and pass a pointer
to the path into the tracepoint code instead. This is necessary
because the tracepoint code runs non-preemptible. Thanks to
Trilok Soni for catching this in 4.4.

Change-Id: I7486c5947918d155a30c61d6b9cd5027cf8fbe15
Signed-off-by: Mohan Srinivasan <srmohan@google.com>

diff --git a/fs/ext4/inline.c b/fs/ext4/inline.c
index 84da8fd0ab115cf08279ab06d17c921a569ccc34..bc7c082b7913d2ffd06c8031715d2a7be40c48b4 100644 (file)
--- a/fs/ext4/inline.c
+++ b/fs/ext4/inline.c
@@ -503,8 +503,16 @@ int ext4_readpage_inline(struct inode *inode, struct page *page)
                return -EAGAIN;
        }
 
-       trace_android_fs_dataread_start(inode, page_offset(page), PAGE_SIZE,
-                                       current->pid, current->comm);
+       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,

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 3b8a0b05298827c8a1f7afee1aab8b795705b972..1c733321b03c05e61c63cba322c2a965f2325e7f 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1017,8 +1017,16 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
        pgoff_t index;
        unsigned from, to;
 
-       trace_android_fs_datawrite_start(inode, pos, len,
-                                        current->pid, current->comm);
+       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
@@ -2745,8 +2753,16 @@ static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
                                        len, flags, pagep, fsdata);
        }
        *fsdata = (void *)0;
-       trace_android_fs_datawrite_start(inode, pos, len,
-                                        current->pid, current->comm);
+       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)) {
@@ -3355,16 +3371,27 @@ static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
                return 0;
 
        if (trace_android_fs_dataread_start_enabled() &&
-           (iov_iter_rw(iter) == READ))
+           (iov_iter_rw(iter) == 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,
+                                               current->pid, path,
                                                current->comm);
+       }
        if (trace_android_fs_datawrite_start_enabled() &&
-           (iov_iter_rw(iter) == WRITE))
+           (iov_iter_rw(iter) == 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,
+                                                current->pid, path,
                                                 current->comm);
-
+       }
        trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
        if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                ret = ext4_ext_direct_IO(iocb, iter, offset);

diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index 1ce24a6759a090de564813b6639e011da10b3271..1c5db9fd9c8f174fcf86b094669ec3383442a30a 100644 (file)
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -152,11 +152,17 @@ ext4_submit_bio_read(struct bio *bio)
                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);
                }
        }

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index e692958d6e7859995d970d0364fbd36b1a7abd08..8936044dee4c9e4bead9bc457153c68e260c0b25 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1402,8 +1402,16 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
        struct dnode_of_data dn;
        int err = 0;
 
-       trace_android_fs_datawrite_start(inode, pos, len,
-                                        current->pid, current->comm);
+       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);
 
        f2fs_balance_fs(sbi);
@@ -1587,15 +1595,27 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
        trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
 
        if (trace_android_fs_dataread_start_enabled() &&
-           (iov_iter_rw(iter) == READ))
+           (iov_iter_rw(iter) == 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,
+                                               count, current->pid, path,
                                                current->comm);
+       }
        if (trace_android_fs_datawrite_start_enabled() &&
-           (iov_iter_rw(iter) == WRITE))
-               trace_android_fs_datawrite_start(inode, offset, count,
-                                                current->pid, current->comm);
+           (iov_iter_rw(iter) == 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 (iov_iter_rw(iter) == WRITE) {
                __allocate_data_blocks(inode, offset, count);
                if (unlikely(f2fs_cp_error(F2FS_I_SB(inode)))) {

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index d2c5d69ba0b146bd2bd3a9b3a507f4e2655765ce..dbb2cc4df603722d8f9ed755ca3772bcb6382c57 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -85,9 +85,16 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
 {
        struct page *ipage;
 
-       trace_android_fs_dataread_start(inode, page_offset(page),
-                                       PAGE_SIZE, current->pid,
-                                       current->comm);
+       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 = get_node_page(F2FS_I_SB(inode), inode->i_ino);
        if (IS_ERR(ipage)) {

diff --git a/fs/mpage.c b/fs/mpage.c
index 5c65d8942692fd468558c9cac0052216af75a2bb..0fd48fdcc1b18958f326c6837562e41df737cdf1 100644 (file)
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -79,11 +79,17 @@ static struct bio *mpage_bio_submit(int rw, struct bio *bio)
                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);
                }
        }

diff --git a/include/trace/events/android_fs.h b/include/trace/events/android_fs.h
index 531da433a7bc8007f70993feb5527ad39b7ae936..49509533d3faab32355d7a3de8ec0fd00c7595d9 100644 (file)
--- a/include/trace/events/android_fs.h
+++ b/include/trace/events/android_fs.h
@@ -9,8 +9,8 @@
 
 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 *command),
-       TP_ARGS(inode, offset, bytes, pid, command));
+                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),
@@ -18,14 +18,48 @@ DEFINE_EVENT(android_fs_data_end_template, android_fs_dataread_end,
 
 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 *command),
-       TP_ARGS(inode, offset, bytes, pid, command));
+                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));
+            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
index 618988b047c18b6cf10eb432f8841d342017c93c..4e61ffe7a814851136b0674a93139f13169af429 100644 (file)
--- a/include/trace/events/android_fs_template.h
+++ b/include/trace/events/android_fs_template.h
@@ -5,11 +5,10 @@
 
 DECLARE_EVENT_CLASS(android_fs_data_start_template,
        TP_PROTO(struct inode *inode, loff_t offset, int bytes,
-                pid_t pid, char *command),
-       TP_ARGS(inode, offset, bytes, pid, command),
+                pid_t pid, char *pathname, char *command),
+       TP_ARGS(inode, offset, bytes, pid, pathname, command),
        TP_STRUCT__entry(
-               __array(char, path, MAX_FILTER_STR_VAL);
-               __field(char *, pathname);
+               __string(pathbuf, pathname);
                __field(loff_t, offset);
                __field(int,    bytes);
                __field(loff_t, i_size);
@@ -19,27 +18,7 @@ DECLARE_EVENT_CLASS(android_fs_data_start_template,
        ),
        TP_fast_assign(
                {
-                       struct dentry *d;
-
-                       /*
-                        * Grab a reference to the inode here because
-                        * d_obtain_alias() will either drop the inode
-                        * reference if it locates an existing dentry
-                        * or transfer the reference to the new dentry
-                        * created. In our case, the file is still open,
-                        * so the dentry is guaranteed to exist (connected),
-                        * so d_obtain_alias() drops the reference we
-                        * grabbed here.
-                        */
-                       ihold(inode);
-                       d = d_obtain_alias(inode);
-                       if (!IS_ERR(d)) {
-                               __entry->pathname = dentry_path(d,
-                                                       __entry->path,
-                                                       MAX_FILTER_STR_VAL);
-                               dput(d);
-                       } else
-                               __entry->pathname = ERR_PTR(-EINVAL);
+                       __assign_str(pathbuf, pathname);
                        __entry->offset         = offset;
                        __entry->bytes          = bytes;
                        __entry->i_size         = i_size_read(inode);
@@ -50,9 +29,8 @@ DECLARE_EVENT_CLASS(android_fs_data_start_template,
        ),
        TP_printk("entry_name %s, offset %llu, bytes %d, cmdline %s,"
                  " pid %d, i_size %llu, ino %lu",
-                 (IS_ERR(__entry->pathname) ? "ERROR" : __entry->pathname),
-                 __entry->offset, __entry->bytes, __get_str(cmdline),
-                 __entry->pid, __entry->i_size,
+                 __get_str(pathbuf), __entry->offset, __entry->bytes,
+                 __get_str(cmdline), __entry->pid, __entry->i_size,
                  (unsigned long) __entry->ino)
 );