filemap: add trace events for get_pages, map_pages, and fault

To allow precise tracking of page caches accessed, add new tracepoints
that trigger when a process actually accesses them.

The ureadahead program used by ChromeOS traces the disk access of programs
as they start up at boot up.  It uses mincore(2) or the
'mm_filemap_add_to_page_cache' trace event to accomplish this.  It stores
this information in a "pack" file and on subsequent boots, it will read
the pack file and call readahead(2) on the information so that disk
storage can be loaded into RAM before the applications actually need it.

A problem we see is that due to the kernel's readahead algorithm that can
aggressively pull in more data than needed (to try and accomplish the same
goal) and this data is also recorded.  The end result is that the pack
file contains a lot of pages on disk that are never actually used.
Calling readahead(2) on these unused pages can slow down the system boot
up times.

To solve this, add 3 new trace events, get_pages, map_pages, and fault.
These will be used to trace the pages are not only pulled in from disk,
but are actually used by the application.  Only those pages will be stored
in the pack file, and this helps out the performance of boot up.

With the combination of these 3 new trace events and
mm_filemap_add_to_page_cache, we observed a reduction in the pack file by
7.3% - 20% on ChromeOS varying by device.

Link: https://lkml.kernel.org/r/20240813100312.3930505-1-takayas@chromium.org
Signed-off-by: Takaya Saeki <takayas@chromium.org>
Reviewed-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Reviewed-by: Steven Rostedt (Google) <rostedt@goodmis.org>
Cc: Junichi Uekawa <uekawa@chromium.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Matthew Wilcox <willy@infradead.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/trace/events/filemap.h b/include/trace/events/filemap.h
index 46c89c1e460c595e75e6f41e9360b31db36e251d..f48fe637bfd25885dc6daaf09336ab60626b4944 100644 (file)
--- a/include/trace/events/filemap.h
+++ b/include/trace/events/filemap.h
@@ -56,6 +56,90 @@ DEFINE_EVENT(mm_filemap_op_page_cache, mm_filemap_add_to_page_cache,
        TP_ARGS(folio)
        );
 
+DECLARE_EVENT_CLASS(mm_filemap_op_page_cache_range,
+
+       TP_PROTO(
+               struct address_space *mapping,
+               pgoff_t index,
+               pgoff_t last_index
+       ),
+
+       TP_ARGS(mapping, index, last_index),
+
+       TP_STRUCT__entry(
+               __field(unsigned long, i_ino)
+               __field(dev_t, s_dev)
+               __field(unsigned long, index)
+               __field(unsigned long, last_index)
+       ),
+
+       TP_fast_assign(
+               __entry->i_ino = mapping->host->i_ino;
+               if (mapping->host->i_sb)
+                       __entry->s_dev =
+                               mapping->host->i_sb->s_dev;
+               else
+                       __entry->s_dev = mapping->host->i_rdev;
+               __entry->index = index;
+               __entry->last_index = last_index;
+       ),
+
+       TP_printk(
+               "dev=%d:%d ino=%lx ofs=%lld-%lld",
+               MAJOR(__entry->s_dev),
+               MINOR(__entry->s_dev), __entry->i_ino,
+               ((loff_t)__entry->index) << PAGE_SHIFT,
+               ((((loff_t)__entry->last_index + 1) << PAGE_SHIFT) - 1)
+       )
+);
+
+DEFINE_EVENT(mm_filemap_op_page_cache_range, mm_filemap_get_pages,
+       TP_PROTO(
+               struct address_space *mapping,
+               pgoff_t index,
+               pgoff_t last_index
+       ),
+       TP_ARGS(mapping, index, last_index)
+);
+
+DEFINE_EVENT(mm_filemap_op_page_cache_range, mm_filemap_map_pages,
+       TP_PROTO(
+               struct address_space *mapping,
+               pgoff_t index,
+               pgoff_t last_index
+       ),
+       TP_ARGS(mapping, index, last_index)
+);
+
+TRACE_EVENT(mm_filemap_fault,
+       TP_PROTO(struct address_space *mapping, pgoff_t index),
+
+       TP_ARGS(mapping, index),
+
+       TP_STRUCT__entry(
+               __field(unsigned long, i_ino)
+               __field(dev_t, s_dev)
+               __field(unsigned long, index)
+       ),
+
+       TP_fast_assign(
+               __entry->i_ino = mapping->host->i_ino;
+               if (mapping->host->i_sb)
+                       __entry->s_dev =
+                               mapping->host->i_sb->s_dev;
+               else
+                       __entry->s_dev = mapping->host->i_rdev;
+               __entry->index = index;
+       ),
+
+       TP_printk(
+               "dev=%d:%d ino=%lx ofs=%lld",
+               MAJOR(__entry->s_dev),
+               MINOR(__entry->s_dev), __entry->i_ino,
+               ((loff_t)__entry->index) << PAGE_SHIFT
+       )
+);
+
 TRACE_EVENT(filemap_set_wb_err,
                TP_PROTO(struct address_space *mapping, errseq_t eseq),
 

diff --git a/mm/filemap.c b/mm/filemap.c
index 7665f2398d4569de95a07cb2bf1d665dfc847bdb..fcfec2a78a309df56f8cf18a21f14c713c5d240d 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2548,6 +2548,7 @@ retry:
                        goto err;
        }
 
+       trace_mm_filemap_get_pages(mapping, index, last_index);
        return 0;
 err:
        if (err < 0)
@@ -3279,6 +3280,8 @@ vm_fault_t filemap_fault(struct vm_fault *vmf)
        if (unlikely(index >= max_idx))
                return VM_FAULT_SIGBUS;
 
+       trace_mm_filemap_fault(mapping, index);
+
        /*
         * Do we have something in the page cache already?
         */
@@ -3645,6 +3648,7 @@ vm_fault_t filemap_map_pages(struct vm_fault *vmf,
        } while ((folio = next_uptodate_folio(&xas, mapping, end_pgoff)) != NULL);
        add_mm_counter(vma->vm_mm, folio_type, rss);
        pte_unmap_unlock(vmf->pte, vmf->ptl);
+       trace_mm_filemap_map_pages(mapping, start_pgoff, end_pgoff);
 out:
        rcu_read_unlock();