ext4: convert instrumentation from markers to tracepoints (9bffad1e) · Commits · e / devices / android_kernel_xiaomi_markw

fs/ext4/fsync.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -28,10 +28,12 @@
		#include <linux/writeback.h>
		#include <linux/jbd2.h>
		#include <linux/blkdev.h>
		#include <linux/marker.h>

		#include "ext4.h"
		#include "ext4_jbd2.h"

		#include <trace/events/ext4.h>

		/*
		* akpm: A new design for ext4_sync_file().
		*
		@@ -52,9 +54,7 @@ int ext4_sync_file(struct file file, struct dentry dentry, int datasync)

		J_ASSERT(ext4_journal_current_handle() == NULL);

		trace_mark(ext4_sync_file, "dev %s datasync %d ino %ld parent %ld",
		inode->i_sb->s_id, datasync, inode->i_ino,
		dentry->d_parent->d_inode->i_ino);
		trace_ext4_sync_file(file, dentry, datasync);

		/*
		* data=writeback:

fs/ext4/ialloc.c

+6 −9

Original line number	Diff line number	Diff line
		@@ -23,11 +23,14 @@
		#include <linux/bitops.h>
		#include <linux/blkdev.h>
		#include <asm/byteorder.h>

		#include "ext4.h"
		#include "ext4_jbd2.h"
		#include "xattr.h"
		#include "acl.h"

		#include <trace/events/ext4.h>

		/*
		* ialloc.c contains the inodes allocation and deallocation routines
		*/
		@@ -208,11 +211,7 @@ void ext4_free_inode(handle_t handle, struct inode inode)

		ino = inode->i_ino;
		ext4_debug("freeing inode %lu\n", ino);
		trace_mark(ext4_free_inode,
		"dev %s ino %lu mode %d uid %lu gid %lu bocks %llu",
		sb->s_id, inode->i_ino, inode->i_mode,
		(unsigned long) inode->i_uid, (unsigned long) inode->i_gid,
		(unsigned long long) inode->i_blocks);
		trace_ext4_free_inode(inode);

		/*
		* Note: we must free any quota before locking the superblock,
		@@ -815,8 +814,7 @@ struct inode ext4_new_inode(handle_t handle, struct inode *dir, int mode)

		sb = dir->i_sb;
		ngroups = ext4_get_groups_count(sb);
		trace_mark(ext4_request_inode, "dev %s dir %lu mode %d", sb->s_id,
		dir->i_ino, mode);
		trace_ext4_request_inode(dir, mode);
		inode = new_inode(sb);
		if (!inode)
		return ERR_PTR(-ENOMEM);
		@@ -1047,8 +1045,7 @@ got:
		}

		ext4_debug("allocating inode %lu\n", inode->i_ino);
		trace_mark(ext4_allocate_inode, "dev %s ino %lu dir %lu mode %d",
		sb->s_id, inode->i_ino, dir->i_ino, mode);
		trace_ext4_allocate_inode(inode, dir, mode);
		goto really_out;
		fail:
		ext4_std_error(sb, err);

fs/ext4/inode.c

+14 −55

Original line number	Diff line number	Diff line
		@@ -37,11 +37,14 @@
		#include <linux/namei.h>
		#include <linux/uio.h>
		#include <linux/bio.h>

		#include "ext4_jbd2.h"
		#include "xattr.h"
		#include "acl.h"
		#include "ext4_extents.h"

		#include <trace/events/ext4.h>

		#define MPAGE_DA_EXTENT_TAIL 0x01

		static inline int ext4_begin_ordered_truncate(struct inode *inode,
		@@ -1466,10 +1469,7 @@ static int ext4_write_begin(struct file file, struct address_space mapping,
		pgoff_t index;
		unsigned from, to;

		trace_mark(ext4_write_begin,
		"dev %s ino %lu pos %llu len %u flags %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, flags);
		trace_ext4_write_begin(inode, pos, len, flags);
		/*
		* Reserve one block more for addition to orphan list in case
		* we allocate blocks but write fails for some reason
		@@ -1611,10 +1611,7 @@ static int ext4_ordered_write_end(struct file *file,
		struct inode *inode = mapping->host;
		int ret = 0, ret2;

		trace_mark(ext4_ordered_write_end,
		"dev %s ino %lu pos %llu len %u copied %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, copied);
		trace_ext4_ordered_write_end(inode, pos, len, copied);
		ret = ext4_jbd2_file_inode(handle, inode);

		if (ret == 0) {
		@@ -1658,10 +1655,7 @@ static int ext4_writeback_write_end(struct file *file,
		struct inode *inode = mapping->host;
		int ret = 0, ret2;

		trace_mark(ext4_writeback_write_end,
		"dev %s ino %lu pos %llu len %u copied %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, copied);
		trace_ext4_writeback_write_end(inode, pos, len, copied);
		ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
		page, fsdata);
		copied = ret2;
		@@ -1705,10 +1699,7 @@ static int ext4_journalled_write_end(struct file *file,
		unsigned from, to;
		loff_t new_i_size;

		trace_mark(ext4_journalled_write_end,
		"dev %s ino %lu pos %llu len %u copied %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, copied);
		trace_ext4_journalled_write_end(inode, pos, len, copied);
		from = pos & (PAGE_CACHE_SIZE - 1);
		to = from + len;

		@@ -2554,9 +2545,7 @@ static int ext4_da_writepage(struct page *page,
		struct buffer_head *page_bufs;
		struct inode *inode = page->mapping->host;

		trace_mark(ext4_da_writepage,
		"dev %s ino %lu page_index %lu",
		inode->i_sb->s_id, inode->i_ino, page->index);
		trace_ext4_da_writepage(inode, page);
		size = i_size_read(inode);
		if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
		@@ -2667,19 +2656,7 @@ static int ext4_da_writepages(struct address_space *mapping,
		int needed_blocks, ret = 0, nr_to_writebump = 0;
		struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);

		trace_mark(ext4_da_writepages,
		"dev %s ino %lu nr_t_write %ld "
		"pages_skipped %ld range_start %llu "
		"range_end %llu nonblocking %d "
		"for_kupdate %d for_reclaim %d "
		"for_writepages %d range_cyclic %d",
		inode->i_sb->s_id, inode->i_ino,
		wbc->nr_to_write, wbc->pages_skipped,
		(unsigned long long) wbc->range_start,
		(unsigned long long) wbc->range_end,
		wbc->nonblocking, wbc->for_kupdate,
		wbc->for_reclaim, wbc->for_writepages,
		wbc->range_cyclic);
		trace_ext4_da_writepages(inode, wbc);

		/*
		* No pages to write? This is mainly a kludge to avoid starting
		@@ -2845,14 +2822,7 @@ out_writepages:
		if (!no_nrwrite_index_update)
		wbc->no_nrwrite_index_update = 0;
		wbc->nr_to_write -= nr_to_writebump;
		trace_mark(ext4_da_writepage_result,
		"dev %s ino %lu ret %d pages_written %d "
		"pages_skipped %ld congestion %d "
		"more_io %d no_nrwrite_index_update %d",
		inode->i_sb->s_id, inode->i_ino, ret,
		pages_written, wbc->pages_skipped,
		wbc->encountered_congestion, wbc->more_io,
		wbc->no_nrwrite_index_update);
		trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
		return ret;
		}

		@@ -2904,11 +2874,7 @@ static int ext4_da_write_begin(struct file file, struct address_space mapping,
		len, flags, pagep, fsdata);
		}
		fsdata = (void )0;

		trace_mark(ext4_da_write_begin,
		"dev %s ino %lu pos %llu len %u flags %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, flags);
		trace_ext4_da_write_begin(inode, pos, len, flags);
		retry:
		/*
		* With delayed allocation, we don't log the i_disksize update
		@@ -3001,10 +2967,7 @@ static int ext4_da_write_end(struct file *file,
		}
		}

		trace_mark(ext4_da_write_end,
		"dev %s ino %lu pos %llu len %u copied %u",
		inode->i_sb->s_id, inode->i_ino,
		(unsigned long long) pos, len, copied);
		trace_ext4_da_write_end(inode, pos, len, copied);
		start = pos & (PAGE_CACHE_SIZE - 1);
		end = start + copied - 1;

		@@ -3255,9 +3218,7 @@ static int ext4_normal_writepage(struct page *page,
		loff_t size = i_size_read(inode);
		loff_t len;

		trace_mark(ext4_normal_writepage,
		"dev %s ino %lu page_index %lu",
		inode->i_sb->s_id, inode->i_ino, page->index);
		trace_ext4_normal_writepage(inode, page);
		J_ASSERT(PageLocked(page));
		if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
		@@ -3343,9 +3304,7 @@ static int ext4_journalled_writepage(struct page *page,
		loff_t size = i_size_read(inode);
		loff_t len;

		trace_mark(ext4_journalled_writepage,
		"dev %s ino %lu page_index %lu",
		inode->i_sb->s_id, inode->i_ino, page->index);
		trace_ext4_journalled_writepage(inode, page);
		J_ASSERT(PageLocked(page));
		if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;

fs/ext4/mballoc.c

+27 −50

Original line number	Diff line number	Diff line
		@@ -22,6 +22,8 @@
		*/

		#include "mballoc.h"
		#include <trace/events/ext4.h>

		/*
		* MUSTDO:
		* - test ext4_ext_search_left() and ext4_ext_search_right()
		@@ -340,8 +342,6 @@ static void ext4_mb_generate_from_freelist(struct super_block sb, void bitmap,
		ext4_group_t group);
		static void release_blocks_on_commit(journal_t journal, transaction_t txn);



		static inline void mb_correct_addr_and_bit(int bit, void *addr)
		{
		#if BITS_PER_LONG == 64
		@@ -2859,8 +2859,7 @@ static void release_blocks_on_commit(journal_t journal, transaction_t txn)
		discard_block = (ext4_fsblk_t) entry->group * EXT4_BLOCKS_PER_GROUP(sb)
		+ entry->start_blk
		+ le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
		trace_mark(ext4_discard_blocks, "dev %s blk %llu count %u",
		sb->s_id, (unsigned long long) discard_block,
		trace_ext4_discard_blocks(sb, (unsigned long long)discard_block,
		entry->count);
		sb_issue_discard(sb, discard_block, entry->count);

		@@ -3629,10 +3628,7 @@ ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)

		mb_debug("new inode pa %p: %llu/%u for %u\n", pa,
		pa->pa_pstart, pa->pa_len, pa->pa_lstart);
		trace_mark(ext4_mb_new_inode_pa,
		"dev %s ino %lu pstart %llu len %u lstart %u",
		sb->s_id, ac->ac_inode->i_ino,
		pa->pa_pstart, pa->pa_len, pa->pa_lstart);
		trace_ext4_mb_new_inode_pa(ac, pa);

		ext4_mb_use_inode_pa(ac, pa);
		atomic_add(pa->pa_free, &EXT4_SB(sb)->s_mb_preallocated);
		@@ -3692,8 +3688,7 @@ ext4_mb_new_group_pa(struct ext4_allocation_context *ac)

		mb_debug("new group pa %p: %llu/%u for %u\n", pa,
		pa->pa_pstart, pa->pa_len, pa->pa_lstart);
		trace_mark(ext4_mb_new_group_pa, "dev %s pstart %llu len %u lstart %u",
		sb->s_id, pa->pa_pstart, pa->pa_len, pa->pa_lstart);
		trace_ext4_mb_new_group_pa(ac, pa);

		ext4_mb_use_group_pa(ac, pa);
		atomic_add(pa->pa_free, &EXT4_SB(sb)->s_mb_preallocated);
		@@ -3783,9 +3778,7 @@ ext4_mb_release_inode_pa(struct ext4_buddy e4b, struct buffer_head bitmap_bh,
		ext4_mb_store_history(ac);
		}

		trace_mark(ext4_mb_release_inode_pa,
		"dev %s ino %lu block %llu count %u",
		sb->s_id, pa->pa_inode->i_ino, grp_blk_start + bit,
		trace_ext4_mb_release_inode_pa(ac, pa, grp_blk_start + bit,
		next - bit);
		mb_free_blocks(pa->pa_inode, e4b, bit, next - bit);
		bit = next + 1;
		@@ -3820,8 +3813,7 @@ ext4_mb_release_group_pa(struct ext4_buddy *e4b,
		if (ac)
		ac->ac_op = EXT4_MB_HISTORY_DISCARD;

		trace_mark(ext4_mb_release_group_pa, "dev %s pstart %llu len %d",
		sb->s_id, pa->pa_pstart, pa->pa_len);
		trace_ext4_mb_release_group_pa(ac, pa);
		BUG_ON(pa->pa_deleted == 0);
		ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
		BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
		@@ -3889,6 +3881,8 @@ ext4_mb_discard_group_preallocations(struct super_block *sb,

		INIT_LIST_HEAD(&list);
		ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
		if (ac)
		ac->ac_sb = sb;
		repeat:
		ext4_lock_group(sb, group);
		list_for_each_entry_safe(pa, tmp,
		@@ -3987,12 +3981,15 @@ void ext4_discard_preallocations(struct inode *inode)
		}

		mb_debug("discard preallocation for inode %lu\n", inode->i_ino);
		trace_mark(ext4_discard_preallocations, "dev %s ino %lu", sb->s_id,
		inode->i_ino);
		trace_ext4_discard_preallocations(inode);

		INIT_LIST_HEAD(&list);

		ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
		if (ac) {
		ac->ac_sb = sb;
		ac->ac_inode = inode;
		}
		repeat:
		/* first, collect all pa's in the inode */
		spin_lock(&ei->i_prealloc_lock);
		@@ -4276,6 +4273,8 @@ ext4_mb_discard_lg_preallocations(struct super_block *sb,

		INIT_LIST_HEAD(&discard_list);
		ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
		if (ac)
		ac->ac_sb = sb;

		spin_lock(&lg->lg_prealloc_lock);
		list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[order],
		@@ -4445,8 +4444,7 @@ static int ext4_mb_discard_preallocations(struct super_block *sb, int needed)
		int ret;
		int freed = 0;

		trace_mark(ext4_mb_discard_preallocations, "dev %s needed %d",
		sb->s_id, needed);
		trace_ext4_mb_discard_preallocations(sb, needed);
		for (i = 0; i < ngroups && needed > 0; i++) {
		ret = ext4_mb_discard_group_preallocations(sb, i, needed);
		freed += ret;
		@@ -4475,17 +4473,7 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
		sb = ar->inode->i_sb;
		sbi = EXT4_SB(sb);

		trace_mark(ext4_request_blocks, "dev %s flags %u len %u ino %lu "
		"lblk %llu goal %llu lleft %llu lright %llu "
		"pleft %llu pright %llu ",
		sb->s_id, ar->flags, ar->len,
		ar->inode ? ar->inode->i_ino : 0,
		(unsigned long long) ar->logical,
		(unsigned long long) ar->goal,
		(unsigned long long) ar->lleft,
		(unsigned long long) ar->lright,
		(unsigned long long) ar->pleft,
		(unsigned long long) ar->pright);
		trace_ext4_request_blocks(ar);

		/*
		* For delayed allocation, we could skip the ENOSPC and
		@@ -4521,7 +4509,10 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
		}

		ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
		if (!ac) {
		if (ac) {
		ac->ac_sb = sb;
		ac->ac_inode = ar->inode;
		} else {
		ar->len = 0;
		*errp = -ENOMEM;
		goto out1;
		@@ -4594,18 +4585,7 @@ out3:
		reserv_blks);
		}

		trace_mark(ext4_allocate_blocks,
		"dev %s block %llu flags %u len %u ino %lu "
		"logical %llu goal %llu lleft %llu lright %llu "
		"pleft %llu pright %llu ",
		sb->s_id, (unsigned long long) block,
		ar->flags, ar->len, ar->inode ? ar->inode->i_ino : 0,
		(unsigned long long) ar->logical,
		(unsigned long long) ar->goal,
		(unsigned long long) ar->lleft,
		(unsigned long long) ar->lright,
		(unsigned long long) ar->pleft,
		(unsigned long long) ar->pright);
		trace_ext4_allocate_blocks(ar, (unsigned long long)block);

		return block;
		}
		@@ -4740,10 +4720,7 @@ void ext4_mb_free_blocks(handle_t handle, struct inode inode,
		}

		ext4_debug("freeing block %lu\n", block);
		trace_mark(ext4_free_blocks,
		"dev %s block %llu count %lu metadata %d ino %lu",
		sb->s_id, (unsigned long long) block, count, metadata,
		inode ? inode->i_ino : 0);
		trace_ext4_free_blocks(inode, block, count, metadata);

		ac = kmem_cache_alloc(ext4_ac_cachep, GFP_NOFS);
		if (ac) {

fs/ext4/mballoc.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -19,7 +19,6 @@
		#include <linux/seq_file.h>
		#include <linux/version.h>
		#include <linux/blkdev.h>
		#include <linux/marker.h>
		#include <linux/mutex.h>
		#include "ext4_jbd2.h"
		#include "ext4.h"