From patchwork Wed Jan 23 12:03:56 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zheng Liu X-Patchwork-Id: 214903 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 557752C0270 for ; Wed, 23 Jan 2013 22:50:52 +1100 (EST) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755905Ab3AWLuu (ORCPT ); Wed, 23 Jan 2013 06:50:50 -0500 Received: from mail-da0-f49.google.com ([209.85.210.49]:35793 "EHLO mail-da0-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754765Ab3AWLut (ORCPT ); Wed, 23 Jan 2013 06:50:49 -0500 Received: by mail-da0-f49.google.com with SMTP id v40so3741563dad.22 for ; Wed, 23 Jan 2013 03:50:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=x-received:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references; bh=o5wpbDjNfOEbuKi6OKGVgcNQmfMsMcjvNMcBeAp0TTo=; b=iY/E4htCb9BRynpIKoxuceXC0Oh5W0c3rSwzUPo2si3O/iMwOEcB3qTrsbGVa+hlm4 wm2RZ+3diMYATE/Ha1MHHJW2gUItQ4upeIiHzi7RrOusAPXrF7ifHy4iZDHFz7JLohUv sUdc5arZYULQWFCF6SnDBNdtVQS4Bf4VQ02aiB1mAuuudCaS+XXELhbXi1tP0PzWVB8Z SM3LiSsj73fdAms1E+tefmhbe3/nrnMbZmEnMD3UODQj11zGbqCYaur3Acr2lWvYSiSS x2yTRY4CHQo2u8s5Skpv/5xyxG/258lx8xdBX6yPq0eGbs23hRZR7AvJvl5Vzj6z+QXe qxuA== X-Received: by 10.66.72.226 with SMTP id g2mr3734659pav.67.1358941848966; Wed, 23 Jan 2013 03:50:48 -0800 (PST) Received: from lz-desktop.taobao.ali.com ([182.92.247.2]) by mx.google.com with ESMTPS id az8sm13439631pab.3.2013.01.23.03.50.43 (version=TLSv1 cipher=RC4-SHA bits=128/128); Wed, 23 Jan 2013 03:50:47 -0800 (PST) From: Zheng Liu To: linux-ext4@vger.kernel.org, linux-fsdevel@vger.kernel.org Cc: Zheng Liu , "Theodore Ts'o" Subject: [PATCH 06/10 v3] ext4: lookup block mapping in extent status tree Date: Wed, 23 Jan 2013 20:03:56 +0800 Message-Id: <1358942640-2262-7-git-send-email-wenqing.lz@taobao.com> X-Mailer: git-send-email 1.7.12.rc2.18.g61b472e In-Reply-To: <1358942640-2262-1-git-send-email-wenqing.lz@taobao.com> References: <1358942640-2262-1-git-send-email-wenqing.lz@taobao.com> Sender: linux-ext4-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-ext4@vger.kernel.org From: Zheng Liu After tracking all extent status, we already have a extent cache in memory. Every time we want to lookup a block mapping, we can first try to lookup it in extent status tree to avoid a potential disk I/O. A new function called ext4_es_lookup_extent is defined to finish this work. When we try to lookup a block mapping, we always call ext4_map_blocks and/or ext4_da_map_blocks. So in these functions we first try to lookup a block mapping in extent status tree. Signed-off-by: Zheng Liu Cc: "Theodore Ts'o" --- fs/ext4/extents_status.c | 59 +++++++++++++++++++++++++++++++++++++++++++++ fs/ext4/extents_status.h | 1 + fs/ext4/inode.c | 55 ++++++++++++++++++++++++++++++++++++++++++ include/trace/events/ext4.h | 56 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 171 insertions(+) diff --git a/fs/ext4/extents_status.c b/fs/ext4/extents_status.c index 7cbb916..fd4354e 100644 --- a/fs/ext4/extents_status.c +++ b/fs/ext4/extents_status.c @@ -459,6 +459,65 @@ error: return err; } +/* + * ext4_es_lookup_extent() looks up an extent in extent status tree. + * + * ext4_es_lookup_extent is called by ext4_map_blocks/ext4_da_map_blocks. + * + * Return: 1 on found, 0 on not + */ +int ext4_es_lookup_extent(struct inode *inode, struct extent_status *es) +{ + struct ext4_es_tree *tree; + struct extent_status *es1; + struct rb_node *node; + int found = 0; + + trace_ext4_es_lookup_extent_enter(inode, es->es_lblk); + es_debug("lookup extent in block %u\n", es->es_lblk); + + tree = &EXT4_I(inode)->i_es_tree; + read_lock(&EXT4_I(inode)->i_es_lock); + + /* find extent in cache firstly */ + if (tree->cache_es) { + es1 = tree->cache_es; + if (in_range(es->es_lblk, es1->es_lblk, es1->es_len)) { + es_debug("%u cached by [%u/%u)\n", + es->es_lblk, es1->es_lblk, es1->es_len); + found = 1; + goto out; + } + } + + es->es_len = 0; + node = tree->root.rb_node; + while (node) { + es1 = rb_entry(node, struct extent_status, rb_node); + if (es->es_lblk < es1->es_lblk) + node = node->rb_left; + else if (es->es_lblk > ext4_es_end(es1)) + node = node->rb_right; + else { + found = 1; + break; + } + } + +out: + if (found) { + es->es_lblk = es1->es_lblk; + es->es_len = es1->es_len; + es->es_pblk = es1->es_pblk; + es->es_status = es1->es_status; + } + + read_unlock(&EXT4_I(inode)->i_es_lock); + + trace_ext4_es_lookup_extent_exit(inode, es, found); + return found; +} + static int __es_remove_extent(struct ext4_es_tree *tree, ext4_lblk_t lblk, ext4_lblk_t end) { diff --git a/fs/ext4/extents_status.h b/fs/ext4/extents_status.h index 1345c06..6350d35 100644 --- a/fs/ext4/extents_status.h +++ b/fs/ext4/extents_status.h @@ -54,6 +54,7 @@ extern int ext4_es_remove_extent(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len); extern ext4_lblk_t ext4_es_find_extent(struct inode *inode, struct extent_status *es); +extern int ext4_es_lookup_extent(struct inode *inode, struct extent_status *es); static inline int ext4_es_is_written(struct extent_status *es) { diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c index f0dda2a..c86b086 100644 --- a/fs/ext4/inode.c +++ b/fs/ext4/inode.c @@ -508,12 +508,39 @@ static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx, int ext4_map_blocks(handle_t *handle, struct inode *inode, struct ext4_map_blocks *map, int flags) { + struct extent_status es; int retval; map->m_flags = 0; ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u," "logical block %lu\n", inode->i_ino, flags, map->m_len, (unsigned long) map->m_lblk); + + /* Lookup extent status tree firstly */ + es.es_lblk = map->m_lblk; + if (ext4_es_lookup_extent(inode, &es)) { + if (ext4_es_is_written(&es)) { + map->m_pblk = es.es_pblk + map->m_lblk - es.es_lblk; + map->m_flags |= EXT4_MAP_MAPPED; + retval = es.es_len - (map->m_lblk - es.es_lblk); + if (retval > map->m_len) + retval = map->m_len; + map->m_len = retval; + } else if (ext4_es_is_unwritten(&es)) { + map->m_pblk = es.es_pblk + map->m_lblk - es.es_lblk; + map->m_flags |= EXT4_MAP_UNWRITTEN; + retval = es.es_len - (map->m_lblk - es.es_lblk); + if (retval > map->m_len) + retval = map->m_len; + map->m_len = retval; + } else if (ext4_es_is_delayed(&es)) { + retval = 0; + } else { + BUG_ON(1); + } + goto found; + } + /* * Try to see if we can get the block without requesting a new * file system block. @@ -539,6 +566,7 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode, if (!(flags & EXT4_GET_BLOCKS_NO_LOCK)) up_read((&EXT4_I(inode)->i_data_sem)); +found: if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) { int ret = check_block_validity(inode, map); if (ret != 0) @@ -1784,6 +1812,7 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, struct ext4_map_blocks *map, struct buffer_head *bh) { + struct extent_status es; int retval; sector_t invalid_block = ~((sector_t) 0xffff); @@ -1794,6 +1823,32 @@ static int ext4_da_map_blocks(struct inode *inode, sector_t iblock, ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u," "logical block %lu\n", inode->i_ino, map->m_len, (unsigned long) map->m_lblk); + + /* Lookup extent status tree firstly */ + es.es_lblk = iblock; + if (ext4_es_lookup_extent(inode, &es)) { + map->m_pblk = es.es_pblk + iblock - es.es_lblk; + retval = es.es_len - (iblock - es.es_lblk); + if (retval > map->m_len) + retval = map->m_len; + map->m_len = retval; + if (ext4_es_is_written(&es)) { + map->m_flags |= EXT4_MAP_MAPPED; + } else if (ext4_es_is_unwritten(&es)) { + map->m_flags |= EXT4_MAP_UNWRITTEN; + } else if (ext4_es_is_delayed(&es)) { + map_bh(bh, inode->i_sb, invalid_block); + set_buffer_new(bh); + set_buffer_delay(bh); + + return 0; + } else { + BUG_ON(1); + } + + return retval; + } + /* * Try to see if we can get the block without requesting a new * file system block. diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h index 43f335a..f23c177 100644 --- a/include/trace/events/ext4.h +++ b/include/trace/events/ext4.h @@ -2177,6 +2177,62 @@ TRACE_EVENT(ext4_es_find_extent_exit, __entry->pblk, __entry->status, __entry->ret) ); +TRACE_EVENT(ext4_es_lookup_extent_enter, + TP_PROTO(struct inode *inode, ext4_lblk_t lblk), + + TP_ARGS(inode, lblk), + + TP_STRUCT__entry( + __field( dev_t, dev ) + __field( ino_t, ino ) + __field( ext4_lblk_t, lblk ) + ), + + TP_fast_assign( + __entry->dev = inode->i_sb->s_dev; + __entry->ino = inode->i_ino; + __entry->lblk = lblk; + ), + + TP_printk("dev %d,%d ino %lu lblk %u", + MAJOR(__entry->dev), MINOR(__entry->dev), + (unsigned long) __entry->ino, __entry->lblk) +); + +TRACE_EVENT(ext4_es_lookup_extent_exit, + TP_PROTO(struct inode *inode, struct extent_status *es, + int found), + + TP_ARGS(inode, es, found), + + TP_STRUCT__entry( + __field( dev_t, dev ) + __field( ino_t, ino ) + __field( ext4_lblk_t, lblk ) + __field( ext4_lblk_t, len ) + __field( ext4_fsblk_t, pblk ) + __field( int, status ) + __field( int, found ) + ), + + TP_fast_assign( + __entry->dev = inode->i_sb->s_dev; + __entry->ino = inode->i_ino; + __entry->lblk = es->es_lblk; + __entry->len = es->es_len; + __entry->pblk = es->es_pblk; + __entry->status = es->es_status; + __entry->found = found; + ), + + TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %d", + MAJOR(__entry->dev), MINOR(__entry->dev), + (unsigned long) __entry->ino, __entry->found, + __entry->lblk, __entry->len, + __entry->found ? __entry->pblk : 0, + __entry->found ? __entry->status : 0) +); + #endif /* _TRACE_EXT4_H */ /* This part must be outside protection */