f2fs: introduce trace points in f2fs filesystem
Subsystems (3)
PATCH 3/4 f2fs: introduce trace points in f2fs filesystem
From: Namjae Jeon <[email protected]>
#> cat /sys/kernel/debug/tracing/events/f2fs/enable 0
#> echo 1 > /sys/kernel/debug/tracing/events/f2fs/enable #> cat /sys/kernel/debug/tracing/events/f2fs/enable 1
#> mount -t f2fs /dev/sdb3 /mnt/
#>
#> cat /sys/kernel/debug/tracing/trace
# tracer: nop
#
#TASK-PID CPU# TIMESTAMP FUNCTION
# | | | | |
mount-423 [001] 49.879188: f2fs_iget: dev 8,19 ino 2 mount-423 [001] 49.879215: f2fs_get_page: dev 8,19 page_index 81, type 2 mount-423 [001] 49.879224: f2fs_readpage: dev 8,19 ino 2 page_index 81 mount-423 [001] 49.879819: f2fs_get_page: dev 8,19 page_index 83, type 2 mount-423 [001] 49.879830: f2fs_readpage: dev 8,19 ino 2 page_index 83 mount-423 [001] 49.880434: f2fs_get_page: dev 8,19 page_index 593, type 2 mount-423 [001] 49.880442: f2fs_readpage: dev 8,19 ino 2 page_index 593 mount-423 [001] 49.889931: f2fs_get_page: dev 8,19 page_index 595, type 2 mount-423 [001] 49.889939: f2fs_readpage: dev 8,19 ino 2 page_index 595 mount-423 [001] 49.892169: f2fs_get_page: dev 8,19 page_index 594, type 2 mount-423 [001] 49.892186: f2fs_readpage: dev 8,19 ino 2 page_index 594
...
..
--- fs/f2fs/checkpoint.c | 17 + fs/f2fs/data.c | 17 + fs/f2fs/file.c | 14 + fs/f2fs/inode.c | 10 + fs/f2fs/namei.c | 7 +- fs/f2fs/node.c | 23 +- fs/f2fs/segment.c | 5 + fs/f2fs/super.c | 4 + include/trace/events/f2fs.h | 1220 +++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 1315 insertions(+), 2 deletions(-) create mode 100644 include/trace/events/f2fs.h
fs/f2fs/checkpoint.c +17 -0
@@ -17,6 +17,8 @@#include <linux/pagevec.h> #include <linux/swap.h> +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "node.h" #include "segment.h"
@@ -31,6 +33,8 @@ struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index) {struct address_space *mapping = sbi->meta_inode->i_mapping;struct page *page =NULL ; + +trace_f2fs_grab_page (sbi->sb, index,META ); repeat: page =grab_cache_page (mapping, index);if (!page) {
@@ -51,6 +55,8 @@ struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index) {struct address_space *mapping = sbi->meta_inode->i_mapping;struct page *page; + +trace_f2fs_get_page (sbi->sb, index,META ); repeat: page =grab_cache_page (mapping, index);if (!page) {
@@ -74,6 +80,8 @@ static int f2fs_write_meta_page(struct page *page,struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb);int err; +trace_f2fs_write_page (page,META ); +wait_on_page_writeback (page); err =write_meta_page (sbi, page, wbc);
@@ -122,6 +130,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, .for_reclaim = 0, }; +trace_f2fs_sync_pages (sbi->sb, type, nr_to_write);pagevec_init (&pvec,0 );while (index <= end) {
@@ -157,6 +166,7 @@ static int f2fs_set_meta_page_dirty(struct page *page)struct address_space *mapping = page->mapping;struct f2fs_sb_info *sbi =F2FS_SB (mapping->host->i_sb); +trace_f2fs_set_page_dirty (page,META );SetPageUptodate (page);if (!PageDirty (page)) {__set_page_dirty_nobuffers (page);
@@ -197,6 +207,7 @@ void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)struct list_head *head, *this;struct orphan_inode_entry *new =NULL , *orphan =NULL ; +trace_f2fs_orphan_inode (sbi->sb, ino);mutex_lock (&sbi->orphan_inode_mutex); head = &sbi->orphan_inode_list;list_for_each (this, head) {
@@ -239,6 +250,7 @@ void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)struct list_head *this, *next, *head;struct orphan_inode_entry *orphan; +trace_f2fs_remove_orphan_inode (sbi->sb, ino);mutex_lock (&sbi->orphan_inode_mutex); head = &sbi->orphan_inode_list;list_for_each_safe (this, next, head) {
@@ -458,6 +470,8 @@ void set_dirty_dir_page(struct inode *inode, struct page *page)if (!S_ISDIR (inode->i_mode))return ; + +trace_f2fs_set_dirty_dir_page (inode, page); retry: new =kmem_cache_alloc (inode_entry_slab,GFP_NOFS );if (!new) {
@@ -554,6 +568,7 @@ void block_operations(struct f2fs_sb_info *sbi) .for_reclaim = 0, }; +trace_f2fs_operations (sbi->sb,1 );/* Stop renaming operation */ mutex_lock_op (sbi,RENAME );mutex_lock_op (sbi,DENTRY_OPS );
@@ -593,6 +608,7 @@ retry:static void unblock_operations (struct f2fs_sb_info *sbi) {int t; +trace_f2fs_operations (sbi->sb,0 );for (t =NODE_WRITE ; t >=RENAME ; t--)mutex_unlock_op (sbi, t); }
@@ -734,6 +750,7 @@ void write_checkpoint(struct f2fs_sb_info *sbi, bool blocked, bool is_umount)struct f2fs_checkpoint *ckpt =F2FS_CKPT (sbi);unsigned long long ckpt_ver; +trace_f2fs_writecheckpoint (sbi->sb, blocked);if (!blocked) {mutex_lock (&sbi->cp_mutex);block_operations (sbi);
fs/f2fs/data.c +17 -0
@@ -18,6 +18,8 @@#include <linux/bio.h> #include <linux/prefetch.h> +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "node.h" #include "segment.h"
@@ -49,6 +51,7 @@ int reserve_new_block(struct dnode_of_data *dn) {struct f2fs_sb_info *sbi =F2FS_SB (dn->inode->i_sb); +trace_f2fs_reserve_new_block (dn->inode, dn->nid);if (is_inode_flag_set (F2FS_I (dn->inode),FI_NO_ALLOC ))return -EPERM ;if (!inc_valid_block_count (sbi, dn->inode,1 ))
@@ -107,6 +110,8 @@ void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn)block_t start_blkaddr, end_blkaddr;BUG_ON (blk_addr ==NEW_ADDR ); + +trace_f2fs_update_extent_cache (blk_addr); fofs =start_bidx_of_node (ofs_of_node (dn->node_page)) + dn->ofs_in_node;/* Update the page address in the parent node */
@@ -221,6 +226,7 @@ struct page *get_lock_data_page(struct inode *inode, pgoff_t index)struct page *page;int err; +trace_f2fs_get_page (inode->i_sb, index,DATA );set_new_dnode (&dn, inode,NULL ,NULL ,0 ); err =get_dnode_of_data (&dn, index,RDONLY_NODE );if (err)
@@ -261,6 +267,7 @@ struct page *get_new_data_page(struct inode *inode, pgoff_t index,struct dnode_of_data dn;int err; +trace_f2fs_new_data_page (inode, index);set_new_dnode (&dn, inode,NULL ,NULL ,0 ); err =get_dnode_of_data (&dn, index,0 );if (err)
@@ -334,6 +341,8 @@ int f2fs_readpage(struct f2fs_sb_info *sbi, struct page *page,bool sync = (type ==READ_SYNC );struct bio *bio; +if (page->mapping) +trace_f2fs_readpage (page);/* This page can be already read by other threads */ if (PageUptodate (page)) {if (!sync)
@@ -424,6 +433,7 @@ static int get_data_block_ro(struct inode *inode, sector_t iblock,static int f2fs_read_data_page (struct file *file,struct page *page) { +trace_f2fs_read_page (page,DATA );return mpage_readpage (page, get_data_block_ro); }
@@ -489,6 +499,7 @@ static int f2fs_write_data_page(struct page *page,if (page->index < end_index) goto out; +trace_f2fs_write_page (page,DATA );/* * If the offset is out-of-range of file size, * this page does not have to be written to disk.
@@ -588,6 +599,8 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,/* for nobh_write_end */ *fsdata =NULL ; +trace_f2fs_write_begin (inode, pos, len, flags); +f2fs_balance_fs (sbi); page =grab_cache_page_write_begin (mapping, index, flags);
@@ -650,6 +663,7 @@ static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,struct file *file = iocb->ki_filp;struct inode *inode = file->f_mapping->host; +trace_f2fs_direct_IO_enter (inode, offset,iov_length (iov, nr_segs), rw);if (rw ==WRITE )return 0 ;
@@ -662,6 +676,7 @@ static void f2fs_invalidate_data_page(struct page *page, unsigned long offset) {struct inode *inode = page->mapping->host;struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb); +trace_f2fs_invalidate_page (page, offset,DATA );if (S_ISDIR (inode->i_mode) &&PageDirty (page)) {dec_page_count (sbi,F2FS_DIRTY_DENTS );inode_dec_dirty_dents (inode);
@@ -671,6 +686,7 @@ static void f2fs_invalidate_data_page(struct page *page, unsigned long offset)static int f2fs_release_data_page (struct page *page,gfp_t wait) { +trace_f2fs_release_page (page,DATA );ClearPagePrivate (page);return 0 ; }
@@ -680,6 +696,7 @@ static int f2fs_set_data_page_dirty(struct page *page)struct address_space *mapping = page->mapping;struct inode *inode = mapping->host; +trace_f2fs_set_page_dirty (page,DATA );SetPageUptodate (page);if (!PageDirty (page)) {__set_page_dirty_nobuffers (page);
fs/f2fs/file.c +14 -0
@@ -18,6 +18,8 @@#include <linux/uaccess.h> #include <linux/mount.h> +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "node.h" #include "segment.h"
@@ -34,6 +36,7 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,struct dnode_of_data dn;int err; +trace_f2fs_vm_page_mkwrite (vma);f2fs_balance_fs (sbi);sb_start_pagefault (inode->i_sb);
@@ -133,6 +136,7 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)if (inode->i_sb->s_flags &MS_RDONLY )return 0 ; +trace_f2fs_sync_file_enter (file, datasync); ret =filemap_write_and_wait_range (inode->i_mapping, start, end);if (ret)return ret;
@@ -179,6 +183,7 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) } out:mutex_unlock (&inode->i_mutex); +trace_f2fs_sync_file_exit (inode, ret);return ret; }
@@ -219,7 +224,9 @@ static int truncate_data_blocks_range(struct dnode_of_data *dn, int count)void truncate_data_blocks (struct dnode_of_data *dn) { +trace_f2fs_truncate_data_blocks_enter (dn->inode);truncate_data_blocks_range (dn,ADDRS_PER_BLOCK ); +trace_f2fs_truncate_data_blocks_exit (dn->inode); }static void truncate_partial_data_page (struct inode *inode,u64 from)
@@ -293,12 +300,14 @@ void f2fs_truncate(struct inode *inode) S_ISLNK(inode->i_mode)))return ; +trace_f2fs_truncate_enter (inode);if (!truncate_blocks (inode,i_size_read (inode))) { inode->i_mtime = inode->i_ctime =CURRENT_TIME ;mark_inode_dirty (inode); }f2fs_balance_fs (F2FS_SB (inode->i_sb)); +trace_f2fs_truncate_exit (inode); } static int f2fs_getattr(struct vfsmount *mnt,
@@ -406,6 +415,7 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)pgoff_t index;int err; +trace_f2fs_truncate_hole (inode, pg_start, pg_end);for (index = pg_start; index < pg_end; index++) {struct dnode_of_data dn;struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb);
@@ -436,6 +446,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)loff_t off_start, off_end;int ret =0 ; +trace_f2fs_punch_hole (inode, offset, len); pg_start = ((unsigned long long ) offset) >>PAGE_CACHE_SHIFT ; pg_end = ((unsigned long long ) offset + len) >>PAGE_CACHE_SHIFT ;
@@ -544,6 +555,7 @@ static long f2fs_fallocate(struct file *file, int mode,if (mode & ~(FALLOC_FL_KEEP_SIZE |FALLOC_FL_PUNCH_HOLE ))return -EOPNOTSUPP ; +trace_f2fs_fallocate_enter (inode, offset, len, mode);if (mode &FALLOC_FL_PUNCH_HOLE ) ret =punch_hole (inode, offset, len, mode);else
@@ -553,6 +565,8 @@ static long f2fs_fallocate(struct file *file, int mode, inode->i_mtime = inode->i_ctime =CURRENT_TIME ;mark_inode_dirty (inode); } + +trace_f2fs_fallocate_exit (inode, offset, len, ret);return ret; }
fs/f2fs/inode.c +10 -0
@@ -13,6 +13,8 @@#include <linux/buffer_head.h> #include <linux/writeback.h> +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "node.h"
@@ -55,12 +57,16 @@ static int f2fs_iget_test(struct inode *inode, void *data)struct inode *f2fs_iget_nowait (struct super_block *sb,unsigned long ino) { +struct f2fs_iget_args args = { .ino = ino, .on_free =0 }; +struct inode *inode =ilookup5 (sb, ino, f2fs_iget_test, &args); +trace_f2fs_iget_nowait (sb, ino); +if (inode)return inode;if (!args.on_free)
@@ -119,6 +125,7 @@ struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)struct inode *inode;int ret; +trace_f2fs_iget (sb, ino); inode =iget_locked (sb, ino);if (!inode)return ERR_PTR (-ENOMEM );
@@ -178,6 +185,7 @@ void update_inode(struct inode *inode, struct page *node_page)struct f2fs_node *rn;struct f2fs_inode *ri; +trace_f2fs_update_inode (inode, node_page);wait_on_page_writeback (node_page); rn =page_address (node_page);
@@ -217,6 +225,7 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc) inode->i_ino == F2FS_META_INO(sbi))return 0 ; +trace_f2fs_write_inode (inode);if (wbc)f2fs_balance_fs (sbi);
@@ -248,6 +257,7 @@ void f2fs_evict_inode(struct inode *inode) {struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb); +trace_f2fs_evict_inode (inode);truncate_inode_pages (&inode->i_data,0 ); if (inode->i_ino == F2FS_NODE_INO(sbi) ||
fs/f2fs/namei.c +6 -1
@@ -14,6 +14,8 @@#include <linux/sched.h> #include <linux/ctype.h> +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "xattr.h" #include "acl.h"
@@ -26,7 +28,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)struct inode *inode;bool nid_free = false;int err; - +trace_f2fs_new_inode (dir, mode); inode =new_inode (sb);if (!inode)return ERR_PTR (-ENOMEM );
@@ -63,6 +65,7 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode) }mark_inode_dirty (inode); +trace_f2fs_allocate_inode (inode, dir, mode);return inode; out:
@@ -223,6 +226,7 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)struct page *page;int err = -ENOENT ; +trace_f2fs_unlink_enter (dir, dentry);f2fs_balance_fs (sbi); de =f2fs_find_entry (dir, &dentry->d_name, &page);
@@ -241,6 +245,7 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)/* In order to evict this inode, we set it dirty */ mark_inode_dirty (inode); fail: +trace_f2fs_unlink_exit (dentry, err);return err; }
fs/f2fs/node.c +22 -1
@@ -16,10 +16,12 @@#include <linux/pagevec.h> #include <linux/swap.h> +#include "f2fs.h" #include "node.h" #include "segment.h" +#include <trace/events/f2fs.h> static struct kmem_cache *nat_entry_slab;static struct kmem_cache *free_nid_slab;
@@ -29,6 +31,7 @@ static void clear_node_page_dirty(struct page *page)struct f2fs_sb_info *sbi =F2FS_SB (mapping->host->i_sb);unsigned int long flags; +trace_f2fs_clear_page_dirty (page,NODE );if (PageDirty (page)) {spin_lock_irqsave (&mapping->tree_lock, flags); radix_tree_tag_clear(&mapping->page_tree,
@@ -92,6 +95,7 @@ static void ra_nat_pages(struct f2fs_sb_info *sbi, int nid)pgoff_t index;int i; +trace_f2fs_ra_nat_pages (sbi->sb, nid);for (i =0 ; i <FREE_NID_PAGES ; i++, nid +=NAT_ENTRY_PER_BLOCK ) {if (nid >= nm_i->max_nid) nid =0 ;
@@ -236,6 +240,7 @@ static int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink) {struct f2fs_nm_info *nm_i =NM_I (sbi); +trace_f2fs_try_to_free_nats (sbi->sb, nm_i->nat_blkaddr, nr_shrink);if (nm_i->nat_cnt <2 *NM_WOUT_THRESHOLD )return 0 ;
@@ -301,6 +306,7 @@ void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni) cache:/* cache nat entry */ cache_nat_entry (NM_I (sbi), nid, &ne); +trace_f2fs_get_node_info (sbi->sb, ni->nid, ni->ino); }/*
@@ -395,6 +401,7 @@ int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int ro)int level, i;int err =0 ; +trace_f2fs_get_dnode_of_data (dn->inode->i_sb, dn->nid, index); level =get_node_path (index, offset, noffset); nids[0 ] = dn->inode->i_ino;
@@ -483,6 +490,7 @@ static void truncate_node(struct dnode_of_data *dn)struct f2fs_sb_info *sbi =F2FS_SB (dn->inode->i_sb);struct node_info ni; +trace_f2fs_truncate_node (dn->inode, dn->nid);/*Nid and Inode */ get_node_info (sbi, dn->nid, &ni);if (dn->inode->i_blocks ==0 ) {BUG_ON (ni.blk_addr !=NULL_ADDR );
@@ -667,6 +675,7 @@ int truncate_inode_blocks(struct inode *inode, pgoff_t from) level =get_node_path (from, offset, noffset); +trace_f2fs_truncate_inode_blocks (inode, from); page =get_node_page (sbi, inode->i_ino);if (IS_ERR (page))return PTR_ERR (page);
@@ -755,7 +764,7 @@ int remove_inode_page(struct inode *inode)mutex_unlock_op (sbi,NODE_TRUNC );return PTR_ERR (page); } - +trace_f2fs_remove_inode_page (inode, page);if (F2FS_I (inode)->i_xattr_nid) {nid_t nid =F2FS_I (inode)->i_xattr_nid;struct page *npage =get_node_page (sbi, nid);
@@ -806,6 +815,7 @@ struct page *new_node_page(struct dnode_of_data *dn, unsigned int ofs)struct page *page;int err; +trace_f2fs_new_node_page (dn->inode, dn->nid, ofs);if (is_inode_flag_set (F2FS_I (dn->inode),FI_NO_ALLOC ))return ERR_PTR (-EPERM );
@@ -967,6 +977,7 @@ page_hit:void sync_inode_page (struct dnode_of_data *dn) { +trace_f2fs_sync_inode_page (dn->inode, dn->nid);if (IS_INODE (dn->node_page) || dn->inode_page == dn->node_page) {update_inode (dn->inode, dn->node_page); }else if (dn->inode_page) {
@@ -1091,6 +1102,8 @@ static int f2fs_write_node_page(struct page *page,block_t new_addr;struct node_info ni; +trace_f2fs_write_page (page,NODE ); +if (wbc->for_reclaim) {dec_page_count (sbi,F2FS_DIRTY_NODES ); wbc->pages_skipped++;
@@ -1155,6 +1168,7 @@ static int f2fs_set_node_page_dirty(struct page *page)struct address_space *mapping = page->mapping;struct f2fs_sb_info *sbi =F2FS_SB (mapping->host->i_sb); +trace_f2fs_set_page_dirty (page,NODE );SetPageUptodate (page);if (!PageDirty (page)) {__set_page_dirty_nobuffers (page);
@@ -1169,6 +1183,8 @@ static void f2fs_invalidate_node_page(struct page *page, unsigned long offset) {struct inode *inode = page->mapping->host;struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb); + +trace_f2fs_invalidate_page (page, offset,NODE );if (PageDirty (page))dec_page_count (sbi,F2FS_DIRTY_NODES );ClearPagePrivate (page);
@@ -1176,6 +1192,7 @@ static void f2fs_invalidate_node_page(struct page *page, unsigned long offset)static int f2fs_release_node_page (struct page *page,gfp_t wait) { +trace_f2fs_release_page (page,NODE );ClearPagePrivate (page);return 0 ; }
@@ -1342,6 +1359,8 @@ bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid)struct f2fs_nm_info *nm_i =NM_I (sbi);struct free_nid *i =NULL ;struct list_head *this; + +trace_f2fs_alloc_nid (sbi->sb); retry:mutex_lock (&nm_i->build_lock);if (!nm_i->fcnt) {
@@ -1377,6 +1396,7 @@ retry: i->state =NID_ALLOC ; nm_i->fcnt--;spin_unlock (&nm_i->free_nid_list_lock); +trace_f2fs_allocated_nid (sbi->sb, *nid);return true; }
@@ -1553,6 +1573,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)nid_t start_nid =0 , end_nid =0 ;bool flushed; +trace_f2fs_flush_nat_entries (sbi->sb); flushed =flush_nats_in_journal (sbi);if (!flushed)
fs/f2fs/segment.c +5 -0
@@ -14,6 +14,7 @@#include <linux/blkdev.h> #include <linux/prefetch.h> #include <linux/vmalloc.h> +#include <trace/events/f2fs.h> #include "f2fs.h" #include "segment.h"
@@ -87,6 +88,7 @@ void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)if (segno ==NULL_SEGNO ||IS_CURSEG (sbi, segno))return ; +trace_f2fs_locate_dirty_segment (sbi->sb, segno);mutex_lock (&dirty_i->seglist_lock); valid_blocks =get_valid_blocks (sbi, segno,0 );
@@ -177,6 +179,7 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)unsigned int segno, offset;long int new_vblocks; +trace_f2fs_update_sit_entry (sbi->sb, blkaddr); segno =GET_SEGNO (sbi, blkaddr); se =get_seg_entry (sbi, segno);
@@ -226,6 +229,7 @@ void invalidate_blocks(struct f2fs_sb_info *sbi, block_t addr)BUG_ON (addr ==NULL_ADDR );if (addr ==NEW_ADDR )return ; +trace_f2fs_invalidate_blocks (sbi->sb, addr);/* add it into sit main buffer */ mutex_lock (&sit_i->sentry_lock);
@@ -546,6 +550,7 @@ static void allocate_segment_by_default(struct f2fs_sb_info *sbi,struct curseg_info *curseg =CURSEG_I (sbi, type);unsigned int ofs_unit; +trace_f2fs_allocate_segment (sbi->sb, type);if (force) {new_curseg (sbi, type, true); goto out;
fs/f2fs/super.c +4 -0
@@ -23,6 +23,9 @@#include <linux/exportfs.h> #include <linux/f2fs_fs.h> +#define CREATE_TRACE_POINTS +#include <trace/events/f2fs.h> +#include "f2fs.h" #include "node.h" #include "xattr.h"
@@ -132,6 +135,7 @@ int f2fs_sync_fs(struct super_block *sb, int sync) {struct f2fs_sb_info *sbi =F2FS_SB (sb); +trace_f2fs_sync_fs (sb, sync);if (!sbi->s_dirty && !get_pages (sbi,F2FS_DIRTY_NODES ))return 0 ;
include/trace/events/f2fs.h new file +1220 -0
1,220 lines not on this page · raw message
Signature · 1 line
1.7.9.5
2013-01-12 (토), 14:41 +0900, Namjae Jeon:
Quoted 31 lines
From: Namjae Jeon <[email protected]>
#> cat
/sys/kernel/debug/tracing/events/f2fs/enable0
#> echo 1 >/sys/kernel/debug/tracing/events/f2fs/enable#> cat/sys/kernel/debug/tracing/events/f2fs/enable1#> mount -t f2fs
/dev/sdb3/mnt/
#>
#> cat/sys/kernel/debug/tracing/trace
# tracer: nop
#
#TASK-PID CPU# TIMESTAMP FUNCTION
# | | | | |mount-423 [001] 49.879188: f2fs_iget: dev 8,19 ino 2 mount-423 [001] 49.879215: f2fs_get_page: dev 8,19 page_index 81, type 2 mount-423 [001] 49.879224: f2fs_readpage: dev 8,19 ino 2 page_index 81 mount-423 [001] 49.879819: f2fs_get_page: dev 8,19 page_index 83, type 2 mount-423 [001] 49.879830: f2fs_readpage: dev 8,19 ino 2 page_index 83 mount-423 [001] 49.880434: f2fs_get_page: dev 8,19 page_index 593, type 2 mount-423 [001] 49.880442: f2fs_readpage: dev 8,19 ino 2 page_index 593 mount-423 [001] 49.889931: f2fs_get_page: dev 8,19 page_index 595, type 2 mount-423 [001] 49.889939: f2fs_readpage: dev 8,19 ino 2 page_index 595 mount-423 [001] 49.892169: f2fs_get_page: dev 8,19 page_index 594, type 2 mount-423 [001] 49.892186: f2fs_readpage: dev 8,19 ino 2 page_index 594...
..Signed-off-by Namjae Jeon <[email protected]>Signed-off-by Pankaj Kumar <[email protected]>
Quoted 10 lines
--- fs/f2fs/checkpoint.c | 17 + fs/f2fs/data.c | 17 + fs/f2fs/file.c | 14 + fs/f2fs/inode.c | 10 + fs/f2fs/namei.c | 7 +- fs/f2fs/node.c | 23 +- fs/f2fs/segment.c | 5 + fs/f2fs/super.c | 4 + include/trace/events/f2fs.h | 1220 +++++++++++++++++++++++++++++++++++++++++++
IMO, it needs to split this patch into two independent patches like:
1. adding a header file to the event subsystem, and
2. introducing tracepoints in f2fs.
Then, we need to get acks from all the related maintainers.
Moreover, it is obvious that the patch-set should describe each of tracepoints precisely and concretely.
Anyway, it must be a valuable job. :)
Thanks,
Signature · 2 lines
Jaegeuk Kim Samsung
2013/1/14, Jaegeuk Kim <[email protected]>:
Quoted 58 lines
2013-01-12 (토), 14:41 +0900, Namjae Jeon:
Quoted 51 lines
From: Namjae Jeon <[email protected]>
#> cat
/sys/kernel/debug/tracing/events/f2fs/enable0
#> echo 1 >/sys/kernel/debug/tracing/events/f2fs/enable#> cat/sys/kernel/debug/tracing/events/f2fs/enable1#> mount -t f2fs
/dev/sdb3/mnt/
#>
#> cat/sys/kernel/debug/tracing/trace
# tracer: nop
#
#TASK-PID CPU# TIMESTAMP FUNCTION
# | | | | |mount-423 [001] 49.879188: f2fs_iget: dev 8,19 ino 2 mount-423 [001] 49.879215: f2fs_get_page: dev 8,19 page_index 81,type 2
mount-423 [001] 49.879224:f2fs_readpage: dev 8,19 ino 2page_index
81
mount-423 [001] 49.879819:f2fs_get_page: dev 8,19page_index83,
type 2
mount-423 [001] 49.879830:f2fs_readpage: dev 8,19 ino 2page_index
83
mount-423 [001] 49.880434:f2fs_get_page: dev 8,19page_index593,
type 2
mount-423 [001] 49.880442:f2fs_readpage: dev 8,19 ino 2page_index
593
mount-423 [001] 49.889931:f2fs_get_page: dev 8,19page_index595,
type 2
mount-423 [001] 49.889939:f2fs_readpage: dev 8,19 ino 2page_index
595
mount-423 [001] 49.892169:f2fs_get_page: dev 8,19page_index594,
type 2
mount-423 [001] 49.892186:f2fs_readpage: dev 8,19 ino 2page_index
594
...
..Signed-off-by Namjae Jeon <[email protected]>Signed-off-by Pankaj Kumar <[email protected]>--- fs/f2fs/checkpoint.c | 17 + fs/f2fs/data.c | 17 + fs/f2fs/file.c | 14 + fs/f2fs/inode.c | 10 + fs/f2fs/namei.c | 7 +- fs/f2fs/node.c | 23 +- fs/f2fs/segment.c | 5 + fs/f2fs/super.c | 4 + include/trace/events/f2fs.h | 1220Quoted 1 line
+++++++++++++++++++++++++++++++++++++++++++
IMO, it needs to split this patch into two independent patches like:
1. adding a header file to the event subsystem, and
2. introducing tracepoints in f2fs.
Quoted 7 lines
Then, we need to get acks from all the related maintainers.
Moreover, it is obvious that the patch-set should describe each of tracepoints precisely and concretely.
Anyway, it must be a valuable job. :)
Thanks,
Hi Jaegeuk.
Okay, I see. I will split the patch as your suggestion. And I will check more performance side and the reason why we should add trace point here.
Thanks.
Quoted 5 lines
--
Jaegeuk Kim
Samsung