Nabble - Xfs - General

xfs in memory corruption

2009-12-18T23:09:00Z

xfs in memory corruption Hi all, got the following error on one of our test machines. SLES10 SP2 with stock kernel

I've not had the chance to scrutinize complete /var/log/messages for additional helpful info.
Any advanced help is appreciated.

thanks!
-Brady

Dec 23 14:21:45 sdw5 kernel: Filesystem "sde": XFS internal error xfs_trans_cancel at line 1175 of file fs/xfs/xfs_trans.c. Caller 0xffffffff8826ca0c
Dec 23 14:21:45 sdw5 kernel:
Dec 23 14:21:45 sdw5 kernel: Call Trace: <ffffffff88265456>{:xfs:xfs_trans_cancel+91}
Dec 23 14:21:45 sdw5 kernel:        <ffffffff8826ca0c>{:xfs:xfs_create+1395} <ffffffff8827700b>{:xfs:xfs_vn_mknod+429}
Dec 23 14:21:45 sdw5 kernel:        <ffffffff80192f3a>{vfs_create+390} <ffffffff801962cf>{open_namei+421}
Dec 23 14:21:45 sdw5 kernel:        <ffffffff80184313>{do_filp_open+28} <ffffffff80184374>{do_sys_open+69}
Dec 23 14:21:45 sdw5 kernel:        <ffffffff8010ae42>{system_call+126}
Dec 23 14:21:45 sdw5 kernel: xfs_force_shutdown(sde,0x8) called from line 1176 of file fs/xfs/xfs_trans.c. Return address = 0xffffffff88265475
Dec 23 14:21:45 sdw5 kernel: postgres[5990]: segfault at 00007fff36319618 rip 0000000000999556 rsp 00007fff36319620 error 6
Dec 23 14:21:45 sdw5 kernel: postgres[6152]: segfault at 00007fffd0793e00 rip 00002ab7dad22d0d rsp 00007fffd0793dd0 error 6
Dec 23 14:21:45 sdw5 kernel: Filesystem "sde": Corruption of in-memory data detected. Shutting down filesystem: sde
Dec 23 14:21:45 sdw5 kernel: Please umount the filesystem, and rectify the problem(s)
Dec 23 14:21:45 sdw5 kernel: postgres[6170]: segfault at 00007fff5eb9efd0 rip 00002aff4c918d0d rsp 00007fff5eb9efa0 error 6
Dec 23 14:21:45 sdw5 kernel: postgres[6062]: segfault at 00007fff32585878 rip 0000000000999556 rsp 00007fff32585880 error 6
_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[XFS updates] XFS development tree branch, master, updated. v2.6.30-rc4-24758-gf8c89a9

2009-12-16T20:32:20Z

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "XFS development tree".

The branch, master has been updated
f8c89a9 xfs: kill some warnings on i386 builds
from 47e96ea6187f0ea7322d9beedc046a5409c4d45e (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit f8c89a9e39a10448543c8dc720626d4cf7f2ec49
Author: Dave Chinner <david@...>
Date: Thu Dec 17 00:20:07 2009 +0000

xfs: kill some warnings on i386 builds

Randy Dunlap Reported printk() format-related warnings reported
on i386 builds in his environment. Dave Chinner provided this
patch to eliminate them.

Signed-off by: Dave Chinner <david@...>
Acked-by: Randy Dunlap <randy.dunlap@...>

Signed-off-by: Alex Elder <aelder@...>

-----------------------------------------------------------------------

Summary of changes:
fs/xfs/linux-2.6/xfs_trace.h | 8 ++++----
1 files changed, 4 insertions(+), 4 deletions(-)

hooks/post-receive
--
XFS development tree

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

RE: [GIT PULL] XFS update for 2.6.33-rc1

2009-12-16T19:41:12Z

Dave Chinner wrote:

I didn't get them either when I built in my environment.

Dave, your patch looks good to me, and Randy has acked it
so I'm going to pull it into our XFS top-of-tree. I'll
hold off sending yet another pull request to Linus for
now. Thanks for addressing it quickly.

-Alex

> /me hates gcc's warning inconsistencies with a passion.
>
>> e.g.:
>>
>> In file included from linux-next-20091216/include/trace/ftrace.h:398,
>> from linux-next-20091216/include/trace/define_trace.h:69,
>> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.h:1369,
>> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.c:75:
>> linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function
>> 'ftrace_raw_output_id_xfs_iomap_enter': linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:830:
>> warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type
>> 'xfs_fsblock_t'
>
> Patch that should fix this below.
>
> Cheers,
>
> Dave.

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [GIT PULL] XFS update for 2.6.33-rc1

2009-12-16T17:56:16Z

Dave Chinner wrote:

> On Wed, Dec 16, 2009 at 01:55:12PM -0800, Randy Dunlap wrote:
>> On Wed, 16 Dec 2009 15:26:10 -0600 Alex Elder wrote:
>>
>>> One more XFS update for -rc1, now that the new XFS tracing code has
>>> been committed.
>> Sorry if I have missed it, but have the printk format warnings
>> on i386 builds been fixed?
>
> I don't see any here w/ gcc 4.3.4 x86-64 compiling i386 kernels....
>
> /me hates gcc's warning inconsistencies with a passion.
>
>> e.g.:
>>
>> In file included from linux-next-20091216/include/trace/ftrace.h:398,
>> from linux-next-20091216/include/trace/define_trace.h:69,
>> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.h:1369,
>> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.c:75:
>> linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_iomap_enter':
>> linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:830: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'xfs_fsblock_t'
>
> Patch that should fix this below.

Yes, thanks for that.

Acked-by: Randy Dunlap <randy.dunlap@...>

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [GIT PULL] XFS update for 2.6.33-rc1

2009-12-16T16:20:07Z

On Wed, Dec 16, 2009 at 01:55:12PM -0800, Randy Dunlap wrote:
> On Wed, 16 Dec 2009 15:26:10 -0600 Alex Elder wrote:
>
> > One more XFS update for -rc1, now that the new XFS tracing code has
> > been committed.
>
> Sorry if I have missed it, but have the printk format warnings
> on i386 builds been fixed?

I don't see any here w/ gcc 4.3.4 x86-64 compiling i386 kernels....

/me hates gcc's warning inconsistencies with a passion.

> e.g.:
>
> In file included from linux-next-20091216/include/trace/ftrace.h:398,
> from linux-next-20091216/include/trace/define_trace.h:69,
> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.h:1369,
> from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.c:75:
> linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_iomap_enter':
> linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:830: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'xfs_fsblock_t'

Patch that should fix this below.

Cheers,

Dave.
--
Dave Chinner
david@...

XFS: Format xfs_fsblock_t correctly in tracing code.

Fixes printk build warnings on i386.

Reported-by: Randy Dunlap <randy.dunlap@...>
Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/linux-2.6/xfs_trace.h | 8 ++++----
1 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/xfs/linux-2.6/xfs_trace.h b/fs/xfs/linux-2.6/xfs_trace.h
index c40834b..d4ded59 100644
--- a/fs/xfs/linux-2.6/xfs_trace.h
+++ b/fs/xfs/linux-2.6/xfs_trace.h
@@ -815,7 +815,7 @@ TRACE_EVENT(name, \
), \
TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx " \
"offset 0x%llx count %zd flags %s " \
- "startoff 0x%llx startblock 0x%llx blockcount 0x%llx", \
+ "startoff 0x%llx startblock %s blockcount 0x%llx", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__entry->size, \
@@ -824,7 +824,7 @@ TRACE_EVENT(name, \
__entry->count, \
__print_flags(__entry->flags, "|", BMAPI_FLAGS), \
__entry->startoff, \
- __entry->startblock, \
+ xfs_fmtfsblock(__entry->startblock), \
__entry->blockcount) \
)
DEFINE_IOMAP_EVENT(xfs_iomap_enter);
@@ -1201,7 +1201,7 @@ TRACE_EVENT(name, \
TP_printk("dev %d:%d agno %u agbno %u minlen %u maxlen %u mod %u " \
"prod %u minleft %u total %u alignment %u minalignslop %u " \
"len %u type %s otype %s wasdel %d wasfromfl %d isfl %d " \
- "userdata %d firstblock 0x%llx", \
+ "userdata %d firstblock %s", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->agno, \
__entry->agbno, \
@@ -1220,7 +1220,7 @@ TRACE_EVENT(name, \
__entry->wasfromfl, \
__entry->isfl, \
__entry->userdata, \
- __entry->firstblock) \
+ xfs_fmtfsblock(__entry->firstblock)) \
)

DEFINE_ALLOC_EVENT(xfs_alloc_exact_done);

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [GIT PULL] XFS update for 2.6.33-rc1

2009-12-16T13:55:12Z

On Wed, 16 Dec 2009 15:26:10 -0600 Alex Elder wrote:

> One more XFS update for -rc1, now that the new XFS tracing code has
> been committed.

Sorry if I have missed it, but have the printk format warnings
on i386 builds been fixed?

e.g.:

In file included from linux-next-20091216/include/trace/ftrace.h:398,
from linux-next-20091216/include/trace/define_trace.h:69,
from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.h:1369,
from linux-next-20091216/fs/xfs/linux-2.6/xfs_trace.c:75:
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_iomap_enter':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:830: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_iomap_found':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:831: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_iomap_alloc':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:832: warning: format '%llx' expects type 'long long unsigned int', but argument 12 has type 'xfs_fsblock_t'
LD drivers/media/IR/ir-common.o
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_exact_done':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1226: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_exact_error':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1227: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_near_nominleft':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1228: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_near_first': LD drivers/media/IR/built-in.o

linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1229: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_near_greater':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1230: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_near_lesser':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1231: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_near_error':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1232: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_size_neither':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1233: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_size_noentry':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1234: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_size_nominleft':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1235: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_size_done':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1236: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_size_error':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1237: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_small_freelist':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1238: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_small_notenough':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1239: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_small_done':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1240: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_small_error':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1241: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_vextent_badargs':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1242: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_vextent_nofix':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1243: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_vextent_noagbp':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1244: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_vextent_loopfailed':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1245: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h: In function 'ftrace_raw_output_id_xfs_alloc_vextent_allfailed':
linux-next-20091216/fs/xfs/linux-2.6/./xfs_trace.h:1246: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'

> -Alex
>
> The following changes since commit 5ac4d630eb87656bd4dc313b910776d54d88ea28:
> Linus Torvalds (1):
> Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block
>
> are available in the git repository at:
>
> git://oss.sgi.com/xfs/xfs for-linus
>
> Christoph Hellwig (2):
> xfs: check for not fully initialized inodes in xfs_ireclaim
> xfs: kill xfs_bmbt_rec_32/64 types
>
> Dave Chinner (2):
> xfs: improve metadata I/O merging in the elevator
> XFS: Free buffer pages array unconditionally
>
> fs/xfs/linux-2.6/xfs_buf.c | 10 +++++++---
> fs/xfs/linux-2.6/xfs_buf.h | 1 +
> fs/xfs/xfs_bmap_btree.h | 14 +++-----------
> fs/xfs/xfs_iget.c | 12 ++++++++----
> fs/xfs/xfs_inode_item.h | 6 +++---
> fs/xfs/xfs_log.c | 2 ++
> include/linux/fs.h | 1 +
> 7 files changed, 25 insertions(+), 21 deletions(-)

---
~Randy

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[GIT PULL] XFS update for 2.6.33-rc1

2009-12-16T13:26:10Z

One more XFS update for -rc1, now that the new XFS tracing code has
been committed.

-Alex

The following changes since commit 5ac4d630eb87656bd4dc313b910776d54d88ea28:
Linus Torvalds (1):
Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block

are available in the git repository at:

git://oss.sgi.com/xfs/xfs for-linus

Christoph Hellwig (2):
xfs: check for not fully initialized inodes in xfs_ireclaim
xfs: kill xfs_bmbt_rec_32/64 types

Dave Chinner (2):
xfs: improve metadata I/O merging in the elevator
XFS: Free buffer pages array unconditionally

fs/xfs/linux-2.6/xfs_buf.c | 10 +++++++---
fs/xfs/linux-2.6/xfs_buf.h | 1 +
fs/xfs/xfs_bmap_btree.h | 14 +++-----------
fs/xfs/xfs_iget.c | 12 ++++++++----
fs/xfs/xfs_inode_item.h | 6 +++---
fs/xfs/xfs_log.c | 2 ++
include/linux/fs.h | 1 +
7 files changed, 25 insertions(+), 21 deletions(-)

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[XFS updates] XFS development tree branch, for-linus, updated. v2.6.30-rc4-32819-g3fc98b1

2009-12-16T13:20:39Z

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "XFS development tree".

The branch, for-linus has been updated
3fc98b1 XFS: Free buffer pages array unconditionally
a5f9be5 xfs: kill xfs_bmbt_rec_32/64 types
2ee1aba xfs: improve metadata I/O merging in the elevator
b44b112 xfs: check for not fully initialized inodes in xfs_ireclaim
5fe878a direct-io: cleanup blockdev_direct_IO locking
d180ec5 Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
03daa57 fs/xfs/xfs_log_recover.c: use %pU to print UUIDs
from 0b1b213fcf3a8486ada99a2bab84ab8c6f51b264 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 3fc98b1ac036675b95f6e3fafd5ef147b97d4d30
Author: Dave Chinner <david@...>
Date: Mon Dec 14 23:11:57 2009 +0000

XFS: Free buffer pages array unconditionally

The code in xfs_free_buf() only attempts to free the b_pages array if the
buffer is a page cache backed or page allocated buffer. The extra log buffer
that is used when the log wraps uses pages that are allocated to a different
log buffer, but it still has a b_pages array allocated when those pages
are associated to with the extra buffer in xfs_buf_associate_memory.

Hence we need to always attempt to free the b_pages array when tearing
down a buffer, not just on buffers that are explicitly marked as page bearing
buffers. This fixes a leak detected by the kernel memory leak code.

Signed-off-by: Dave Chinner <david@...>
Signed-off-by: Alex Elder <aelder@...>

commit a5f9be58c2b87106100a6053d09b1f9f8d551c6e
Author: Christoph Hellwig <hch@...>
Date: Fri Dec 4 10:19:07 2009 +0000

xfs: kill xfs_bmbt_rec_32/64 types

For a long time we've always stored bmap btree records in the 64bit format,
so kill off the dead 32bit type, and make sure the 64bit type is named just
xfs_bmbt_rec everywhere, without any size postfix.

Signed-off-by: Christoph Hellwig <hch@...>
Reviewed-by: Eric Sandeen <sandeen@...>
Signed-off-by: Alex Elder <aelder@...>

commit 2ee1abad73a12df5521cd3f017f081f1f684a361
Author: Dave Chinner <dgc@...>
Date: Tue Nov 24 18:03:15 2009 +0000

xfs: improve metadata I/O merging in the elevator

Change all async metadata buffers to use [READ|WRITE]_META I/O types
so that the I/O doesn't get issued immediately. This allows merging of
adjacent metadata requests but still prioritises them over bulk data.
This shows a 10-15% improvement in sequential create speed of small
files.

Don't include the log buffers in this classification - leave them as
sync types so they are issued immediately.

Signed-off-by: Dave Chinner <dgc@...>
Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit b44b1126279b60597f96bbe77507b1650f88a969
Author: Christoph Hellwig <hch@...>
Date: Tue Dec 1 18:12:29 2009 +0000

xfs: check for not fully initialized inodes in xfs_ireclaim

Add an assert for inodes not added to the inode cache in xfs_ireclaim,
to make sure we're not going to introduce something like the
famous nfsd inode cache bug again.

Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit 5fe878ae7f82fbf0830dbfaee4c5ca18f3aee442
Author: Christoph Hellwig <hch@...>
Date: Tue Dec 15 16:47:50 2009 -0800

direct-io: cleanup blockdev_direct_IO locking

Currently the locking in blockdev_direct_IO is a mess, we have three
different locking types and very confusing checks for some of them. The
most complicated one is DIO_OWN_LOCKING for reads, which happens to not
actually be used.

This patch gets rid of the DIO_OWN_LOCKING - as mentioned above the read
case is unused anyway, and the write side is almost identical to
DIO_NO_LOCKING. The difference is that DIO_NO_LOCKING always sets the
create argument for the get_blocks callback to zero, but we can easily
move that to the actual get_blocks callbacks. There are four users of the
DIO_NO_LOCKING mode: gfs already ignores the create argument and thus is
fine with the new version, ocfs2 only errors out if create were ever set,
and we can remove this dead code now, the block device code only ever uses
create for an error message if we are fully beyond the device which can
never happen, and last but not least XFS will need the new behavour for
writes.

Now we can replace the lock_type variable with a flags one, where no flag
means the DIO_NO_LOCKING behaviour and DIO_LOCKING is kept as the first
flag. Separate out the check for not allowing to fill holes into a
separate flag, although for now both flags always get set at the same
time.

Also revamp the documentation of the locking scheme to actually make
sense.

[akpm@...: coding-style fixes]
Signed-off-by: Christoph Hellwig <hch@...>
Cc: Dave Chinner <david@...>
Cc: Badari Pulavarty <pbadari@...>
Cc: Jeff Moyer <jmoyer@...>
Cc: Jens Axboe <jens.axboe@...>
Cc: Zach Brown <zach.brown@...>
Cc: Al Viro <viro@...>
Cc: Alex Elder <aelder@...>
Cc: Mark Fasheh <mfasheh@...>
Cc: Joel Becker <joel.becker@...>
Signed-off-by: Andrew Morton <akpm@...>
Signed-off-by: Linus Torvalds <torvalds@...>

commit d180ec5d348e3a51836d723c182374483012c981
Merge: 53365383c4667aba55385cd1858582c19a7a8a36 0b1b213fcf3a8486ada99a2bab84ab8c6f51b264
Author: Linus Torvalds <torvalds@...>
Date: Tue Dec 15 09:12:43 2009 -0800

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

* 'for-linus' of git://oss.sgi.com/xfs/xfs:
xfs: event tracing support
xfs: change the xfs_iext_insert / xfs_iext_remove
xfs: cleanup bmap extent state macros

commit 03daa57cdb2198e36a41ca1f63a030759490363f
Author: Joe Perches <joe@...>
Date: Mon Dec 14 18:01:10 2009 -0800

fs/xfs/xfs_log_recover.c: use %pU to print UUIDs

Signed-off-by: Joe Perches <joe@...>
Acked-by: Alex Elder <aelder@...>
Cc: Christoph Hellwig <hch@...>
Signed-off-by: Andrew Morton <akpm@...>
Signed-off-by: Linus Torvalds <torvalds@...>

-----------------------------------------------------------------------

Summary of changes:
fs/xfs/linux-2.6/xfs_aops.c | 20 +++++++-------------
fs/xfs/linux-2.6/xfs_buf.c | 10 +++++++---
fs/xfs/linux-2.6/xfs_buf.h | 1 +
fs/xfs/xfs_bmap_btree.h | 14 +++-----------
fs/xfs/xfs_iget.c | 12 ++++++++----
fs/xfs/xfs_inode_item.h | 6 +++---
fs/xfs/xfs_log.c | 2 ++
fs/xfs/xfs_log_recover.c | 14 ++++----------
8 files changed, 35 insertions(+), 44 deletions(-)

hooks/post-receive
--
XFS development tree

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[XFS updates] XFS development tree branch, master, updated. v2.6.30-rc4-24757-g47e96ea

2009-12-16T11:55:44Z

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "XFS development tree".

The branch, master has been updated
47e96ea XFS: Free buffer pages array unconditionally
2402c09 xfs: kill xfs_bmbt_rec_32/64 types
79c3f79 xfs: improve metadata I/O merging in the elevator
26d56b2 xfs: check for not fully initialized inodes in xfs_ireclaim
from d0c156230fa510e7e091e60d4c9c3ea7bd96edf6 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 47e96ea6187f0ea7322d9beedc046a5409c4d45e
Author: Dave Chinner <david@...>
Date: Mon Dec 14 23:11:57 2009 +0000

XFS: Free buffer pages array unconditionally

The code in xfs_free_buf() only attempts to free the b_pages array if the
buffer is a page cache backed or page allocated buffer. The extra log buffer
that is used when the log wraps uses pages that are allocated to a different
log buffer, but it still has a b_pages array allocated when those pages
are associated to with the extra buffer in xfs_buf_associate_memory.

Hence we need to always attempt to free the b_pages array when tearing
down a buffer, not just on buffers that are explicitly marked as page bearing
buffers. This fixes a leak detected by the kernel memory leak code.

Signed-off-by: Dave Chinner <david@...>
Signed-off-by: Alex Elder <aelder@...>

commit 2402c0970562d7c815a23db92827af1c33a34fad
Author: Christoph Hellwig <hch@...>
Date: Fri Dec 4 10:19:07 2009 +0000

xfs: kill xfs_bmbt_rec_32/64 types

For a long time we've always stored bmap btree records in the 64bit format,
so kill off the dead 32bit type, and make sure the 64bit type is named just
xfs_bmbt_rec everywhere, without any size postfix.

Signed-off-by: Christoph Hellwig <hch@...>
Reviewed-by: Eric Sandeen <sandeen@...>
Signed-off-by: Alex Elder <aelder@...>

commit 79c3f79f1cfc128410293a400921bef7ba42d37e
Author: Dave Chinner <dgc@...>
Date: Tue Nov 24 18:03:15 2009 +0000

xfs: improve metadata I/O merging in the elevator

Change all async metadata buffers to use [READ|WRITE]_META I/O types
so that the I/O doesn't get issued immediately. This allows merging of
adjacent metadata requests but still prioritises them over bulk data.
This shows a 10-15% improvement in sequential create speed of small
files.

Don't include the log buffers in this classification - leave them as
sync types so they are issued immediately.

Signed-off-by: Dave Chinner <dgc@...>
Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit 26d56b2f0597d0529f829629f6f1873356c4a9b2
Author: Christoph Hellwig <hch@...>
Date: Tue Dec 1 18:12:29 2009 +0000

xfs: check for not fully initialized inodes in xfs_ireclaim

Add an assert for inodes not added to the inode cache in xfs_ireclaim,
to make sure we're not going to introduce something like the
famous nfsd inode cache bug again.

Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

-----------------------------------------------------------------------

Summary of changes:
fs/xfs/linux-2.6/xfs_buf.c | 10 +++++++---
fs/xfs/linux-2.6/xfs_buf.h | 1 +
fs/xfs/xfs_bmap_btree.h | 14 +++-----------
fs/xfs/xfs_iget.c | 12 ++++++++----
fs/xfs/xfs_inode_item.h | 6 +++---
fs/xfs/xfs_log.c | 2 ++
6 files changed, 24 insertions(+), 21 deletions(-)

hooks/post-receive
--
XFS development tree

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

pescaria por kilo

2009-12-15T19:00:53Z

grana

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

missao.zip (-1 bytes) Download Attachment

RE: [PATCH] XFS: Free buffer pages array unconditionally

2009-12-15T14:51:31Z

Dave Chinner wrote:
> On Tue, Dec 15, 2009 at 01:21:36PM -0600, Alex Elder wrote:
>> Dave Chinner wrote:
>>> The code in xfs_free_buf() only attempts to free the b_pages array if the
>>> buffer is a page cache backed or page allocated buffer. The extra log buffer
>>> that is used when the log wraps uses pages that are allocated to a different
>>> log buffer, but it still has a b_pages array allocated when those pages
>>> are associated to with the extra buffer in xfs_buf_associate_memory.

I get it now. You're right, I was confusing the array
with the pages themselves. And in hindsight the title
of your patch and the explanation is abundantly clear
on what's being freed... Thank you for carefully
explaining it to me (again).

The patch looks good.

-Alex

Reviewed-by: Alex Elder <aelder@...>

>>> Hence we need to always attempt to free the b_pages array when tearing
>>> down a buffer, not just on buffers that are explicitly marked as page bearing
>>> buffers. This fixes a leak detected by the kernel memory leak code.
>>
>> Three places call xfs_buf_get_pages();
>> - _xfs_buf_lookup_pages(), which sets the _XBF_PAGE_CACHE flag in the buffer after the call
>> - xfs_buf_associate_memory(), which sets no flag bit
>> - xfs_buf_get_noaddr(), which sets the _XBF_PAGES flag.
>>
>> The only place that checks for _XBF_PAGES is xfs_buf_free().
>>
>> Given that, I have two comments:
>> - You could just as easily have set the _XBF_PAGES flag in
>> xfs_buf_associate_memory, thereby making that flag indicate
>> consistently that the buffer has allocated pages
>
> _XBF_PAGES is used to indicate that the buffer owns the
> pages and must free them when the buffer is freed.
>
> _XBF_PAGE_CACHE indicates pages are allocated out of the buftarg
> page cache and need to be released when the buffer is freed.
>
> In both cases, xfs_buf_free() has to free the pages
> associated with these buffers.
>
> In the case of xfs_buf_associate_memory(), the memory attached to
> the buffer is owned by an external entity and hence we are not
> allowed to free it when we free the buffer. Therefore we can't set
> _XBF_PAGES on the buffer.
>
>> - Or, since you are proposing unconditionally freeing the
>> pages,
>
> This change doesn't unconditionally free the pages attached
> to the buffer - it unconditionally frees the array used to
> index the pages on the buffer when the buffer is torn down.
> i.e:
>
> +------+ +------+
> | bp | | |-------> page
> | | b_pages | |-------> page
> | |-------->| |.............
> | | | |-------> page
> | | | |-------> page
> +------+ +------+
> ^^^^^^
> This array is what we are
> freeing unconditionally.
>
> Cheers,
>
> Dave.

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH] XFS: Free buffer pages array unconditionally

2009-12-15T14:36:58Z

On Tue, Dec 15, 2009 at 01:21:36PM -0600, Alex Elder wrote:

> Dave Chinner wrote:
> > The code in xfs_free_buf() only attempts to free the b_pages array if the
> > buffer is a page cache backed or page allocated buffer. The extra log buffer
> > that is used when the log wraps uses pages that are allocated to a different
> > log buffer, but it still has a b_pages array allocated when those pages
> > are associated to with the extra buffer in xfs_buf_associate_memory.
> >
> > Hence we need to always attempt to free the b_pages array when tearing
> > down a buffer, not just on buffers that are explicitly marked as page bearing
> > buffers. This fixes a leak detected by the kernel memory leak code.
>
> Three places call xfs_buf_get_pages();
> - _xfs_buf_lookup_pages(), which sets the _XBF_PAGE_CACHE flag in the
> buffer after the call
> - xfs_buf_associate_memory(), which sets no flag bit
> - xfs_buf_get_noaddr(), which sets the _XBF_PAGES flag.
>
> The only place that checks for _XBF_PAGES is xfs_buf_free().
>
> Given that, I have two comments:
> - You could just as easily have set the _XBF_PAGES flag in
> xfs_buf_associate_memory, thereby making that flag indicate
> consistently that the buffer has allocated pages

_XBF_PAGES is used to indicate that the buffer owns the
pages and must free them when the buffer is freed.

_XBF_PAGE_CACHE indicates pages are allocated out of the buftarg
page cache and need to be released when the buffer is freed.

In both cases, xfs_buf_free() has to free the pages
associated with these buffers.

In the case of xfs_buf_associate_memory(), the memory attached to
the buffer is owned by an external entity and hence we are not
allowed to free it when we free the buffer. Therefore we can't set
_XBF_PAGES on the buffer.

> - Or, since you are proposing unconditionally freeing the
> pages,

This change doesn't unconditionally free the pages attached
to the buffer - it unconditionally frees the array used to
index the pages on the buffer when the buffer is torn down.
i.e:

+------+ +------+
| bp | | |-------> page
| | b_pages | |-------> page
| |-------->| |.............
| | | |-------> page
| | | |-------> page
+------+ +------+
^^^^^^
This array is what we are
freeing unconditionally.

Cheers,

Dave.
--
Dave Chinner
david@...

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

RE: [PATCH v2] xfs: improve metadata I/O merging in the elevator

2009-12-15T12:12:26Z

Christoph Hellwig wrote:

> From: Dave Chinner <dgc@...>
>
> Change all async metadata buffers to use [READ|WRITE]_META I/O types
> so that the I/O doesn't get issued immediately. This allows merging
> of adjacent metadata requests but still prioritises them over bulk
> data. This shows a 10-15% improvement in sequential create speed of
> small files.
>
> Don't include the log buffers in this classification - leave them
> as sync types so they are issued immediately.

Looks good.

> Signed-off-by: Dave Chinner <dgc@...>
> Signed-off-by: Christoph Hellwig <hch@...>

Reviewed-by: Alex Elder <aelder@...>

> Index: xfs/fs/xfs/linux-2.6/xfs_buf.c
> ===================================================================
> --- xfs.orig/fs/xfs/linux-2.6/xfs_buf.c 2009-11-16 12:03:21.940253900 +0100
> +++ xfs/fs/xfs/linux-2.6/xfs_buf.c 2009-11-16 12:05:54.224256517 +0100
> @@ -1177,10 +1177,14 @@ _xfs_buf_ioapply(
> if (bp->b_flags & XBF_ORDERED) {
> ASSERT(!(bp->b_flags & XBF_READ));
> rw = WRITE_BARRIER;
> - } else if (bp->b_flags & _XBF_RUN_QUEUES) {
> + } else if (bp->b_flags & XBF_LOG_BUFFER) {
> ASSERT(!(bp->b_flags & XBF_READ_AHEAD));
> bp->b_flags &= ~_XBF_RUN_QUEUES;
> rw = (bp->b_flags & XBF_WRITE) ? WRITE_SYNC : READ_SYNC;
> + } else if (bp->b_flags & _XBF_RUN_QUEUES) {
> + ASSERT(!(bp->b_flags & XBF_READ_AHEAD));
> + bp->b_flags &= ~_XBF_RUN_QUEUES;
> + rw = (bp->b_flags & XBF_WRITE) ? WRITE_META : READ_META;
> } else {
> rw = (bp->b_flags & XBF_WRITE) ? WRITE :
> (bp->b_flags & XBF_READ_AHEAD) ? READA : READ;
> Index: xfs/fs/xfs/linux-2.6/xfs_buf.h
> ===================================================================
> --- xfs.orig/fs/xfs/linux-2.6/xfs_buf.h 2009-11-16 12:03:21.945261731 +0100
> +++ xfs/fs/xfs/linux-2.6/xfs_buf.h 2009-11-16 12:03:23.796003934 +0100
> @@ -55,6 +55,7 @@ typedef enum {
> XBF_FS_MANAGED = (1 << 8), /* filesystem controls freeing memory */
> XBF_ORDERED = (1 << 11), /* use ordered writes */
> XBF_READ_AHEAD = (1 << 12), /* asynchronous read-ahead */
> + XBF_LOG_BUFFER = (1 << 13), /* this is a buffer used for the log */
>
> /* flags used only as arguments to access routines */
> XBF_LOCK = (1 << 14), /* lock requested */
> Index: xfs/fs/xfs/xfs_log.c
> ===================================================================
> --- xfs.orig/fs/xfs/xfs_log.c 2009-11-16 12:03:21.952261854 +0100
> +++ xfs/fs/xfs/xfs_log.c 2009-11-16 12:03:23.798003071 +0100
> @@ -1524,6 +1524,7 @@ xlog_sync(xlog_t *log,
> XFS_BUF_ZEROFLAGS(bp);
> XFS_BUF_BUSY(bp);
> XFS_BUF_ASYNC(bp);
> + bp->b_flags |= XBF_LOG_BUFFER;
> /*
> * Do an ordered write for the log block.
> * Its unnecessary to flush the first split block in the log wrap case.
> @@ -1561,6 +1562,7 @@ xlog_sync(xlog_t *log,
> XFS_BUF_ZEROFLAGS(bp);
> XFS_BUF_BUSY(bp);
> XFS_BUF_ASYNC(bp);
> + bp->b_flags |= XBF_LOG_BUFFER;
> if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
> XFS_BUF_ORDERED(bp);
> dptr = XFS_BUF_PTR(bp);
> Index: xfs/include/linux/fs.h
> ===================================================================
> --- xfs.orig/include/linux/fs.h 2009-11-16 12:04:49.799002997 +0100
> +++ xfs/include/linux/fs.h 2009-11-16 12:05:10.130255677 +0100
> @@ -151,6 +151,7 @@ struct inodes_stat_t {
> #define READ_META (READ | (1 << BIO_RW_META))
> #define WRITE_SYNC_PLUG (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
> #define WRITE_SYNC (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
> +#define WRITE_META (WRITE | (1 << BIO_RW_META))
> #define WRITE_ODIRECT (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
> #define SWRITE_SYNC_PLUG \
> (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
>
> _______________________________________________
> xfs mailing list
> xfs@...
> http://oss.sgi.com/mailman/listinfo/xfs

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

RE: [PATCH V2] xfs: check for not fully initialized inodes in xfs_ireclaim

2009-12-15T12:05:15Z

Christoph Hellwig wrote:
> Add an assert for inodes not added to the inode cache in xfs_ireclaim, to make
> sure we're not going to introduce something like the famous nfsd inode cache
> bug again.

It's a shame we can't do more than an ASSERT() here
(for non-debug builds).

Looks good though.

> Signed-off-by: Christoph Hellwig <hch@...>

Reviewed-by: Alex Elder <aelder@...>

> Index: xfs/fs/xfs/xfs_iget.c
> ===================================================================
> --- xfs.orig/fs/xfs/xfs_iget.c 2009-11-26 19:10:47.206253628 +0100
> +++ xfs/fs/xfs/xfs_iget.c 2009-12-01 19:09:43.310004091 +0100
> @@ -514,17 +514,21 @@ xfs_ireclaim(
> {
> struct xfs_mount *mp = ip->i_mount;
> struct xfs_perag *pag;
> + xfs_agino_t agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
>
> XFS_STATS_INC(xs_ig_reclaims);
>
> /*
> - * Remove the inode from the per-AG radix tree. It doesn't matter
> - * if it was never added to it because radix_tree_delete can deal
> - * with that case just fine.
> + * Remove the inode from the per-AG radix tree.
> + *
> + * Because radix_tree_delete won't complain even if the item was never
> + * added to the tree assert that it's been there before to catch
> + * problems with the inode life time early on.
> */
> pag = xfs_get_perag(mp, ip->i_ino);
> write_lock(&pag->pag_ici_lock);
> - radix_tree_delete(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ip->i_ino));
> + if (!radix_tree_delete(&pag->pag_ici_root, agino))
> + ASSERT(0);
> write_unlock(&pag->pag_ici_lock);
> xfs_put_perag(mp, pag);
>
>
> _______________________________________________
> xfs mailing list
> xfs@...
> http://oss.sgi.com/mailman/listinfo/xfs

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

RE: [PATCH] XFS: Free buffer pages array unconditionally

2009-12-15T11:21:36Z

Dave Chinner wrote:
> The code in xfs_free_buf() only attempts to free the b_pages array if the
> buffer is a page cache backed or page allocated buffer. The extra log buffer
> that is used when the log wraps uses pages that are allocated to a different
> log buffer, but it still has a b_pages array allocated when those pages
> are associated to with the extra buffer in xfs_buf_associate_memory.
>
> Hence we need to always attempt to free the b_pages array when tearing
> down a buffer, not just on buffers that are explicitly marked as page bearing
> buffers. This fixes a leak detected by the kernel memory leak code.

Three places call xfs_buf_get_pages();
- _xfs_buf_lookup_pages(), which sets the _XBF_PAGE_CACHE flag in the
buffer after the call
- xfs_buf_associate_memory(), which sets no flag bit
- xfs_buf_get_noaddr(), which sets the _XBF_PAGES flag.

The only place that checks for _XBF_PAGES is xfs_buf_free().

Given that, I have two comments:
- You could just as easily have set the _XBF_PAGES flag in
xfs_buf_associate_memory, thereby making that flag indicate
consistently that the buffer has allocated pages
- Or, since you are proposing unconditionally freeing the
pages, we can perhaps drop the _XBF_PAGES flag altogether
since it no longer serves much purpose. (I prefer this.)

-Alex

> Signed-off-by: Dave Chinner <david@...>
> ---
> fs/xfs/linux-2.6/xfs_buf.c | 4 ++--
> 1 files changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
> index 4ddc973..529d6a6 100644
> --- a/fs/xfs/linux-2.6/xfs_buf.c
> +++ b/fs/xfs/linux-2.6/xfs_buf.c
> @@ -318,6 +318,7 @@ _xfs_buf_free_pages(
> {
> if (bp->b_pages != bp->b_page_array) {
> kmem_free(bp->b_pages);
> + bp->b_pages = NULL;
> }
> }
>
> @@ -349,9 +350,8 @@ xfs_buf_free(
> ASSERT(!PagePrivate(page));
> page_cache_release(page);
> }
> - _xfs_buf_free_pages(bp);
> }
> -
> + _xfs_buf_free_pages(bp);
> xfs_buf_deallocate(bp);
> }

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: Disappointing performance of copy (MD raid + XFS)

2009-12-15T08:53:23Z

Kasper Sandberg wrote:

> On Fri, 2009-12-11 at 14:26 +1100, Dave Chinner wrote:
>> On Fri, Dec 11, 2009 at 02:41:32AM +0100, Asdo wrote:
>>> I have checked the other problem I had which I was mentioning, that I
> <snip>
>>> Also with noalign and rotorstep at 255 the stripe_cache_size stays
>>> usually in the lower half (below 16000 out of 32000) while with defaults
>>> it's stuck for most of the time at the maximum and processes are stuck
>>> sleeping in MD locks for this reason.
>> That really does sound like a misaligned filesystem - the stripe
>> cache will grow larger the more RMW cycles that need to be
>> performed...
> Sorry to interrupt, I would very much like to see if my array/xfs is
> properly aligned and all that stuff which has been mentioned inhere,
> could any of you please post the things required to check? filesystem is
> straight on md raid6, debian lenny.
>
>
> <snip>
>

use xfs_info on your mountpoint, and compare the stripe unit and width
to what md tells you. xfs_info stripe unit/width output is in fs blocks
units.

-Eric

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[GIT PULL] XFS update for 2.6.33-rc1

2009-12-15T07:01:01Z

This is a rather pervasive change to XFS code that switches it from
using its own internal tracing mechanism to instead use the tracepoint
support provided elsewhere in the kernel.

Please pull this in for 2.6.33.

I have a few other much smaller XFS changes for 2.6.33 but wanted to
get past this hump first.

-Alex

The following changes since commit 3ea6b3d0e6d0ffd91c0f8cadeb69b7133c038b32:
Linus Torvalds (1):
Merge branch 'for_linus' of git://git.kernel.org/.../jack/linux-udf-2.6

are available in the git repository at:

git://oss.sgi.com/xfs/xfs for-linus

Christoph Hellwig (3):
xfs: cleanup bmap extent state macros
xfs: change the xfs_iext_insert / xfs_iext_remove
xfs: event tracing support

fs/xfs/Makefile | 8 +-
fs/xfs/linux-2.6/xfs_acl.c | 1 +
fs/xfs/linux-2.6/xfs_aops.c | 52 +--
fs/xfs/linux-2.6/xfs_aops.h | 2 +
fs/xfs/linux-2.6/xfs_buf.c | 117 ++---
fs/xfs/linux-2.6/xfs_buf.h | 33 +-
fs/xfs/linux-2.6/xfs_fs_subr.c | 3 +
fs/xfs/linux-2.6/xfs_ioctl.c | 1 +
fs/xfs/linux-2.6/xfs_ioctl32.c | 1 +
fs/xfs/linux-2.6/xfs_iops.c | 1 +
fs/xfs/linux-2.6/xfs_linux.h | 1 -
fs/xfs/linux-2.6/xfs_lrw.c | 87 +---
fs/xfs/linux-2.6/xfs_lrw.h | 45 --
fs/xfs/linux-2.6/xfs_super.c | 104 +---
fs/xfs/linux-2.6/xfs_super.h | 7 -
fs/xfs/linux-2.6/xfs_sync.c | 1 +
fs/xfs/linux-2.6/xfs_trace.c | 75 +++
fs/xfs/linux-2.6/xfs_trace.h | 1369 ++++++++++++++++++++++++++++++++++++++++
fs/xfs/linux-2.6/xfs_vnode.h | 4 +
fs/xfs/quota/xfs_dquot.c | 110 +---
fs/xfs/quota/xfs_dquot.h | 21 -
fs/xfs/quota/xfs_qm.c | 40 +-
fs/xfs/quota/xfs_qm_syscalls.c | 4 +-
fs/xfs/support/ktrace.c | 323 ----------
fs/xfs/support/ktrace.h | 85 ---
fs/xfs/xfs.h | 16 -
fs/xfs/xfs_ag.h | 14 +
fs/xfs/xfs_alloc.c | 230 ++------
fs/xfs/xfs_alloc.h | 27 +-
fs/xfs/xfs_alloc_btree.c | 1 +
fs/xfs/xfs_attr.c | 107 +---
fs/xfs/xfs_attr.h | 10 +
fs/xfs/xfs_attr_leaf.c | 14 +-
fs/xfs/xfs_attr_sf.h | 40 --
fs/xfs/xfs_bmap.c | 942 +++++++++-------------------
fs/xfs/xfs_bmap.h | 58 ++-
fs/xfs/xfs_bmap_btree.c | 6 -
fs/xfs/xfs_btree.c | 5 +-
fs/xfs/xfs_btree_trace.h | 17 -
fs/xfs/xfs_buf_item.c | 87 +--
fs/xfs/xfs_buf_item.h | 20 +-
fs/xfs/xfs_da_btree.c | 3 +-
fs/xfs/xfs_da_btree.h | 7 +
fs/xfs/xfs_dfrag.c | 2 +-
fs/xfs/xfs_dir2.c | 8 +-
fs/xfs/xfs_dir2_block.c | 20 +-
fs/xfs/xfs_dir2_leaf.c | 21 +-
fs/xfs/xfs_dir2_node.c | 27 +-
fs/xfs/xfs_dir2_sf.c | 26 +-
fs/xfs/xfs_dir2_trace.c | 216 -------
fs/xfs/xfs_dir2_trace.h | 72 ---
fs/xfs/xfs_filestream.c | 8 +-
fs/xfs/xfs_fsops.c | 2 +
fs/xfs/xfs_iget.c | 111 +---
fs/xfs/xfs_inode.c | 79 +--
fs/xfs/xfs_inode.h | 82 +--
fs/xfs/xfs_inode_item.c | 5 +-
fs/xfs/xfs_iomap.c | 85 +---
fs/xfs/xfs_iomap.h | 8 +
fs/xfs/xfs_log.c | 181 ++----
fs/xfs/xfs_log_priv.h | 20 +-
fs/xfs/xfs_log_recover.c | 1 +
fs/xfs/xfs_mount.c | 2 +
fs/xfs/xfs_quota.h | 8 +
fs/xfs/xfs_rename.c | 1 +
fs/xfs/xfs_rtalloc.c | 1 +
fs/xfs/xfs_rw.c | 3 +-
fs/xfs/xfs_trans.h | 47 ++
fs/xfs/xfs_trans_buf.c | 62 +-
fs/xfs/xfs_vnodeops.c | 8 +-
70 files changed, 2369 insertions(+), 2836 deletions(-)
create mode 100644 fs/xfs/linux-2.6/xfs_trace.c
create mode 100644 fs/xfs/linux-2.6/xfs_trace.h
delete mode 100644 fs/xfs/support/ktrace.c
delete mode 100644 fs/xfs/support/ktrace.h
delete mode 100644 fs/xfs/xfs_dir2_trace.c
delete mode 100644 fs/xfs/xfs_dir2_trace.h

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[XFS updates] XFS development tree branch, for-linus, updated. v2.6.30-rc4-31865-g0b1b213

2009-12-15T05:47:30Z

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "XFS development tree".

The branch, for-linus has been updated
0b1b213 xfs: event tracing support
6ef3554 xfs: change the xfs_iext_insert / xfs_iext_remove
7574aa9 xfs: cleanup bmap extent state macros
d031655 Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu
3126c13 Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6
f4d544e Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs
6b2f3d1 vfs: Implement proper O_SYNC semantics
4ef58d4 Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
6035ccd Merge branch 'for-2.6.33' of git://git.kernel.dk/linux-2.6-block
1557d33 Merge git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/sysctl-2.6
d014d04 Merge branch 'for-next' into for-linus
af901ca tree-wide: fix assorted typos all over the place
0d99519 writeback: remove unused nonblocking and congestion checks
6d45611 sysctl: Drop & in front of every proc_handler.
ab09203 sysctl fs: Remove dead binary sysctl support
7a9e02d this_cpu: xfs_icsb_modify_counters does not need "cpu" variable
from 44a743f68705c681439f264deb05f8f38e9048d3 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 0b1b213fcf3a8486ada99a2bab84ab8c6f51b264
Author: Christoph Hellwig <hch@...>
Date: Mon Dec 14 23:14:59 2009 +0000

xfs: event tracing support

Convert the old xfs tracing support that could only be used with the
out of tree kdb and xfsidbg patches to use the generic event tracer.

To use it make sure CONFIG_EVENT_TRACING is enabled and then enable
all xfs trace channels by:

echo 1 > /sys/kernel/debug/tracing/events/xfs/enable

or alternatively enable single events by just doing the same in one
event subdirectory, e.g.

echo 1 > /sys/kernel/debug/tracing/events/xfs/xfs_ihold/enable

or set more complex filters, etc. In Documentation/trace/events.txt
all this is desctribed in more detail. To reads the events do a

cat /sys/kernel/debug/tracing/trace

Compared to the last posting this patch converts the tracing mostly to
the one tracepoint per callsite model that other users of the new
tracing facility also employ. This allows a very fine-grained control
of the tracing, a cleaner output of the traces and also enables the
perf tool to use each tracepoint as a virtual performance counter,
allowing us to e.g. count how often certain workloads git various
spots in XFS. Take a look at

http://lwn.net/Articles/346470/

for some examples.

Also the btree tracing isn't included at all yet, as it will require
additional core tracing features not in mainline yet, I plan to
deliver it later.

And the really nice thing about this patch is that it actually removes
many lines of code while adding this nice functionality:

fs/xfs/Makefile | 8
fs/xfs/linux-2.6/xfs_acl.c | 1
fs/xfs/linux-2.6/xfs_aops.c | 52 -
fs/xfs/linux-2.6/xfs_aops.h | 2
fs/xfs/linux-2.6/xfs_buf.c | 117 +--
fs/xfs/linux-2.6/xfs_buf.h | 33
fs/xfs/linux-2.6/xfs_fs_subr.c | 3
fs/xfs/linux-2.6/xfs_ioctl.c | 1
fs/xfs/linux-2.6/xfs_ioctl32.c | 1
fs/xfs/linux-2.6/xfs_iops.c | 1
fs/xfs/linux-2.6/xfs_linux.h | 1
fs/xfs/linux-2.6/xfs_lrw.c | 87 --
fs/xfs/linux-2.6/xfs_lrw.h | 45 -
fs/xfs/linux-2.6/xfs_super.c | 104 ---
fs/xfs/linux-2.6/xfs_super.h | 7
fs/xfs/linux-2.6/xfs_sync.c | 1
fs/xfs/linux-2.6/xfs_trace.c | 75 ++
fs/xfs/linux-2.6/xfs_trace.h | 1369 +++++++++++++++++++++++++++++++++++++++++
fs/xfs/linux-2.6/xfs_vnode.h | 4
fs/xfs/quota/xfs_dquot.c | 110 ---
fs/xfs/quota/xfs_dquot.h | 21
fs/xfs/quota/xfs_qm.c | 40 -
fs/xfs/quota/xfs_qm_syscalls.c | 4
fs/xfs/support/ktrace.c | 323 ---------
fs/xfs/support/ktrace.h | 85 --
fs/xfs/xfs.h | 16
fs/xfs/xfs_ag.h | 14
fs/xfs/xfs_alloc.c | 230 +-----
fs/xfs/xfs_alloc.h | 27
fs/xfs/xfs_alloc_btree.c | 1
fs/xfs/xfs_attr.c | 107 ---
fs/xfs/xfs_attr.h | 10
fs/xfs/xfs_attr_leaf.c | 14
fs/xfs/xfs_attr_sf.h | 40 -
fs/xfs/xfs_bmap.c | 507 +++------------
fs/xfs/xfs_bmap.h | 49 -
fs/xfs/xfs_bmap_btree.c | 6
fs/xfs/xfs_btree.c | 5
fs/xfs/xfs_btree_trace.h | 17
fs/xfs/xfs_buf_item.c | 87 --
fs/xfs/xfs_buf_item.h | 20
fs/xfs/xfs_da_btree.c | 3
fs/xfs/xfs_da_btree.h | 7
fs/xfs/xfs_dfrag.c | 2
fs/xfs/xfs_dir2.c | 8
fs/xfs/xfs_dir2_block.c | 20
fs/xfs/xfs_dir2_leaf.c | 21
fs/xfs/xfs_dir2_node.c | 27
fs/xfs/xfs_dir2_sf.c | 26
fs/xfs/xfs_dir2_trace.c | 216 ------
fs/xfs/xfs_dir2_trace.h | 72 --
fs/xfs/xfs_filestream.c | 8
fs/xfs/xfs_fsops.c | 2
fs/xfs/xfs_iget.c | 111 ---
fs/xfs/xfs_inode.c | 67 --
fs/xfs/xfs_inode.h | 76 --
fs/xfs/xfs_inode_item.c | 5
fs/xfs/xfs_iomap.c | 85 --
fs/xfs/xfs_iomap.h | 8
fs/xfs/xfs_log.c | 181 +----
fs/xfs/xfs_log_priv.h | 20
fs/xfs/xfs_log_recover.c | 1
fs/xfs/xfs_mount.c | 2
fs/xfs/xfs_quota.h | 8
fs/xfs/xfs_rename.c | 1
fs/xfs/xfs_rtalloc.c | 1
fs/xfs/xfs_rw.c | 3
fs/xfs/xfs_trans.h | 47 +
fs/xfs/xfs_trans_buf.c | 62 -
fs/xfs/xfs_vnodeops.c | 8
70 files changed, 2151 insertions(+), 2592 deletions(-)

Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit 6ef3554422e2c7e7aa424ba63737da498881dff4
Author: Christoph Hellwig <hch@...>
Date: Wed Nov 25 00:00:21 2009 +0000

xfs: change the xfs_iext_insert / xfs_iext_remove

Change the xfs_iext_insert / xfs_iext_remove prototypes to pass more
information which will allow pushing the trace points from the callers
into those functions. This includes folding the whichfork information
into the state variable to minimize the addition stack footprint.

Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit 7574aa92f9b4952c458024e1fa51f20fed65ba07
Author: Christoph Hellwig <hch@...>
Date: Wed Nov 25 00:00:19 2009 +0000

xfs: cleanup bmap extent state macros

Cleanup the extent state macros in the bmap code to use one common set of
flags that we can pass to the tracing code later and remove a lot of the
macro obsfucation.

Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Alex Elder <aelder@...>

commit d0316554d3586cbea60592a41391b5def2553d6f
Merge: fb0bbb92d42d5bd0ab224605444efdfed06d6934 51e99be00ce2713cbb841cedc997cafa6e26c7f4
Author: Linus Torvalds <torvalds@...>
Date: Mon Dec 14 09:58:24 2009 -0800

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu: (34 commits)
m68k: rename global variable vmalloc_end to m68k_vmalloc_end
percpu: add missing per_cpu_ptr_to_phys() definition for UP
percpu: Fix kdump failure if booted with percpu_alloc=page
percpu: make misc percpu symbols unique
percpu: make percpu symbols in ia64 unique
percpu: make percpu symbols in powerpc unique
percpu: make percpu symbols in x86 unique
percpu: make percpu symbols in xen unique
percpu: make percpu symbols in cpufreq unique
percpu: make percpu symbols in oprofile unique
percpu: make percpu symbols in tracer unique
percpu: make percpu symbols under kernel/ and mm/ unique
percpu: remove some sparse warnings
percpu: make alloc_percpu() handle array types
vmalloc: fix use of non-existent percpu variable in put_cpu_var()
this_cpu: Use this_cpu_xx in trace_functions_graph.c
this_cpu: Use this_cpu_xx for ftrace
this_cpu: Use this_cpu_xx in nmi handling
this_cpu: Use this_cpu operations in RCU
this_cpu: Use this_cpu ops for VM statistics
...

Fix up trivial (famous last words) global per-cpu naming conflicts in
arch/x86/kvm/svm.c
mm/slab.c

commit 3126c136bc30225d7a43af741778aa50e95e467a
Merge: f4d544ee5720d336a8c64f9fd33efb888c302309 8e0eb4011bd73d5f91b215b532f74eef478ef795
Author: Linus Torvalds <torvalds@...>
Date: Fri Dec 11 15:31:13 2009 -0800

Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs-2.6: (21 commits)
ext3: PTR_ERR return of wrong pointer in setup_new_group_blocks()
ext3: Fix data / filesystem corruption when write fails to copy data
ext4: Support for 64-bit quota format
ext3: Support for vfsv1 quota format
quota: Implement quota format with 64-bit space and inode limits
quota: Move definition of QFMT_OCFS2 to linux/quota.h
ext2: fix comment in ext2_find_entry about return values
ext3: Unify log messages in ext3
ext2: clear uptodate flag on super block I/O error
ext2: Unify log messages in ext2
ext3: make "norecovery" an alias for "noload"
ext3: Don't update the superblock in ext3_statfs()
ext3: journal all modifications in ext3_xattr_set_handle
ext2: Explicitly assign values to on-disk enum of filetypes
quota: Fix WARN_ON in lookup_one_len
const: struct quota_format_ops
ubifs: remove manual O_SYNC handling
afs: remove manual O_SYNC handling
kill wait_on_page_writeback_range
vfs: Implement proper O_SYNC semantics
...

commit f4d544ee5720d336a8c64f9fd33efb888c302309
Merge: 0e2f7b837600979d5b6f174a6ff695b85942e985 44a743f68705c681439f264deb05f8f38e9048d3
Author: Linus Torvalds <torvalds@...>
Date: Fri Dec 11 15:30:29 2009 -0800

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

* 'for-linus' of git://oss.sgi.com/xfs/xfs:
xfs: Fix error return for fallocate() on XFS
xfs: cleanup dmapi macros in the umount path
xfs: remove incorrect sparse annotation for xfs_iget_cache_miss
xfs: kill the STATIC_INLINE macro
xfs: uninline xfs_get_extsz_hint
xfs: rename xfs_attr_fetch to xfs_attr_get_int
xfs: simplify xfs_buf_get / xfs_buf_read interfaces
xfs: remove IO_ISAIO
xfs: Wrapped journal record corruption on read at recovery
xfs: cleanup data end I/O handlers
xfs: use WRITE_SYNC_PLUG for synchronous writeout
xfs: reset the i_iolock lock class in the reclaim path
xfs: I/O completion handlers must use NOFS allocations
xfs: fix mmap_sem/iolock inversion in xfs_free_eofblocks
xfs: simplify inode teardown

commit 6b2f3d1f769be5779b479c37800229d9a4809fc3
Author: Christoph Hellwig <hch@...>
Date: Tue Oct 27 11:05:28 2009 +0100

vfs: Implement proper O_SYNC semantics

While Linux provided an O_SYNC flag basically since day 1, it took until
Linux 2.4.0-test12pre2 to actually get it implemented for filesystems,
since that day we had generic_osync_around with only minor changes and the
great "For now, when the user asks for O_SYNC, we'll actually give
O_DSYNC" comment. This patch intends to actually give us real O_SYNC
semantics in addition to the O_DSYNC semantics. After Jan's O_SYNC
patches which are required before this patch it's actually surprisingly
simple, we just need to figure out when to set the datasync flag to
vfs_fsync_range and when not.

This patch renames the existing O_SYNC flag to O_DSYNC while keeping it's
numerical value to keep binary compatibility, and adds a new real O_SYNC
flag. To guarantee backwards compatiblity it is defined as expanding to
both the O_DSYNC and the new additional binary flag (__O_SYNC) to make
sure we are backwards-compatible when compiled against the new headers.

This also means that all places that don't care about the differences can
just check O_DSYNC and get the right behaviour for O_SYNC, too - only
places that actuall care need to check __O_SYNC in addition. Drivers and
network filesystems have been updated in a fail safe way to always do the
full sync magic if O_DSYNC is set. The few places setting O_SYNC for
lower layers are kept that way for now to stay failsafe.

We enforce that O_DSYNC is set when __O_SYNC is set early in the open path
to make sure we always get these sane options.

Note that parisc really screwed up their headers as they already define a
O_DSYNC that has always been a no-op. We try to repair it by using it for
the new O_DSYNC and redefinining O_SYNC to send both the traditional
O_SYNC numerical value _and_ the O_DSYNC one.

Cc: Richard Henderson <rth@...>
Cc: Ivan Kokshaysky <ink@...>
Cc: Grant Grundler <grundler@...>
Cc: "David S. Miller" <davem@...>
Cc: Ingo Molnar <mingo@...>
Cc: "H. Peter Anvin" <hpa@...>
Cc: Thomas Gleixner <tglx@...>
Cc: Al Viro <viro@...>
Cc: Andreas Dilger <adilger@...>
Acked-by: Trond Myklebust <Trond.Myklebust@...>
Acked-by: Kyle McMartin <kyle@...>
Acked-by: Ulrich Drepper <drepper@...>
Signed-off-by: Christoph Hellwig <hch@...>
Signed-off-by: Andrew Morton <akpm@...>
Signed-off-by: Jan Kara <jack@...>

commit 4ef58d4e2ad1fa2a3e5bbf41af2284671fca8cf8
Merge: f6c4c8195b5e7878823caa1181be404d9e86d369 d014d043869cdc591f3a33243d3481fa4479c2d0
Author: Linus Torvalds <torvalds@...>
Date: Wed Dec 9 19:43:33 2009 -0800

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial: (42 commits)
tree-wide: fix misspelling of "definition" in comments
reiserfs: fix misspelling of "journaled"
doc: Fix a typo in slub.txt.
inotify: remove superfluous return code check
hdlc: spelling fix in find_pvc() comment
doc: fix regulator docs cut-and-pasteism
mtd: Fix comment in Kconfig
doc: Fix IRQ chip docs
tree-wide: fix assorted typos all over the place
drivers/ata/libata-sff.c: comment spelling fixes
fix typos/grammos in Documentation/edac.txt
sysctl: add missing comments
fs/debugfs/inode.c: fix comment typos
sgivwfb: Make use of ARRAY_SIZE.
sky2: fix sky2_link_down copy/paste comment error
tree-wide: fix typos "couter" -> "counter"
tree-wide: fix typos "offest" -> "offset"
fix kerneldoc for set_irq_msi()
spidev: fix double "of of" in comment
comment typo fix: sybsystem -> subsystem
...

commit 6035ccd8e9e40bb654fbfdef325902ab531679a5
Merge: 23eb3b64b5e44680c867e165fe1cd18e57fba255 878eaddd05d251cefa9632c2b8046833c5eead66
Author: Linus Torvalds <torvalds@...>
Date: Tue Dec 8 08:19:16 2009 -0800

Merge branch 'for-2.6.33' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.33' of git://git.kernel.dk/linux-2.6-block: (113 commits)
cfq-iosched: Do not access cfqq after freeing it
block: include linux/err.h to use ERR_PTR
cfq-iosched: use call_rcu() instead of doing grace period stall on queue exit
blkio: Allow CFQ group IO scheduling even when CFQ is a module
blkio: Implement dynamic io controlling policy registration
blkio: Export some symbols from blkio as its user CFQ can be a module
block: Fix io_context leak after failure of clone with CLONE_IO
block: Fix io_context leak after clone with CLONE_IO
cfq-iosched: make nonrot check logic consistent
io controller: quick fix for blk-cgroup and modular CFQ
cfq-iosched: move IO controller declerations to a header file
cfq-iosched: fix compile problem with !CONFIG_CGROUP
blkio: Documentation
blkio: Wait on sync-noidle queue even if rq_noidle = 1
blkio: Implement group_isolation tunable
blkio: Determine async workload length based on total number of queues
blkio: Wait for cfq queue to get backlogged if group is empty
blkio: Propagate cgroup weight updation to cfq groups
blkio: Drop the reference to queue once the task changes cgroup
blkio: Provide some isolation between groups
...

commit 1557d33007f63dd96e5d15f33af389378e5f2e54
Merge: 6ec22f9b037fc0c2e00ddb7023fad279c365324d c656ae95d1c5c8ed5763356263ace2d03087efec
Author: Linus Torvalds <torvalds@...>
Date: Tue Dec 8 07:38:50 2009 -0800

Merge git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/sysctl-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/sysctl-2.6: (43 commits)
security/tomoyo: Remove now unnecessary handling of security_sysctl.
security/tomoyo: Add a special case to handle accesses through the internal proc mount.
sysctl: Drop & in front of every proc_handler.
sysctl: Remove CTL_NONE and CTL_UNNUMBERED
sysctl: kill dead ctl_handler definitions.
sysctl: Remove the last of the generic binary sysctl support
sysctl net: Remove unused binary sysctl code
sysctl security/tomoyo: Don't look at ctl_name
sysctl arm: Remove binary sysctl support
sysctl x86: Remove dead binary sysctl support
sysctl sh: Remove dead binary sysctl support
sysctl powerpc: Remove dead binary sysctl support
sysctl ia64: Remove dead binary sysctl support
sysctl s390: Remove dead sysctl binary support
sysctl frv: Remove dead binary sysctl support
sysctl mips/lasat: Remove dead binary sysctl support
sysctl drivers: Remove dead binary sysctl support
sysctl crypto: Remove dead binary sysctl support
sysctl security/keys: Remove dead binary sysctl support
sysctl kernel: Remove binary sysctl logic
...

commit d014d043869cdc591f3a33243d3481fa4479c2d0
Merge: 6ec22f9b037fc0c2e00ddb7023fad279c365324d 6070d81eb5f2d4943223c96e7609a53cdc984364
Author: Jiri Kosina <jkosina@...>
Date: Mon Dec 7 18:36:35 2009 +0100

Merge branch 'for-next' into for-linus

Conflicts:

kernel/irq/chip.c

commit af901ca181d92aac3a7dc265144a9081a86d8f39
Author: AndrÃ© Goddard Rosa <andre.goddard@...>
Date: Sat Nov 14 13:09:05 2009 -0200

tree-wide: fix assorted typos all over the place

That is "success", "unknown", "through", "performance", "[re|un]mapping"
, "access", "default", "reasonable", "[con]currently", "temperature"
, "channel", "[un]used", "application", "example","hierarchy", "therefore"
, "[over|under]flow", "contiguous", "threshold", "enough" and others.

Signed-off-by: AndrÃ© Goddard Rosa <andre.goddard@...>
Signed-off-by: Jiri Kosina <jkosina@...>

commit 0d99519efef15fd0cf84a849492c7b1deee1e4b7
Author: Wu Fengguang <fengguang.wu@...>
Date: Thu Dec 3 13:54:25 2009 +0100

writeback: remove unused nonblocking and congestion checks

- no one is calling wb_writeback and write_cache_pages with
wbc.nonblocking=1 any more
- lumpy pageout will want to do nonblocking writeback without the
congestion wait

So remove the congestion checks as suggested by Chris.

Signed-off-by: Wu Fengguang <fengguang.wu@...>
Cc: Chris Mason <chris.mason@...>
Cc: Jens Axboe <jens.axboe@...>
Cc: Trond Myklebust <Trond.Myklebust@...>
Cc: Christoph Hellwig <hch@...>
Cc: Dave Chinner <david@...>
Cc: Evgeniy Polyakov <zbr@...>
Cc: Alex Elder <aelder@...>
Signed-off-by: Jens Axboe <jens.axboe@...>

commit 6d4561110a3e9fa742aeec6717248a491dfb1878
Author: Eric W. Biederman <ebiederm@...>
Date: Mon Nov 16 03:11:48 2009 -0800

sysctl: Drop & in front of every proc_handler.

For consistency drop & in front of every proc_handler. Explicity
taking the address is unnecessary and it prevents optimizations
like stubbing the proc_handlers to NULL.

Cc: Alexey Dobriyan <adobriyan@...>
Cc: Ingo Molnar <mingo@...>
Cc: Joe Perches <joe@...>
Signed-off-by: Eric W. Biederman <ebiederm@...>

commit ab09203e302b6e526f6930f3e460064b0f253ae9
Author: Eric W. Biederman <ebiederm@...>
Date: Thu Nov 5 14:25:10 2009 -0800

sysctl fs: Remove dead binary sysctl support

Now that sys_sysctl is a generic wrapper around /proc/sys .ctl_name
and .strategy members of sysctl tables are dead code. Remove them.

Cc: Jan Harkes <jaharkes@...>
Signed-off-by: Eric W. Biederman <ebiederm@...>

commit 7a9e02d6bb05b268dc403d7ee87ce4198062f838
Author: Christoph Lameter <cl@...>
Date: Sat Oct 3 19:48:23 2009 +0900

this_cpu: xfs_icsb_modify_counters does not need "cpu" variable

The xfs_icsb_modify_counters() function no longer needs the cpu variable
if we use this_cpu_ptr() and we can get rid of get/put_cpu().

Acked-by: Tejun Heo <tj@...>
Reviewed-by: Christoph Hellwig <hch@...>
Acked-by: Olaf Weber <olaf@...>
Signed-off-by: Christoph Lameter <cl@...>
Signed-off-by: Tejun Heo <tj@...>

-----------------------------------------------------------------------

Summary of changes:
fs/xfs/Makefile | 8 +-
fs/xfs/linux-2.6/xfs_acl.c | 1 +
fs/xfs/linux-2.6/xfs_aops.c | 61 +--
fs/xfs/linux-2.6/xfs_aops.h | 2 +
fs/xfs/linux-2.6/xfs_buf.c | 117 ++---
fs/xfs/linux-2.6/xfs_buf.h | 33 +-
fs/xfs/linux-2.6/xfs_fs_subr.c | 3 +
fs/xfs/linux-2.6/xfs_ioctl.c | 1 +
fs/xfs/linux-2.6/xfs_ioctl32.c | 1 +
fs/xfs/linux-2.6/xfs_iops.c | 1 +
fs/xfs/linux-2.6/xfs_linux.h | 1 -
fs/xfs/linux-2.6/xfs_lrw.c | 89 +---
fs/xfs/linux-2.6/xfs_lrw.h | 45 --
fs/xfs/linux-2.6/xfs_super.c | 104 +---
fs/xfs/linux-2.6/xfs_super.h | 7 -
fs/xfs/linux-2.6/xfs_sync.c | 1 +
fs/xfs/linux-2.6/xfs_sysctl.c | 62 +--
fs/xfs/linux-2.6/xfs_trace.c | 75 +++
fs/xfs/linux-2.6/xfs_trace.h | 1369 ++++++++++++++++++++++++++++++++++++++++
fs/xfs/linux-2.6/xfs_vnode.h | 4 +
fs/xfs/quota/xfs_dquot.c | 110 +---
fs/xfs/quota/xfs_dquot.h | 23 +-
fs/xfs/quota/xfs_qm.c | 40 +-
fs/xfs/quota/xfs_qm_syscalls.c | 4 +-
fs/xfs/support/ktrace.c | 323 ----------
fs/xfs/support/ktrace.h | 85 ---
fs/xfs/xfs.h | 16 -
fs/xfs/xfs_ag.h | 14 +
fs/xfs/xfs_alloc.c | 230 ++------
fs/xfs/xfs_alloc.h | 27 +-
fs/xfs/xfs_alloc_btree.c | 1 +
fs/xfs/xfs_attr.c | 107 +---
fs/xfs/xfs_attr.h | 10 +
fs/xfs/xfs_attr_leaf.c | 14 +-
fs/xfs/xfs_attr_sf.h | 40 --
fs/xfs/xfs_bmap.c | 942 +++++++++-------------------
fs/xfs/xfs_bmap.h | 58 ++-
fs/xfs/xfs_bmap_btree.c | 6 -
fs/xfs/xfs_btree.c | 5 +-
fs/xfs/xfs_btree_trace.h | 17 -
fs/xfs/xfs_buf_item.c | 87 +--
fs/xfs/xfs_buf_item.h | 20 +-
fs/xfs/xfs_da_btree.c | 3 +-
fs/xfs/xfs_da_btree.h | 7 +
fs/xfs/xfs_dfrag.c | 2 +-
fs/xfs/xfs_dir2.c | 8 +-
fs/xfs/xfs_dir2_block.c | 20 +-
fs/xfs/xfs_dir2_leaf.c | 21 +-
fs/xfs/xfs_dir2_node.c | 27 +-
fs/xfs/xfs_dir2_sf.c | 26 +-
fs/xfs/xfs_dir2_trace.c | 216 -------
fs/xfs/xfs_dir2_trace.h | 72 ---
fs/xfs/xfs_filestream.c | 8 +-
fs/xfs/xfs_fsops.c | 2 +
fs/xfs/xfs_iget.c | 111 +---
fs/xfs/xfs_inode.c | 79 +--
fs/xfs/xfs_inode.h | 82 +--
fs/xfs/xfs_inode_item.c | 5 +-
fs/xfs/xfs_iomap.c | 85 +---
fs/xfs/xfs_iomap.h | 8 +
fs/xfs/xfs_log.c | 181 ++----
fs/xfs/xfs_log_priv.h | 20 +-
fs/xfs/xfs_log_recover.c | 1 +
fs/xfs/xfs_mount.c | 14 +-
fs/xfs/xfs_quota.h | 8 +
fs/xfs/xfs_rename.c | 1 +
fs/xfs/xfs_rtalloc.c | 1 +
fs/xfs/xfs_rw.c | 3 +-
fs/xfs/xfs_trans.h | 47 ++
fs/xfs/xfs_trans_buf.c | 62 +-
fs/xfs/xfs_vnodeops.c | 8 +-
71 files changed, 2393 insertions(+), 2899 deletions(-)
create mode 100644 fs/xfs/linux-2.6/xfs_trace.c
create mode 100644 fs/xfs/linux-2.6/xfs_trace.h
delete mode 100644 fs/xfs/support/ktrace.c
delete mode 100644 fs/xfs/support/ktrace.h
delete mode 100644 fs/xfs/xfs_dir2_trace.c
delete mode 100644 fs/xfs/xfs_dir2_trace.h

hooks/post-receive
--
XFS development tree

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 6/6] XFS: Reference count per-ag structures

2009-12-14T22:11:17Z

Reference count the per-ag structures to ensure that we keep get/put
pairs balanced. Assert that the reference counts are zero at unmount
time to catch leaks. In future, reference counts will enable us to
safely remove perag structures by allowing us to detect when they
are no longer in use.

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/xfs_ag.h | 4 ++--
fs/xfs/xfs_mount.c | 1 +
fs/xfs/xfs_mount.h | 11 +++++++++--
3 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h
index 6702bd8..18ae43f 100644
--- a/fs/xfs/xfs_ag.h
+++ b/fs/xfs/xfs_ag.h
@@ -196,8 +196,8 @@ typedef struct xfs_perag_busy {
#define XFS_PAGB_NUM_SLOTS 128
#endif

-typedef struct xfs_perag
-{
+typedef struct xfs_perag {
+ atomic_t pag_ref; /* perag reference count */
char pagf_init; /* this agf's entry is initialized */
char pagi_init; /* this agi's entry is initialized */
char pagf_metadata; /* the agf is preferred to be metadata */
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 73d61d4..1d00f7f 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -215,6 +215,7 @@ xfs_free_perag(
for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
spin_lock(&mp->m_perag_lock);
pag = radix_tree_delete(&mp->m_perag_tree, agno);
+ ASSERT(atomic_read(&pag->pag_ref) == 0);
spin_unlock(&mp->m_perag_lock);
ASSERT(pag);
kmem_free(pag->pagb_list);
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index cfa7a5d..16b2212 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -384,7 +384,7 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)
}

/*
- * perag get/put wrappers for eventual ref counting
+ * perag get/put wrappers for ref counting
*/
static inline struct xfs_perag *
xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)
@@ -393,6 +393,12 @@ xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)

spin_lock(&mp->m_perag_lock);
pag = radix_tree_lookup(&mp->m_perag_tree, agno);
+ if (pag) {
+ ASSERT(atomic_read(&pag->pag_ref) >= 0);
+ /* catch leaks in the positive direction during testing */
+ ASSERT(atomic_read(&pag->pag_ref) < 1000);
+ atomic_inc(&pag->pag_ref);
+ }
spin_unlock(&mp->m_perag_lock);
return pag;
}
@@ -400,7 +406,8 @@ xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)
static inline void
xfs_perag_put(struct xfs_perag *pag)
{
- /* nothing to see here, move along */
+ ASSERT(atomic_read(&pag->pag_ref) > 0);
+ atomic_dec(&pag->pag_ref);
}

/*
--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 5/6] XFS: Replace per-ag array with a radix tree

2009-12-14T22:11:16Z

The use of an array for the per-ag structures requires reallocation of the
array when growing the filesystem. This requires locking access to the array to
avoid use after free situations, and the locking is difficult to get right. To
avoid needing to reallocate an array, change the per-ag structures to an
allocated object per ag and index them using a tree structure.

The AGs are always densely indexed (hence the use of an array), but the number
supported is 2^32 and lookups tend to be random and hence indexing needs to
scale. A simple choice is a radix tree - it works well with this sort of index.
This change also removes another large contiguous allocation from the
mount/growfs path in XFS.

The growing process now needs to change to only initialise the new AGs required
for the extra space, and as such only needs to exclusively lock the tree for
inserts. The rest of the code only needs to lock the tree while doing lookups,
and hence this will remove all the deadlocks that currently occur on the
m_perag_lock as it is now an innermost lock. The lock is also changed to a
spinlock from a read/write lock as the hold time is now extremely short.

To complete the picture, the per-ag structures will need to be reference
counted to ensure that we don't free/modify them while they are still in use.
This will be done in subsequent patch.

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/xfs_alloc.c | 8 ------
fs/xfs/xfs_bmap.c | 7 +----
fs/xfs/xfs_filestream.c | 13 +++------
fs/xfs/xfs_fsops.c | 42 +++++++++++++++---------------
fs/xfs/xfs_ialloc.c | 25 +----------------
fs/xfs/xfs_itable.c | 4 ---
fs/xfs/xfs_mount.c | 65 +++++++++++++++++++++++++++++++++++-----------
fs/xfs/xfs_mount.h | 14 +++++++---
8 files changed, 87 insertions(+), 91 deletions(-)

diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 3cb533c..e5679f3 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -2275,7 +2275,6 @@ xfs_alloc_vextent(
* These three force us into a single a.g.
*/
args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno);
- down_read(&mp->m_peraglock);
args->pag = xfs_perag_get(mp, args->agno);
args->minleft = 0;
error = xfs_alloc_fix_freelist(args, 0);
@@ -2285,14 +2284,12 @@ xfs_alloc_vextent(
goto error0;
}
if (!args->agbp) {
- up_read(&mp->m_peraglock);
trace_xfs_alloc_vextent_noagbp(args);
break;
}
args->agbno = XFS_FSB_TO_AGBNO(mp, args->fsbno);
if ((error = xfs_alloc_ag_vextent(args)))
goto error0;
- up_read(&mp->m_peraglock);
break;
case XFS_ALLOCTYPE_START_BNO:
/*
@@ -2344,7 +2341,6 @@ xfs_alloc_vextent(
* Loop over allocation groups twice; first time with
* trylock set, second time without.
*/
- down_read(&mp->m_peraglock);
for (;;) {
args->pag = xfs_perag_get(mp, args->agno);
if (no_min) args->minleft = 0;
@@ -2407,7 +2403,6 @@ xfs_alloc_vextent(
}
xfs_perag_put(args->pag);
}
- up_read(&mp->m_peraglock);
if (bump_rotor || (type == XFS_ALLOCTYPE_ANY_AG)) {
if (args->agno == sagno)
mp->m_agfrotor = (mp->m_agfrotor + 1) %
@@ -2437,7 +2432,6 @@ xfs_alloc_vextent(
return 0;
error0:
xfs_perag_put(args->pag);
- up_read(&mp->m_peraglock);
return error;
}

@@ -2462,7 +2456,6 @@ xfs_free_extent(
args.agno = XFS_FSB_TO_AGNO(args.mp, bno);
ASSERT(args.agno < args.mp->m_sb.sb_agcount);
args.agbno = XFS_FSB_TO_AGBNO(args.mp, bno);
- down_read(&args.mp->m_peraglock);
args.pag = xfs_perag_get(args.mp, args.agno);
if ((error = xfs_alloc_fix_freelist(&args, XFS_ALLOC_FLAG_FREEING)))
goto error0;
@@ -2474,7 +2467,6 @@ xfs_free_extent(
error = xfs_free_ag_extent(tp, args.agbp, args.agno, args.agbno, len, 0);
error0:
xfs_perag_put(args.pag);
- up_read(&args.mp->m_peraglock);
return error;
}

diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index a9b95d9..7c6d9ac 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -2629,14 +2629,12 @@ xfs_bmap_btalloc(
if (startag == NULLAGNUMBER)
startag = ag = 0;
notinit = 0;
- down_read(&mp->m_peraglock);
pag = xfs_perag_get(mp, ag);
while (blen < ap->alen) {
if (!pag->pagf_init &&
(error = xfs_alloc_pagf_init(mp, args.tp,
ag, XFS_ALLOC_FLAG_TRYLOCK))) {
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
return error;
}
/*
@@ -2669,10 +2667,8 @@ xfs_bmap_btalloc(

error = xfs_filestream_new_ag(ap, &ag);
xfs_perag_put(pag);
- if (error) {
- up_read(&mp->m_peraglock);
+ if (error)
return error;
- }

/* loop again to set 'blen'*/
startag = NULLAGNUMBER;
@@ -2688,7 +2684,6 @@ xfs_bmap_btalloc(
pag = xfs_perag_get(mp, ag);
}
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
/*
* Since the above loop did a BUF_TRYLOCK, it is
* possible that there is space for this request.
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index e61f2aa..914d00d 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -253,8 +253,7 @@ next_ag:

/*
* Set the allocation group number for a file or a directory, updating inode
- * references and per-AG references as appropriate. Must be called with the
- * m_peraglock held in read mode.
+ * references and per-AG references as appropriate.
*/
static int
_xfs_filestream_update_ag(
@@ -456,10 +455,10 @@ xfs_filestream_unmount(
}

/*
- * If the mount point's m_perag array is going to be reallocated, all
+ * If the mount point's m_perag tree is going to be modified, all
* outstanding cache entries must be flushed to avoid accessing reference count
* addresses that have been freed. The call to xfs_filestream_flush() must be
- * made inside the block that holds the m_peraglock in write mode to do the
+ * made inside the block that holds the m_perag_lock in write mode to do the
* reallocation.
*/
void
@@ -531,7 +530,6 @@ xfs_filestream_associate(

mp = pip->i_mount;
cache = mp->m_filestream;
- down_read(&mp->m_peraglock);

/*
* We have a problem, Houston.
@@ -548,10 +546,8 @@ xfs_filestream_associate(
*
* So, if we can't get the iolock without sleeping then just give up
*/
- if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
- up_read(&mp->m_peraglock);
+ if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL))
return 1;
- }

/* If the parent directory is already in the cache, use its AG. */
item = xfs_mru_cache_lookup(cache, pip->i_ino);
@@ -606,7 +602,6 @@ exit_did_pick:

exit:
xfs_iunlock(pip, XFS_IOLOCK_EXCL);
- up_read(&mp->m_peraglock);
return -err;
}

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index a13919a..37a6f62 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -167,27 +167,14 @@ xfs_growfs_data_private(
}
new = nb - mp->m_sb.sb_dblocks;
oagcount = mp->m_sb.sb_agcount;
- if (nagcount > oagcount) {
- void *new_perag, *old_perag;
-
- xfs_filestream_flush(mp);
-
- new_perag = kmem_zalloc(sizeof(xfs_perag_t) * nagcount,
- KM_MAYFAIL);
- if (!new_perag)
- return XFS_ERROR(ENOMEM);
-
- down_write(&mp->m_peraglock);
- memcpy(new_perag, mp->m_perag, sizeof(xfs_perag_t) * oagcount);
- old_perag = mp->m_perag;
- mp->m_perag = new_perag;
-
- mp->m_flags |= XFS_MOUNT_32BITINODES;
- nagimax = xfs_initialize_perag(mp, nagcount);
- up_write(&mp->m_peraglock);

- kmem_free(old_perag);
+ /* allocate the new per-ag structures */
+ if (nagcount > oagcount) {
+ error = xfs_initialize_perag(mp, nagcount, &nagimax);
+ if (error)
+ return error;
}
+
tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
tp->t_flags |= XFS_TRANS_RESERVE;
if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
@@ -196,6 +183,11 @@ xfs_growfs_data_private(
return error;
}

+ /*
+ * Write new AG headers to disk. Non-transactional, but written
+ * synchronously so they are completed prior to the growfs transaction
+ * being logged.
+ */
nfree = 0;
for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
/*
@@ -359,6 +351,12 @@ xfs_growfs_data_private(
goto error0;
}
}
+
+ /*
+ * Update changed superblock fields transactionally. These are not
+ * seen by the rest of the world until the transaction commit applies
+ * them atomically to the superblock.
+ */
if (nagcount > oagcount)
xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
if (nb > mp->m_sb.sb_dblocks)
@@ -369,9 +367,9 @@ xfs_growfs_data_private(
if (dpct)
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
error = xfs_trans_commit(tp, 0);
- if (error) {
+ if (error)
return error;
- }
+
/* New allocation groups fully initialized, so update mount struct */
if (nagimax)
mp->m_maxagi = nagimax;
@@ -381,6 +379,8 @@ xfs_growfs_data_private(
mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
} else
mp->m_maxicount = 0;
+
+ /* update secondary superblocks. */
for (agno = 1; agno < nagcount; agno++) {
error = xfs_read_buf(mp, mp->m_ddev_targp,
XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 884ee13..52c9d00 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -383,11 +383,9 @@ xfs_ialloc_ag_alloc(
newino = XFS_OFFBNO_TO_AGINO(args.mp, args.agbno, 0);
be32_add_cpu(&agi->agi_count, newlen);
be32_add_cpu(&agi->agi_freecount, newlen);
- down_read(&args.mp->m_peraglock);
pag = xfs_perag_get(args.mp, agno);
pag->pagi_freecount += newlen;
xfs_perag_put(pag);
- up_read(&args.mp->m_peraglock);
agi->agi_newino = cpu_to_be32(newino);

/*
@@ -489,7 +487,6 @@ xfs_ialloc_ag_select(
*/
agno = pagno;
flags = XFS_ALLOC_FLAG_TRYLOCK;
- down_read(&mp->m_peraglock);
for (;;) {
pag = xfs_perag_get(mp, agno);
if (!pag->pagi_init) {
@@ -531,7 +528,6 @@ xfs_ialloc_ag_select(
goto nextag;
}
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
return agbp;
}
}
@@ -544,18 +540,14 @@ nextag:
* No point in iterating over the rest, if we're shutting
* down.
*/
- if (XFS_FORCED_SHUTDOWN(mp)) {
- up_read(&mp->m_peraglock);
+ if (XFS_FORCED_SHUTDOWN(mp))
return NULL;
- }
agno++;
if (agno >= agcount)
agno = 0;
if (agno == pagno) {
- if (flags == 0) {
- up_read(&mp->m_peraglock);
+ if (flags == 0)
return NULL;
- }
flags = 0;
}
}
@@ -777,16 +769,13 @@ nextag:
*inop = NULLFSINO;
return noroom ? ENOSPC : 0;
}
- down_read(&mp->m_peraglock);
pag = xfs_perag_get(mp, tagno);
if (pag->pagi_inodeok == 0) {
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
goto nextag;
}
error = xfs_ialloc_read_agi(mp, tp, tagno, &agbp);
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
if (error)
goto nextag;
agi = XFS_BUF_TO_AGI(agbp);
@@ -1015,9 +1004,7 @@ alloc_inode:
goto error0;
be32_add_cpu(&agi->agi_freecount, -1);
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
- down_read(&mp->m_peraglock);
pag->pagi_freecount--;
- up_read(&mp->m_peraglock);

error = xfs_check_agi_freecount(cur, agi);
if (error)
@@ -1100,9 +1087,7 @@ xfs_difree(
/*
* Get the allocation group header.
*/
- down_read(&mp->m_peraglock);
error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
- up_read(&mp->m_peraglock);
if (error) {
cmn_err(CE_WARN,
"xfs_difree: xfs_ialloc_read_agi() returned an error %d on %s. Returning error.",
@@ -1169,11 +1154,9 @@ xfs_difree(
be32_add_cpu(&agi->agi_count, -ilen);
be32_add_cpu(&agi->agi_freecount, -(ilen - 1));
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_COUNT | XFS_AGI_FREECOUNT);
- down_read(&mp->m_peraglock);
pag = xfs_perag_get(mp, agno);
pag->pagi_freecount -= ilen - 1;
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, -ilen);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -(ilen - 1));

@@ -1202,11 +1185,9 @@ xfs_difree(
*/
be32_add_cpu(&agi->agi_freecount, 1);
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
- down_read(&mp->m_peraglock);
pag = xfs_perag_get(mp, agno);
pag->pagi_freecount++;
xfs_perag_put(pag);
- up_read(&mp->m_peraglock);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, 1);
}

@@ -1328,9 +1309,7 @@ xfs_imap(
xfs_buf_t *agbp; /* agi buffer */
int i; /* temp state */

- down_read(&mp->m_peraglock);
error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
- up_read(&mp->m_peraglock);
if (error) {
xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
"xfs_ialloc_read_agi() returned "
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 62efab2..940307a 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -420,9 +420,7 @@ xfs_bulkstat(
while (XFS_BULKSTAT_UBLEFT(ubleft) && agno < mp->m_sb.sb_agcount) {
cond_resched();
bp = NULL;
- down_read(&mp->m_peraglock);
error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
- up_read(&mp->m_peraglock);
if (error) {
/*
* Skip this allocation group and go to the next one.
@@ -849,9 +847,7 @@ xfs_inumbers(
agbp = NULL;
while (left > 0 && agno < mp->m_sb.sb_agcount) {
if (agbp == NULL) {
- down_read(&mp->m_peraglock);
error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
- up_read(&mp->m_peraglock);
if (error) {
/*
* If we can't read the AGI of this ag,
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 4739c2c..73d61d4 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -209,13 +209,16 @@ STATIC void
xfs_free_perag(
xfs_mount_t *mp)
{
- if (mp->m_perag) {
- int agno;
+ xfs_agnumber_t agno;
+ struct xfs_perag *pag;

- for (agno = 0; agno < mp->m_maxagi; agno++)
- if (mp->m_perag[agno].pagb_list)
- kmem_free(mp->m_perag[agno].pagb_list);
- kmem_free(mp->m_perag);
+ for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) {
+ spin_lock(&mp->m_perag_lock);
+ pag = radix_tree_delete(&mp->m_perag_tree, agno);
+ spin_unlock(&mp->m_perag_lock);
+ ASSERT(pag);
+ kmem_free(pag->pagb_list);
+ kmem_free(pag);
}
}

@@ -389,10 +392,11 @@ xfs_initialize_perag_icache(
}
}

-xfs_agnumber_t
+int
xfs_initialize_perag(
xfs_mount_t *mp,
- xfs_agnumber_t agcount)
+ xfs_agnumber_t agcount,
+ xfs_agnumber_t *maxagi)
{
xfs_agnumber_t index, max_metadata;
xfs_perag_t *pag;
@@ -405,6 +409,33 @@ xfs_initialize_perag(
agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);

+ /*
+ * Walk the current per-ag tree so we don't try to initialise AGs
+ * that already exist (growfs case). Allocate and insert all the
+ * AGs we don't find ready for initialisation.
+ */
+ for (index = 0; index < agcount; index++) {
+ pag = xfs_perag_get(mp, index);
+ if (pag) {
+ xfs_perag_put(pag);
+ continue;
+ }
+ pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
+ if (!pag)
+ return -ENOMEM;
+ if (radix_tree_preload(GFP_NOFS))
+ return -ENOMEM;
+ spin_lock(&mp->m_perag_lock);
+ if (radix_tree_insert(&mp->m_perag_tree, index, pag)) {
+ BUG();
+ spin_unlock(&mp->m_perag_lock);
+ kmem_free(pag);
+ return -EEXIST;
+ }
+ spin_unlock(&mp->m_perag_lock);
+ radix_tree_preload_end();
+ }
+
/* Clear the mount flag if no inode can overflow 32 bits
* on this filesystem, or if specifically requested..
*/
@@ -454,7 +485,9 @@ xfs_initialize_perag(
xfs_perag_put(pag);
}
}
- return index;
+ if (maxagi)
+ *maxagi = index;
+ return 0;
}

void
@@ -1155,13 +1188,13 @@ xfs_mountfs(
/*
* Allocate and initialize the per-ag data.
*/
- init_rwsem(&mp->m_peraglock);
- mp->m_perag = kmem_zalloc(sbp->sb_agcount * sizeof(xfs_perag_t),
- KM_MAYFAIL);
- if (!mp->m_perag)
+ spin_lock_init(&mp->m_perag_lock);
+ INIT_RADIX_TREE(&mp->m_perag_tree, GFP_NOFS);
+ error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi);
+ if (error) {
+ cmn_err(CE_WARN, "XFS: Failed per-ag init: %d", error);
goto out_remove_uuid;
-
- mp->m_maxagi = xfs_initialize_perag(mp, sbp->sb_agcount);
+ }

if (!sbp->sb_logblocks) {
cmn_err(CE_WARN, "XFS: no log defined");
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index f8a68a2..cfa7a5d 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -207,8 +207,8 @@ typedef struct xfs_mount {
uint m_ag_maxlevels; /* XFS_AG_MAXLEVELS */
uint m_bm_maxlevels[2]; /* XFS_BM_MAXLEVELS */
uint m_in_maxlevels; /* max inobt btree levels. */
- struct xfs_perag *m_perag; /* per-ag accounting info */
- struct rw_semaphore m_peraglock; /* lock for m_perag (pointer) */
+ struct radix_tree_root m_perag_tree; /* per-ag accounting info */
+ spinlock_t m_perag_lock; /* lock for m_perag_tree */
struct mutex m_growlock; /* growfs mutex */
int m_fixedfsid[2]; /* unchanged for life of FS */
uint m_dmevmask; /* DMI events for this FS */
@@ -389,7 +389,12 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)
static inline struct xfs_perag *
xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)
{
- return &mp->m_perag[agno];
+ struct xfs_perag *pag;
+
+ spin_lock(&mp->m_perag_lock);
+ pag = radix_tree_lookup(&mp->m_perag_tree, agno);
+ spin_unlock(&mp->m_perag_lock);
+ return pag;
}

static inline void
@@ -450,7 +455,8 @@ extern struct xfs_dmops xfs_dmcore_xfs;
#endif /* __KERNEL__ */

extern void xfs_mod_sb(struct xfs_trans *, __int64_t);
-extern xfs_agnumber_t xfs_initialize_perag(struct xfs_mount *, xfs_agnumber_t);
+extern int xfs_initialize_perag(struct xfs_mount *, xfs_agnumber_t,
+ xfs_agnumber_t *);
extern void xfs_sb_from_disk(struct xfs_sb *, struct xfs_dsb *);
extern void xfs_sb_to_disk(struct xfs_dsb *, struct xfs_sb *, __int64_t);

--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 4/6] XFS: convert remaining direct references to m_perag

2009-12-14T22:11:15Z

Convert the remaining direct lookups of the per ag structures
to use get/put accesses. Ensure that the loops across AGs and
prior users of the interface balance gets and puts correctly.

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/xfs_bmap.c | 8 +++++++-
fs/xfs/xfs_ialloc.c | 35 +++++++++++++++++++++++++----------
fs/xfs/xfs_inode.c | 5 ++++-
fs/xfs/xfs_mount.c | 9 ++++++---
4 files changed, 42 insertions(+), 15 deletions(-)

diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 98251cd..a9b95d9 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -2630,11 +2630,12 @@ xfs_bmap_btalloc(
startag = ag = 0;
notinit = 0;
down_read(&mp->m_peraglock);
+ pag = xfs_perag_get(mp, ag);
while (blen < ap->alen) {
- pag = &mp->m_perag[ag];
if (!pag->pagf_init &&
(error = xfs_alloc_pagf_init(mp, args.tp,
ag, XFS_ALLOC_FLAG_TRYLOCK))) {
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
return error;
}
@@ -2667,6 +2668,7 @@ xfs_bmap_btalloc(
break;

error = xfs_filestream_new_ag(ap, &ag);
+ xfs_perag_put(pag);
if (error) {
up_read(&mp->m_peraglock);
return error;
@@ -2674,6 +2676,7 @@ xfs_bmap_btalloc(

/* loop again to set 'blen'*/
startag = NULLAGNUMBER;
+ pag = xfs_perag_get(mp, ag);
continue;
}
}
@@ -2681,7 +2684,10 @@ xfs_bmap_btalloc(
ag = 0;
if (ag == startag)
break;
+ xfs_perag_put(pag);
+ pag = xfs_perag_get(mp, ag);
}
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
/*
* Since the above loop did a BUF_TRYLOCK, it is
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index cb907ba..884ee13 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -253,6 +253,7 @@ xfs_ialloc_ag_alloc(
xfs_agino_t thisino; /* current inode number, for loop */
int isaligned = 0; /* inode allocation at stripe unit */
/* boundary */
+ struct xfs_perag *pag;

args.tp = tp;
args.mp = tp->t_mountp;
@@ -383,7 +384,9 @@ xfs_ialloc_ag_alloc(
be32_add_cpu(&agi->agi_count, newlen);
be32_add_cpu(&agi->agi_freecount, newlen);
down_read(&args.mp->m_peraglock);
- args.mp->m_perag[agno].pagi_freecount += newlen;
+ pag = xfs_perag_get(args.mp, agno);
+ pag->pagi_freecount += newlen;
+ xfs_perag_put(pag);
up_read(&args.mp->m_peraglock);
agi->agi_newino = cpu_to_be32(newino);

@@ -488,7 +491,7 @@ xfs_ialloc_ag_select(
flags = XFS_ALLOC_FLAG_TRYLOCK;
down_read(&mp->m_peraglock);
for (;;) {
- pag = &mp->m_perag[agno];
+ pag = xfs_perag_get(mp, agno);
if (!pag->pagi_init) {
if (xfs_ialloc_read_agi(mp, tp, agno, &agbp)) {
agbp = NULL;
@@ -527,6 +530,7 @@ xfs_ialloc_ag_select(
agbp = NULL;
goto nextag;
}
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
return agbp;
}
@@ -535,6 +539,7 @@ unlock_nextag:
if (agbp)
xfs_trans_brelse(tp, agbp);
nextag:
+ xfs_perag_put(pag);
/*
* No point in iterating over the rest, if we're shutting
* down.
@@ -672,6 +677,7 @@ xfs_dialloc(
xfs_agnumber_t tagno; /* testing allocation group number */
xfs_btree_cur_t *tcur; /* temp cursor */
xfs_inobt_rec_incore_t trec; /* temp inode allocation record */
+ struct xfs_perag *pag;

if (*IO_agbp == NULL) {
@@ -772,11 +778,14 @@ nextag:
return noroom ? ENOSPC : 0;
}
down_read(&mp->m_peraglock);
- if (mp->m_perag[tagno].pagi_inodeok == 0) {
+ pag = xfs_perag_get(mp, tagno);
+ if (pag->pagi_inodeok == 0) {
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
goto nextag;
}
error = xfs_ialloc_read_agi(mp, tp, tagno, &agbp);
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
if (error)
goto nextag;
@@ -790,6 +799,7 @@ nextag:
*/
agno = tagno;
*IO_agbp = NULL;
+ pag = xfs_perag_get(mp, agno);

restart_pagno:
cur = xfs_inobt_init_cursor(mp, tp, agbp, be32_to_cpu(agi->agi_seqno));
@@ -808,7 +818,6 @@ nextag:
* If in the same AG as the parent, try to get near the parent.
*/
if (pagno == agno) {
- xfs_perag_t *pag = &mp->m_perag[agno];
int doneleft; /* done, to the left */
int doneright; /* done, to the right */
int searchdistance = 10;
@@ -1007,7 +1016,7 @@ alloc_inode:
be32_add_cpu(&agi->agi_freecount, -1);
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
down_read(&mp->m_peraglock);
- mp->m_perag[tagno].pagi_freecount--;
+ pag->pagi_freecount--;
up_read(&mp->m_peraglock);

error = xfs_check_agi_freecount(cur, agi);
@@ -1016,12 +1025,14 @@ alloc_inode:

xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -1);
+ xfs_perag_put(pag);
*inop = ino;
return 0;
error1:
xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
error0:
xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
+ xfs_perag_put(pag);
return error;
}

@@ -1052,6 +1063,7 @@ xfs_difree(
xfs_mount_t *mp; /* mount structure for filesystem */
int off; /* offset of inode in inode chunk */
xfs_inobt_rec_incore_t rec; /* btree record */
+ struct xfs_perag *pag;

mp = tp->t_mountp;

@@ -1158,7 +1170,9 @@ xfs_difree(
be32_add_cpu(&agi->agi_freecount, -(ilen - 1));
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_COUNT | XFS_AGI_FREECOUNT);
down_read(&mp->m_peraglock);
- mp->m_perag[agno].pagi_freecount -= ilen - 1;
+ pag = xfs_perag_get(mp, agno);
+ pag->pagi_freecount -= ilen - 1;
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, -ilen);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -(ilen - 1));
@@ -1189,7 +1203,9 @@ xfs_difree(
be32_add_cpu(&agi->agi_freecount, 1);
xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
down_read(&mp->m_peraglock);
- mp->m_perag[agno].pagi_freecount++;
+ pag = xfs_perag_get(mp, agno);
+ pag->pagi_freecount++;
+ xfs_perag_put(pag);
up_read(&mp->m_peraglock);
xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, 1);
}
@@ -1379,7 +1395,6 @@ xfs_imap(
XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
return XFS_ERROR(EINVAL);
}
-
return 0;
}

@@ -1523,8 +1538,7 @@ xfs_ialloc_read_agi(
return error;

agi = XFS_BUF_TO_AGI(*bpp);
- pag = &mp->m_perag[agno];
-
+ pag = xfs_perag_get(mp, agno);
if (!pag->pagi_init) {
pag->pagi_freecount = be32_to_cpu(agi->agi_freecount);
pag->pagi_count = be32_to_cpu(agi->agi_count);
@@ -1537,6 +1551,7 @@ xfs_ialloc_read_agi(
*/
ASSERT(pag->pagi_freecount == be32_to_cpu(agi->agi_freecount) ||
XFS_FORCED_SHUTDOWN(mp));
+ xfs_perag_put(pag);
return 0;
}

diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 1f69dda..c2618db 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2695,7 +2695,7 @@ xfs_iflush_cluster(
ilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
ilist = kmem_alloc(ilist_size, KM_MAYFAIL|KM_NOFS);
if (!ilist)
- return 0;
+ goto out_put;

mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
@@ -2764,6 +2764,8 @@ xfs_iflush_cluster(
out_free:
read_unlock(&pag->pag_ici_lock);
kmem_free(ilist);
+out_put:
+ xfs_perag_put(pag);
return 0;

@@ -2807,6 +2809,7 @@ cluster_corrupt_out:
*/
xfs_iflush_abort(iq);
kmem_free(ilist);
+ xfs_perag_put(pag);
return XFS_ERROR(EFSCORRUPTED);
}

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index d652d59..4739c2c 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -438,18 +438,20 @@ xfs_initialize_perag(
}

/* This ag is preferred for inodes */
- pag = &mp->m_perag[index];
+ pag = xfs_perag_get(mp, index);
pag->pagi_inodeok = 1;
if (index < max_metadata)
pag->pagf_metadata = 1;
xfs_initialize_perag_icache(pag);
+ xfs_perag_put(pag);
}
} else {
/* Setup default behavior for smaller filesystems */
for (index = 0; index < agcount; index++) {
- pag = &mp->m_perag[index];
+ pag = xfs_perag_get(mp, index);
pag->pagi_inodeok = 1;
xfs_initialize_perag_icache(pag);
+ xfs_perag_put(pag);
}
}
return index;
@@ -731,12 +733,13 @@ xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount)
error = xfs_ialloc_pagi_init(mp, NULL, index);
if (error)
return error;
- pag = &mp->m_perag[index];
+ pag = xfs_perag_get(mp, index);
ifree += pag->pagi_freecount;
ialloc += pag->pagi_count;
bfree += pag->pagf_freeblks;
bfreelst += pag->pagf_flcount;
btree += pag->pagf_btreeblks;
+ xfs_perag_put(pag);
}
/*
* Overwrite incore superblock counters with just-read data
--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 3/6] XFS: Convert filestreams code to use per-ag get/put routines

2009-12-14T22:11:14Z

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/xfs_filestream.c | 19 ++++++++++++-------
fs/xfs/xfs_filestream.h | 27 ++++++++++++++++++++++++---
2 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index a631e14..e61f2aa 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -140,6 +140,7 @@ _xfs_filestream_pick_ag(
int flags,
xfs_extlen_t minlen)
{
+ int streams, max_streams;
int err, trylock, nscan;
xfs_extlen_t longest, free, minfree, maxfree = 0;
xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
@@ -155,15 +156,15 @@ _xfs_filestream_pick_ag(
trylock = XFS_ALLOC_FLAG_TRYLOCK;

for (nscan = 0; 1; nscan++) {
-
- TRACE_AG_SCAN(mp, ag, xfs_filestream_peek_ag(mp, ag));
-
- pag = mp->m_perag + ag;
+ pag = xfs_perag_get(mp, ag);
+ TRACE_AG_SCAN(mp, ag, atomic_read(&pag->pagf_fstrms));

if (!pag->pagf_init) {
err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
- if (err && !trylock)
+ if (err && !trylock) {
+ xfs_perag_put(pag);
return err;
+ }
}

/* Might fail sometimes during the 1st pass with trylock set. */
@@ -173,6 +174,7 @@ _xfs_filestream_pick_ag(
/* Keep track of the AG with the most free blocks. */
if (pag->pagf_freeblks > maxfree) {
maxfree = pag->pagf_freeblks;
+ max_streams = atomic_read(&pag->pagf_fstrms);
max_ag = ag;
}

@@ -195,6 +197,8 @@ _xfs_filestream_pick_ag(

/* Break out, retaining the reference on the AG. */
free = pag->pagf_freeblks;
+ streams = atomic_read(&pag->pagf_fstrms);
+ xfs_perag_put(pag);
*agp = ag;
break;
}
@@ -202,6 +206,7 @@ _xfs_filestream_pick_ag(
/* Drop the reference on this AG, it's not usable. */
xfs_filestream_put_ag(mp, ag);
next_ag:
+ xfs_perag_put(pag);
/* Move to the next AG, wrapping to AG 0 if necessary. */
if (++ag >= mp->m_sb.sb_agcount)
ag = 0;
@@ -229,6 +234,7 @@ next_ag:
if (max_ag != NULLAGNUMBER) {
xfs_filestream_get_ag(mp, max_ag);
TRACE_AG_PICK1(mp, max_ag, maxfree);
+ streams = max_streams;
free = maxfree;
*agp = max_ag;
break;
@@ -240,8 +246,7 @@ next_ag:
return 0;
}

- TRACE_AG_PICK2(mp, startag, *agp, xfs_filestream_peek_ag(mp, *agp),
- free, nscan, flags);
+ TRACE_AG_PICK2(mp, startag, *agp, streams, free, nscan, flags);

return 0;
}
diff --git a/fs/xfs/xfs_filestream.h b/fs/xfs/xfs_filestream.h
index 4aba67c..58378b2 100644
--- a/fs/xfs/xfs_filestream.h
+++ b/fs/xfs/xfs_filestream.h
@@ -79,12 +79,21 @@ extern ktrace_t *xfs_filestreams_trace_buf;
* the cache that reference per-ag array elements that have since been
* reallocated.
*/
+/*
+ * xfs_filestream_peek_ag is only used in tracing code
+ */
static inline int
xfs_filestream_peek_ag(
xfs_mount_t *mp,
xfs_agnumber_t agno)
{
- return atomic_read(&mp->m_perag[agno].pagf_fstrms);
+ struct xfs_perag *pag;
+ int ret;
+
+ pag = xfs_perag_get(mp, agno);
+ ret = atomic_read(&pag->pagf_fstrms);
+ xfs_perag_put(pag);
+ return ret;
}

static inline int
@@ -92,7 +101,13 @@ xfs_filestream_get_ag(
xfs_mount_t *mp,
xfs_agnumber_t agno)
{
- return atomic_inc_return(&mp->m_perag[agno].pagf_fstrms);
+ struct xfs_perag *pag;
+ int ret;
+
+ pag = xfs_perag_get(mp, agno);
+ ret = atomic_inc_return(&pag->pagf_fstrms);
+ xfs_perag_put(pag);
+ return ret;
}

static inline int
@@ -100,7 +115,13 @@ xfs_filestream_put_ag(
xfs_mount_t *mp,
xfs_agnumber_t agno)
{
- return atomic_dec_return(&mp->m_perag[agno].pagf_fstrms);
+ struct xfs_perag *pag;
+ int ret;
+
+ pag = xfs_perag_get(mp, agno);
+ ret = atomic_dec_return(&pag->pagf_fstrms);
+ xfs_perag_put(pag);
+ return ret;
}

/* allocation selection flags */
--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 2/6] XFS: Don't directly reference m_perag in allocation code

2009-12-14T22:11:13Z

Start abstracting the perag references so that the indexing of the
structures is not directly coded into all the places that uses the
perag structures. This will allow us to separate the use of the
perag structure and the way it is indexed and hence avoid the known
deadlocks related to growing a busy filesystem.

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/xfs_alloc.c | 81 +++++++++++++++++++++++++--------------------
fs/xfs/xfs_alloc_btree.c | 9 ++++-
2 files changed, 52 insertions(+), 38 deletions(-)

diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index a1c65fc..3cb533c 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -1662,11 +1662,13 @@ xfs_free_ag_extent(
xfs_agf_t *agf;
xfs_perag_t *pag; /* per allocation group data */

+ pag = xfs_perag_get(mp, agno);
+ pag->pagf_freeblks += len;
+ xfs_perag_put(pag);
+
agf = XFS_BUF_TO_AGF(agbp);
- pag = &mp->m_perag[agno];
be32_add_cpu(&agf->agf_freeblks, len);
xfs_trans_agblocks_delta(tp, len);
- pag->pagf_freeblks += len;
XFS_WANT_CORRUPTED_GOTO(
be32_to_cpu(agf->agf_freeblks) <=
be32_to_cpu(agf->agf_length),
@@ -1969,7 +1971,8 @@ xfs_alloc_get_freelist(
xfs_trans_brelse(tp, agflbp);
if (be32_to_cpu(agf->agf_flfirst) == XFS_AGFL_SIZE(mp))
agf->agf_flfirst = 0;
- pag = &mp->m_perag[be32_to_cpu(agf->agf_seqno)];
+
+ pag = xfs_perag_get(mp, be32_to_cpu(agf->agf_seqno));
be32_add_cpu(&agf->agf_flcount, -1);
xfs_trans_agflist_delta(tp, -1);
pag->pagf_flcount--;
@@ -2078,7 +2081,8 @@ xfs_alloc_put_freelist(
be32_add_cpu(&agf->agf_fllast, 1);
if (be32_to_cpu(agf->agf_fllast) == XFS_AGFL_SIZE(mp))
agf->agf_fllast = 0;
- pag = &mp->m_perag[be32_to_cpu(agf->agf_seqno)];
+
+ pag = xfs_perag_get(mp, be32_to_cpu(agf->agf_seqno));
be32_add_cpu(&agf->agf_flcount, 1);
xfs_trans_agflist_delta(tp, 1);
pag->pagf_flcount++;
@@ -2089,6 +2093,7 @@ xfs_alloc_put_freelist(
pag->pagf_btreeblks--;
logflags |= XFS_AGF_BTREEBLKS;
}
+ xfs_perag_put(pag);

xfs_alloc_log_agf(tp, agbp, logflags);

@@ -2152,7 +2157,6 @@ xfs_read_agf(
xfs_trans_brelse(tp, *bpp);
return XFS_ERROR(EFSCORRUPTED);
}
-
XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGF, XFS_AGF_REF);
return 0;
}
@@ -2184,7 +2188,7 @@ xfs_alloc_read_agf(
ASSERT(!XFS_BUF_GETERROR(*bpp));

agf = XFS_BUF_TO_AGF(*bpp);
- pag = &mp->m_perag[agno];
+ pag = xfs_perag_get(mp, agno);
if (!pag->pagf_init) {
pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
pag->pagf_btreeblks = be32_to_cpu(agf->agf_btreeblks);
@@ -2211,6 +2215,7 @@ xfs_alloc_read_agf(
be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]));
}
#endif
+ xfs_perag_put(pag);
return 0;
}

@@ -2271,7 +2276,7 @@ xfs_alloc_vextent(
*/
args->agno = XFS_FSB_TO_AGNO(mp, args->fsbno);
down_read(&mp->m_peraglock);
- args->pag = &mp->m_perag[args->agno];
+ args->pag = xfs_perag_get(mp, args->agno);
args->minleft = 0;
error = xfs_alloc_fix_freelist(args, 0);
args->minleft = minleft;
@@ -2341,7 +2346,7 @@ xfs_alloc_vextent(
*/
down_read(&mp->m_peraglock);
for (;;) {
- args->pag = &mp->m_perag[args->agno];
+ args->pag = xfs_perag_get(mp, args->agno);
if (no_min) args->minleft = 0;
error = xfs_alloc_fix_freelist(args, flags);
args->minleft = minleft;
@@ -2400,6 +2405,7 @@ xfs_alloc_vextent(
}
}
}
+ xfs_perag_put(args->pag);
}
up_read(&mp->m_peraglock);
if (bump_rotor || (type == XFS_ALLOCTYPE_ANY_AG)) {
@@ -2427,8 +2433,10 @@ xfs_alloc_vextent(
args->len);
#endif
}
+ xfs_perag_put(args->pag);
return 0;
error0:
+ xfs_perag_put(args->pag);
up_read(&mp->m_peraglock);
return error;
}
@@ -2455,7 +2463,7 @@ xfs_free_extent(
ASSERT(args.agno < args.mp->m_sb.sb_agcount);
args.agbno = XFS_FSB_TO_AGBNO(args.mp, bno);
down_read(&args.mp->m_peraglock);
- args.pag = &args.mp->m_perag[args.agno];
+ args.pag = xfs_perag_get(args.mp, args.agno);
if ((error = xfs_alloc_fix_freelist(&args, XFS_ALLOC_FLAG_FREEING)))
goto error0;
#ifdef DEBUG
@@ -2465,6 +2473,7 @@ xfs_free_extent(
#endif
error = xfs_free_ag_extent(tp, args.agbp, args.agno, args.agbno, len, 0);
error0:
+ xfs_perag_put(args.pag);
up_read(&args.mp->m_peraglock);
return error;
}
@@ -2486,15 +2495,15 @@ xfs_alloc_mark_busy(xfs_trans_t *tp,
xfs_agblock_t bno,
xfs_extlen_t len)
{
- xfs_mount_t *mp;
xfs_perag_busy_t *bsy;
+ struct xfs_perag *pag;
int n;

- mp = tp->t_mountp;
- spin_lock(&mp->m_perag[agno].pagb_lock);
+ pag = xfs_perag_get(tp->t_mountp, agno);
+ spin_lock(&pag->pagb_lock);

/* search pagb_list for an open slot */
- for (bsy = mp->m_perag[agno].pagb_list, n = 0;
+ for (bsy = pag->pagb_list, n = 0;
n < XFS_PAGB_NUM_SLOTS;
bsy++, n++) {
if (bsy->busy_tp == NULL) {
@@ -2502,11 +2511,11 @@ xfs_alloc_mark_busy(xfs_trans_t *tp,
}
}

- trace_xfs_alloc_busy(mp, agno, bno, len, n);
+ trace_xfs_alloc_busy(tp->t_mountp, agno, bno, len, n);

if (n < XFS_PAGB_NUM_SLOTS) {
- bsy = &mp->m_perag[agno].pagb_list[n];
- mp->m_perag[agno].pagb_count++;
+ bsy = &pag->pagb_list[n];
+ pag->pagb_count++;
bsy->busy_start = bno;
bsy->busy_length = len;
bsy->busy_tp = tp;
@@ -2521,7 +2530,8 @@ xfs_alloc_mark_busy(xfs_trans_t *tp,
xfs_trans_set_sync(tp);
}

- spin_unlock(&mp->m_perag[agno].pagb_lock);
+ spin_unlock(&pag->pagb_lock);
+ xfs_perag_put(pag);
}

void
@@ -2529,24 +2539,23 @@ xfs_alloc_clear_busy(xfs_trans_t *tp,
xfs_agnumber_t agno,
int idx)
{
- xfs_mount_t *mp;
+ struct xfs_perag *pag;
xfs_perag_busy_t *list;

- mp = tp->t_mountp;
-
- spin_lock(&mp->m_perag[agno].pagb_lock);
- list = mp->m_perag[agno].pagb_list;
-
ASSERT(idx < XFS_PAGB_NUM_SLOTS);
+ pag = xfs_perag_get(tp->t_mountp, agno);
+ spin_lock(&pag->pagb_lock);
+ list = pag->pagb_list;

- trace_xfs_alloc_unbusy(mp, agno, idx, list[idx].busy_tp == tp);
+ trace_xfs_alloc_unbusy(tp->t_mountp, agno, idx, list[idx].busy_tp == tp);

if (list[idx].busy_tp == tp) {
list[idx].busy_tp = NULL;
- mp->m_perag[agno].pagb_count--;
+ pag->pagb_count--;
}

- spin_unlock(&mp->m_perag[agno].pagb_lock);
+ spin_unlock(&pag->pagb_lock);
+ xfs_perag_put(pag);
}

@@ -2560,21 +2569,20 @@ xfs_alloc_search_busy(xfs_trans_t *tp,
xfs_agblock_t bno,
xfs_extlen_t len)
{
- xfs_mount_t *mp;
+ struct xfs_perag *pag;
xfs_perag_busy_t *bsy;
xfs_agblock_t uend, bend;
xfs_lsn_t lsn;
int cnt;

- mp = tp->t_mountp;
-
- spin_lock(&mp->m_perag[agno].pagb_lock);
- cnt = mp->m_perag[agno].pagb_count;
+ pag = xfs_perag_get(tp->t_mountp, agno);
+ spin_lock(&pag->pagb_lock);
+ cnt = pag->pagb_count;

uend = bno + len - 1;

/* search pagb_list for this slot, skipping open slots */
- for (bsy = mp->m_perag[agno].pagb_list; cnt; bsy++) {
+ for (bsy = pag->pagb_list; cnt; bsy++) {

/*
* (start1,length1) within (start2, length2)
@@ -2589,7 +2597,7 @@ xfs_alloc_search_busy(xfs_trans_t *tp,
}
}

- trace_xfs_alloc_busysearch(mp, agno, bno, len, !!cnt);
+ trace_xfs_alloc_busysearch(tp->t_mountp, agno, bno, len, !!cnt);

/*
* If a block was found, force the log through the LSN of the
@@ -2597,9 +2605,10 @@ xfs_alloc_search_busy(xfs_trans_t *tp,
*/
if (cnt) {
lsn = bsy->busy_tp->t_commit_lsn;
- spin_unlock(&mp->m_perag[agno].pagb_lock);
- xfs_log_force(mp, lsn, XFS_LOG_FORCE|XFS_LOG_SYNC);
+ spin_unlock(&pag->pagb_lock);
+ xfs_log_force(tp->t_mountp, lsn, XFS_LOG_FORCE|XFS_LOG_SYNC);
} else {
- spin_unlock(&mp->m_perag[agno].pagb_lock);
+ spin_unlock(&pag->pagb_lock);
}
+ xfs_perag_put(pag);
}
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index adbd914..b726e10 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -61,12 +61,14 @@ xfs_allocbt_set_root(
struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp);
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
int btnum = cur->bc_btnum;
+ struct xfs_perag *pag = xfs_perag_get(cur->bc_mp, seqno);

ASSERT(ptr->s != 0);

agf->agf_roots[btnum] = ptr->s;
be32_add_cpu(&agf->agf_levels[btnum], inc);
- cur->bc_mp->m_perag[seqno].pagf_levels[btnum] += inc;
+ pag->pagf_levels[btnum] += inc;
+ xfs_perag_put(pag);

xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_ROOTS | XFS_AGF_LEVELS);
}
@@ -150,6 +152,7 @@ xfs_allocbt_update_lastrec(
{
struct xfs_agf *agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno);
+ struct xfs_perag *pag;
__be32 len;
int numrecs;

@@ -193,7 +196,9 @@ xfs_allocbt_update_lastrec(
}

agf->agf_longest = len;
- cur->bc_mp->m_perag[seqno].pagf_longest = be32_to_cpu(len);
+ pag = xfs_perag_get(cur->bc_mp, seqno);
+ pag->pagf_longest = be32_to_cpu(len);
+ xfs_perag_put(pag);
xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp, XFS_AGF_LONGEST);
}

--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 1/6] XFS: rename xfs_get_perag

2009-12-14T22:11:12Z

xfs_get_perag is really getting the perag that an inode
belongs to based on it's inode number. Convert the use of this
function to just get the perag from a provided ag number.
Use this new function to obtain the per-ag structure when
traversing the per AG inode trees for sync and reclaim.

Signed-off-by: Dave Chinner <david@...>
---
fs/xfs/linux-2.6/xfs_sync.c | 33 +++++++++++++++++++++------------
fs/xfs/xfs_iget.c | 10 +++++-----
fs/xfs/xfs_inode.c | 8 +++++---
fs/xfs/xfs_mount.h | 8 ++++----
4 files changed, 35 insertions(+), 24 deletions(-)

diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index 6fed97a..0e17683 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -96,13 +96,12 @@ unlock:
STATIC int
xfs_inode_ag_walk(
struct xfs_mount *mp,
- xfs_agnumber_t ag,
+ struct xfs_perag *pag,
int (*execute)(struct xfs_inode *ip,
struct xfs_perag *pag, int flags),
int flags,
int tag)
{
- struct xfs_perag *pag = &mp->m_perag[ag];
uint32_t first_index;
int last_error = 0;
int skipped;
@@ -137,8 +136,6 @@ restart:
delay(1);
goto restart;
}
-
- xfs_put_perag(mp, pag);
return last_error;
}

@@ -155,9 +152,15 @@ xfs_inode_ag_iterator(
xfs_agnumber_t ag;

for (ag = 0; ag < mp->m_sb.sb_agcount; ag++) {
- if (!mp->m_perag[ag].pag_ici_init)
+ struct xfs_perag *pag;
+
+ pag = xfs_perag_get(mp, ag);
+ if (!pag->pag_ici_init) {
+ xfs_perag_put(pag);
continue;
- error = xfs_inode_ag_walk(mp, ag, execute, flags, tag);
+ }
+ error = xfs_inode_ag_walk(mp, pag, execute, flags, tag);
+ xfs_perag_put(pag);
if (error) {
last_error = error;
if (error == EFSCORRUPTED)
@@ -669,25 +672,30 @@ xfs_reclaim_inode(
xfs_inode_t *ip,
int sync_mode)
{
- xfs_perag_t *pag = xfs_get_perag(ip->i_mount, ip->i_ino);
+ struct xfs_mount *mp = ip->i_mount;
+ struct xfs_perag *pag;
+

- /* The hash lock here protects a thread in xfs_iget_core from
+ /*
+ * The radix tree lock here protects a thread in xfs_iget_core from
* racing with us on linking the inode back with a vnode.
* Once we have the XFS_IRECLAIM flag set it will not touch
* us.
*/
+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
write_lock(&pag->pag_ici_lock);
spin_lock(&ip->i_flags_lock);
if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
!__xfs_iflags_test(ip, XFS_IRECLAIMABLE)) {
spin_unlock(&ip->i_flags_lock);
write_unlock(&pag->pag_ici_lock);
+ xfs_perag_put(pag);
return -EAGAIN;
}
__xfs_iflags_set(ip, XFS_IRECLAIM);
spin_unlock(&ip->i_flags_lock);
write_unlock(&pag->pag_ici_lock);
- xfs_put_perag(ip->i_mount, pag);
+ xfs_perag_put(pag);

/*
* If the inode is still dirty, then flush it out. If the inode
@@ -737,16 +745,17 @@ void
xfs_inode_set_reclaim_tag(
xfs_inode_t *ip)
{
- xfs_mount_t *mp = ip->i_mount;
- xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino);
+ struct xfs_mount *mp = ip->i_mount;
+ struct xfs_perag *pag;

+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
read_lock(&pag->pag_ici_lock);
spin_lock(&ip->i_flags_lock);
__xfs_inode_set_reclaim_tag(pag, ip);
__xfs_iflags_set(ip, XFS_IRECLAIMABLE);
spin_unlock(&ip->i_flags_lock);
read_unlock(&pag->pag_ici_lock);
- xfs_put_perag(mp, pag);
+ xfs_perag_put(pag);
}

void
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index f5c904a..d1e7250 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -375,7 +375,7 @@ xfs_iget(
return EINVAL;

/* get the perag structure and ensure that it's inode capable */
- pag = xfs_get_perag(mp, ino);
+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ino));
if (!pag->pagi_inodeok)
return EINVAL;
ASSERT(pag->pag_ici_init);
@@ -399,7 +399,7 @@ again:
if (error)
goto out_error_or_again;
}
- xfs_put_perag(mp, pag);
+ xfs_perag_put(pag);

*ipp = ip;

@@ -418,7 +418,7 @@ out_error_or_again:
delay(1);
goto again;
}
- xfs_put_perag(mp, pag);
+ xfs_perag_put(pag);
return error;
}

@@ -486,11 +486,11 @@ xfs_ireclaim(
* if it was never added to it because radix_tree_delete can deal
* with that case just fine.
*/
- pag = xfs_get_perag(mp, ip->i_ino);
+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
write_lock(&pag->pag_ici_lock);
radix_tree_delete(&pag->pag_ici_root, XFS_INO_TO_AGINO(mp, ip->i_ino));
write_unlock(&pag->pag_ici_lock);
- xfs_put_perag(mp, pag);
+ xfs_perag_put(pag);

/*
* Here we do an (almost) spurious inode lock in order to coordinate
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index ce278b3..1f69dda 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1946,8 +1946,9 @@ xfs_ifree_cluster(
xfs_inode_t *ip, **ip_found;
xfs_inode_log_item_t *iip;
xfs_log_item_t *lip;
- xfs_perag_t *pag = xfs_get_perag(mp, inum);
+ struct xfs_perag *pag;

+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, inum));
if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
blks_per_cluster = 1;
ninodes = mp->m_sb.sb_inopblock;
@@ -2088,7 +2089,7 @@ xfs_ifree_cluster(
}

kmem_free(ip_found);
- xfs_put_perag(mp, pag);
+ xfs_perag_put(pag);
}

/*
@@ -2675,7 +2676,7 @@ xfs_iflush_cluster(
xfs_buf_t *bp)
{
xfs_mount_t *mp = ip->i_mount;
- xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino);
+ struct xfs_perag *pag;
unsigned long first_index, mask;
unsigned long inodes_per_cluster;
int ilist_size;
@@ -2686,6 +2687,7 @@ xfs_iflush_cluster(
int bufwasdelwri;
int i;

+ pag = xfs_perag_get(mp, XFS_INO_TO_AGNO(mp, ip->i_ino));
ASSERT(pag->pagi_inodeok);
ASSERT(pag->pag_ici_init);

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 1df7e45..f8a68a2 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -386,14 +386,14 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)
/*
* perag get/put wrappers for eventual ref counting
*/
-static inline xfs_perag_t *
-xfs_get_perag(struct xfs_mount *mp, xfs_ino_t ino)
+static inline struct xfs_perag *
+xfs_perag_get(struct xfs_mount *mp, xfs_agnumber_t agno)
{
- return &mp->m_perag[XFS_INO_TO_AGNO(mp, ino)];
+ return &mp->m_perag[agno];
}

static inline void
-xfs_put_perag(struct xfs_mount *mp, xfs_perag_t *pag)
+xfs_perag_put(struct xfs_perag *pag)
{
/* nothing to see here, move along */
}
--
1.6.5

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[PATCH 0/6] XFS: Fix growfs deadlocks and per-AG use after free V3

2009-12-14T22:11:11Z

The use of an array for the xfs_perag structures results in growfs having
to realocate the array. This requires exclusion to prevent use-after-free
situations. The current locking is prone to deadlocks when growing under
load, and the xfssyncd currently has no protection against the array being
reallocated that can lead to panics.

This series abstracts the per-ag structure access and then removes the array
to replace it with individual xfs_perag structures indexed by a radix tree.
The only locking required is for the radix tree, hence the deadlocks go away
as the tree lock is always the innermost lock. The use after frees go away
as well as growfs does not need to reallocate structures fo pre-existing
allocation groups - it only needs to allocate the structures for the new
AGs and insert them into the tree.

This series also adds reference counting to the xfs-perag structure to
ensure that we balance get/put accesses to the structures and provide the
infrastructure to determine if the structure is in use or not.

Version 3: Rebase for current upstream tree.
Version 2: Fix review comments from Christoph.

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T21:36:29Z

2009/12/15 Dave Chinner <david@...>:

In xfs_btree_make_block_unfull, it seems that oindex and index are
optimised to register variables. So, it become more odd.

> thing is probably smashing the stack. Possibly a buffer overrun. To
> narrow down the possible cause, can you add the debug:
>
> printk("%s:%s: oindex = %p, index = %p\n",
> __func__, __LINE__, oindex, index);
>
> throughout the xfs_btree_make_block_unfull() function? i.e. at
> first entry, before the xfs_btree_rshift() call, before the
> xfs_btree_lshift() call, etc, to see if any of the parameters
> are being modified during execution of the function?
>
> If the variables being passed into xfs_btree_make_block_unfull() are
> already bad, then do the same thing for the caller
> xfs_btree_insert(). This may help narrow down where the problem
> is coming from....
>
> Cheers,
>
> Dave.
> --
> Dave Chinner
> david@...
>

--
The simplest is not all best but the best is surely the simplest!

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [PATCH 0/6] XFS: Fix growfs deadlocks and per-AG use after free V2

2009-12-14T21:14:55Z

On Tue, Dec 15, 2009 at 10:11:04AM +1100, Dave Chinner wrote:

> The use of an array for the xfs_perag structures results in growfs having
> to realocate the array. This requires exclusion to prevent use-after-free
> situations. The current locking is prone to deadlocks when growing under
> load, and the xfssyncd currently has no protection against the array being
> reallocated that can lead to panics.
>
> This series abstracts the per-ag structure access and then removes the array
> to replace it with individual xfs_perag structures indexed by a radix tree.
> The only locking required is for the radix tree, hence the deadlocks go away
> as the tree lock is always the innermost lock. The use after frees go away
> as well as growfs does not need to reallocate structures fo pre-existing
> allocation groups - it only needs to allocate the structures for the new
> AGs and insert them into the tree.
>
> This series also adds reference counting to the xfs-perag structure to
> ensure that we balance get/put accesses to the structures and provide the
> infrastructure to determine if the structure is in use or not.
>
> Version 2: Fix review comments from Christoph.

This series needs updating after the trace patches were merged. I'll
post it again soon...

Cheers,

Dave.
--
Dave Chinner
david@...

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

[XFS updates] XFS development tree branch, master, updated. v2.6.30-rc4-24753-gd0c1562

2009-12-14T20:56:20Z

RE: [PATCH 3/3] xfs: event tracing support

2009-12-14T20:47:22Z

Christoph Hellwig wrote:

> On Mon, Dec 14, 2009 at 04:40:36PM -0600, Alex Elder wrote:
>> There is a problem with trace_xfs_bmap_insert(). It is
>> referenced once (in xfs_bmap_trace_exlist()), but never defined.
>> The reference does not match the prototype defined for the other bmap tracepoints either.
>>
>> Rather than trying to figure out what you intended I thought I'd
>> give you a chance to offer a fix. If you do, please just send me
>> an update of that portion of the code if possible. Meanwhile
>> I've commented out that reference and am going to try to complete
>> my review of this patch shortly.
>>
>> Details are in the excerpts below. I didn't add any commentary,
>> I'm just calling attention to the code I'm referring to.
>
> Yeah, that was some debug build that got missed in the last iteration of
> the patch. Updated version below:

OK, this looks good. Compared to the first time around, I gave
it a very cursory review. But we'll get it in.

Signed-off-by: Alex Elder <aelder@...>

> Subject: xfs: event tracing support
> From: Christoph Hellwig <hch@...>
>
> Convert the old xfs tracing support that could only be used with the out
> of tree kdb and xfsidbg patches to use the generic event tracer.
>
> To use it make sure CONFIG_EVENT_TRACING is enabled and then enable all
> xfs trace channels by:
>
> echo 1 > /sys/kernel/debug/tracing/events/xfs/enable
>
> or alternatively enable single events by just doing the same in one
> event subdirectory, e.g.
>
> echo 1 > /sys/kernel/debug/tracing/events/xfs/xfs_ihold/enable
>
> or set more complex filters, etc. In Documentation/trace/events.txt all

. . .

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T19:22:59Z

2009/12/15 Eric Sandeen <sandeen@...>:

> hank peng wrote:
>> 2009/12/15 Dave Chinner <david@...>:
>>> On Tue, Dec 15, 2009 at 08:49:37AM +0800, hank peng wrote:
>>>> Hi, Eric:
>>>> I add some code like this:
>>>> if (*stat) {
>>>> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
>>>> *stat, oindex, index);
>>>> if (oindex == NULL || index == NULL) {
>>> This won't catch bad non-NULL pointers like you are seeing.
>>>
>>>> printk("BUG occured!\n");
>>>> printk("oindex = %p, index = %p\n", oindex, index);
>>>> BUG();
>>>> }
>>>> *oindex = *index = cur->bc_ptrs[level];
>>>> return 0;
>>>> }
>>>>
>>>> And the same OOPS happened again but a little different, kernel messages are:
>>>>
>>>> <snip>
>>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>>> *stat = 0x00000001, oindex = 00000501, index = 22008424
>>>> Unable to handle kernel paging request for data at address 0x22008424
>
> Are you using any of the xfs userspace prior to this error, or is it a
> fresh boot and just normal IO?
>

no xfs userspace prior to this error, just normal IO. Besides, it need
some time to produce the OOPS.

> I ask because libxfs calls sys_ustat() which at one point was corrupting
> userspace, at least, with 32-bit userspace on a 64-bit kernel:
> https://bugzilla.redhat.com/show_bug.cgi?id=472795
>
Forgot to say, I use "-o inode64" when mount.

# uname -a
Linux Storage 2.6.31.6-svn40 #30 Tue Dec 15 09:50:02 CST 2009 ppc unknown
# mount
rootfs on / type rootfs (rw)
/dev/root on / type ext2 (rw,relatime,errors=continue)
/dev/mtdblock2 on /mnt/sys_data type jffs2 (rw,relatime)
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,relatime)
tmpfs on /opt/upgrade type tmpfs (rw,relatime)
devpts on /dev/pts type devpts (rw,relatime,gid=5,mode=620)
/dev/Pool_md2/ss1 on /mnt/Pool_md2/ss1 type xfs
(rw,relatime,attr2,inode64,noquota)

> Even with that fixed there were still some reports of odd behavior
> on ppc... I don't know if things might be going wrong in kernelspace
> as well...
>
> https://bugzilla.redhat.com/show_bug.cgi?id=517994
> and I haven't gotten to the bottom of that yet ...
>
> Very few things actually use sys_ustat, but xfs userspace does...
> just a random thought.
>
> -eric
>
>>> Given that oindex and index are stack varibles, this indicates some
>>> thing is probably smashing the stack. Possibly a buffer overrun. To
>>> narrow down the possible cause, can you add the debug:
>>>
>>> printk("%s:%s: oindex = %p, index = %p\n",
>>> __func__, __LINE__, oindex, index);
>>>
>>> throughout the xfs_btree_make_block_unfull() function? i.e. at
>>> first entry, before the xfs_btree_rshift() call, before the
>>> xfs_btree_lshift() call, etc, to see if any of the parameters
>>> are being modified during execution of the function?
>>>
>>> If the variables being passed into xfs_btree_make_block_unfull() are
>>> already bad, then do the same thing for the caller
>>> xfs_btree_insert(). This may help narrow down where the problem
>>> is coming from....
>>>
>> Thanks for your reply!
>> As you said, I added some code like this:
>> /* First, try shifting an entry to the right neighbor. */
>> printk("%s: before xfs_btree_rshift, oindex = %p, index = %p\n",
>> __func__, oindex, index);
>> error = xfs_btree_rshift(cur, level, stat);
>> if (error || *stat)
>> return error;
>>
>> /* Next, try shifting an entry to the left neighbor. */
>> printk("%s: before xfs_btree_lshift, oindex = %p, index = %p\n",
>> __func__, oindex, index);
>> error = xfs_btree_lshift(cur, level, stat);
>> if (error)
>> return error;
>>
>> if (*stat) {
>> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
>> *stat, oindex, index);
>> if (oindex == NULL || index == NULL) {
>> printk("BUG occured!\n");
>> printk("oindex = %p, index = %p\n", oindex, index);
>> BUG();
>> }
>> *oindex = *index = cur->bc_ptrs[level];
>> return 0;
>> }
>>
>>
>> xfs_btree_set_ptr_null(cur, &nptr);
>> if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
>> printk("%s: before calling
>> xfs_btree_make_block_unfull, &optr = %p, &ptr = %p\n",
>> __func__, &optr, &ptr);
>> error = xfs_btree_make_block_unfull(cur, level, numrecs,
>> &optr, &ptr, &nptr, &ncur, &nrec, stat);
>> if (error || *stat == 0)
>> goto error0;
>> }
>>
>>
>> We are waiting for OOPS to happen.
>>
>> I hope it will nerver be memory corrupt problem which is nightmare for
>> me to debug.
>>
>>> Cheers,
>>>
>>> Dave.
>>> --
>>> Dave Chinner
>>> david@...
>>>
>>
>>
>>
>
>

--
The simplest is not all best but the best is surely the simplest!

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T19:15:09Z

hank peng wrote:

> 2009/12/15 Dave Chinner <david@...>:
>> On Tue, Dec 15, 2009 at 08:49:37AM +0800, hank peng wrote:
>>> Hi, Eric:
>>> I add some code like this:
>>> if (*stat) {
>>> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
>>> *stat, oindex, index);
>>> if (oindex == NULL || index == NULL) {
>> This won't catch bad non-NULL pointers like you are seeing.
>>
>>> printk("BUG occured!\n");
>>> printk("oindex = %p, index = %p\n", oindex, index);
>>> BUG();
>>> }
>>> *oindex = *index = cur->bc_ptrs[level];
>>> return 0;
>>> }
>>>
>>> And the same OOPS happened again but a little different, kernel messages are:
>>>
>>> <snip>
>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>>> *stat = 0x00000001, oindex = 00000501, index = 22008424
>>> Unable to handle kernel paging request for data at address 0x22008424

Are you using any of the xfs userspace prior to this error, or is it a
fresh boot and just normal IO?

I ask because libxfs calls sys_ustat() which at one point was corrupting
userspace, at least, with 32-bit userspace on a 64-bit kernel:
https://bugzilla.redhat.com/show_bug.cgi?id=472795

Even with that fixed there were still some reports of odd behavior
on ppc... I don't know if things might be going wrong in kernelspace
as well...

https://bugzilla.redhat.com/show_bug.cgi?id=517994
and I haven't gotten to the bottom of that yet ...

Very few things actually use sys_ustat, but xfs userspace does...
just a random thought.

-eric

>> Given that oindex and index are stack varibles, this indicates some
>> thing is probably smashing the stack. Possibly a buffer overrun. To
>> narrow down the possible cause, can you add the debug:
>>
>> printk("%s:%s: oindex = %p, index = %p\n",
>> __func__, __LINE__, oindex, index);
>>
>> throughout the xfs_btree_make_block_unfull() function? i.e. at
>> first entry, before the xfs_btree_rshift() call, before the
>> xfs_btree_lshift() call, etc, to see if any of the parameters
>> are being modified during execution of the function?
>>
>> If the variables being passed into xfs_btree_make_block_unfull() are
>> already bad, then do the same thing for the caller
>> xfs_btree_insert(). This may help narrow down where the problem
>> is coming from....
>>
> Thanks for your reply!
> As you said, I added some code like this:
> /* First, try shifting an entry to the right neighbor. */
> printk("%s: before xfs_btree_rshift, oindex = %p, index = %p\n",
> __func__, oindex, index);
> error = xfs_btree_rshift(cur, level, stat);
> if (error || *stat)
> return error;
>
> /* Next, try shifting an entry to the left neighbor. */
> printk("%s: before xfs_btree_lshift, oindex = %p, index = %p\n",
> __func__, oindex, index);
> error = xfs_btree_lshift(cur, level, stat);
> if (error)
> return error;
>
> if (*stat) {
> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
> *stat, oindex, index);
> if (oindex == NULL || index == NULL) {
> printk("BUG occured!\n");
> printk("oindex = %p, index = %p\n", oindex, index);
> BUG();
> }
> *oindex = *index = cur->bc_ptrs[level];
> return 0;
> }
>
>
> xfs_btree_set_ptr_null(cur, &nptr);
> if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
> printk("%s: before calling
> xfs_btree_make_block_unfull, &optr = %p, &ptr = %p\n",
> __func__, &optr, &ptr);
> error = xfs_btree_make_block_unfull(cur, level, numrecs,
> &optr, &ptr, &nptr, &ncur, &nrec, stat);
> if (error || *stat == 0)
> goto error0;
> }
>
>
> We are waiting for OOPS to happen.
>
> I hope it will nerver be memory corrupt problem which is nightmare for
> me to debug.
>
>> Cheers,
>>
>> Dave.
>> --
>> Dave Chinner
>> david@...
>>
>
>
>

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T17:56:32Z

2009/12/15 Dave Chinner <david@...>:

> On Tue, Dec 15, 2009 at 08:49:37AM +0800, hank peng wrote:
>> Hi, Eric:
>> I add some code like this:
>> if (*stat) {
>> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
>> *stat, oindex, index);
>> if (oindex == NULL || index == NULL) {
>
> This won't catch bad non-NULL pointers like you are seeing.
>
>> printk("BUG occured!\n");
>> printk("oindex = %p, index = %p\n", oindex, index);
>> BUG();
>> }
>> *oindex = *index = cur->bc_ptrs[level];
>> return 0;
>> }
>>
>> And the same OOPS happened again but a little different, kernel messages are:
>>
>> <snip>
>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
>> *stat = 0x00000001, oindex = 00000501, index = 22008424
>> Unable to handle kernel paging request for data at address 0x22008424
>
> Given that oindex and index are stack varibles, this indicates some
> thing is probably smashing the stack. Possibly a buffer overrun. To
> narrow down the possible cause, can you add the debug:
>
> printk("%s:%s: oindex = %p, index = %p\n",
> __func__, __LINE__, oindex, index);
>
> throughout the xfs_btree_make_block_unfull() function? i.e. at
> first entry, before the xfs_btree_rshift() call, before the
> xfs_btree_lshift() call, etc, to see if any of the parameters
> are being modified during execution of the function?
>
> If the variables being passed into xfs_btree_make_block_unfull() are
> already bad, then do the same thing for the caller
> xfs_btree_insert(). This may help narrow down where the problem
> is coming from....
>

Thanks for your reply!
As you said, I added some code like this:
/* First, try shifting an entry to the right neighbor. */
printk("%s: before xfs_btree_rshift, oindex = %p, index = %p\n",
__func__, oindex, index);
error = xfs_btree_rshift(cur, level, stat);
if (error || *stat)
return error;

/* Next, try shifting an entry to the left neighbor. */
printk("%s: before xfs_btree_lshift, oindex = %p, index = %p\n",
__func__, oindex, index);
error = xfs_btree_lshift(cur, level, stat);
if (error)
return error;

if (*stat) {
printk("*stat = 0x%08x, oindex = %p, index = %p\n",
*stat, oindex, index);
if (oindex == NULL || index == NULL) {
printk("BUG occured!\n");
printk("oindex = %p, index = %p\n", oindex, index);
BUG();
}
*oindex = *index = cur->bc_ptrs[level];
return 0;
}

xfs_btree_set_ptr_null(cur, &nptr);
if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
printk("%s: before calling
xfs_btree_make_block_unfull, &optr = %p, &ptr = %p\n",
__func__, &optr, &ptr);
error = xfs_btree_make_block_unfull(cur, level, numrecs,
&optr, &ptr, &nptr, &ncur, &nrec, stat);
if (error || *stat == 0)
goto error0;
}

We are waiting for OOPS to happen.

I hope it will nerver be memory corrupt problem which is nightmare for
me to debug.

> Cheers,
>
> Dave.
> --
> Dave Chinner
> david@...
>

--
The simplest is not all best but the best is surely the simplest!

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T17:26:40Z

On Tue, Dec 15, 2009 at 08:49:37AM +0800, hank peng wrote:
> Hi, Eric:
> I add some code like this:
> if (*stat) {
> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
> *stat, oindex, index);
> if (oindex == NULL || index == NULL) {

This won't catch bad non-NULL pointers like you are seeing.

> printk("BUG occured!\n");
> printk("oindex = %p, index = %p\n", oindex, index);
> BUG();
> }
> *oindex = *index = cur->bc_ptrs[level];
> return 0;
> }
>
> And the same OOPS happened again but a little different, kernel messages are:
>
> <snip>
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = 00000501, index = 22008424
> Unable to handle kernel paging request for data at address 0x22008424

Given that oindex and index are stack varibles, this indicates some
thing is probably smashing the stack. Possibly a buffer overrun. To
narrow down the possible cause, can you add the debug:

printk("%s:%s: oindex = %p, index = %p\n",
__func__, __LINE__, oindex, index);

throughout the xfs_btree_make_block_unfull() function? i.e. at
first entry, before the xfs_btree_rshift() call, before the
xfs_btree_lshift() call, etc, to see if any of the parameters
are being modified during execution of the function?

If the variables being passed into xfs_btree_make_block_unfull() are
already bad, then do the same thing for the caller
xfs_btree_insert(). This may help narrow down where the problem
is coming from....

Cheers,

Dave.
--
Dave Chinner
david@...

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T16:58:15Z

2009/12/15 hank peng <pengxihan@...>:

> Hi, Eric:
> I add some code like this:
> if (*stat) {
> printk("*stat = 0x%08x, oindex = %p, index = %p\n",
> *stat, oindex, index);
> if (oindex == NULL || index == NULL) {
> printk("BUG occured!\n");
> printk("oindex = %p, index = %p\n", oindex, index);
> BUG();
> }
> *oindex = *index = cur->bc_ptrs[level];
> return 0;
> }
>
> And the same OOPS happened again but a little different, kernel messages are:
>
> <snip>
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
> *stat = 0x00000001, oindex = 00000501, index = 22008424
> Unable to handle kernel paging request for data at address 0x22008424
> Faulting instruction address: 0xc019f568
> Oops: Kernel access of bad area, sig: 11 [#1]
> MPC85xx CDS
> Modules linked in:
> NIP: c019f568 LR: c019f54c CTR: c023f9f4
> REGS: e87d7af0 TRAP: 0300 Not tainted (2.6.31.6-svn40)
> MSR: 00029000 <EE,ME,CE> CR: 22008424 XER: 20000000
> DEAR: 22008424, ESR: 00800000
> TASK = efb03390[17279] 'SS_Server' THREAD: e87d6000
> GPR00: 000001fd e87d7ba0 efb03390 0000003b 00031d91 ffffffff c023cfa4 00031d91
> GPR08: c04a7c40 e84511c8 00031d91 00004000 20008482 1016d410 3fff5400 100a0000
> GPR16: 100d0408 00000000 00000000 e8fa3558 c019d0ac 00029000 e87d7c5c c01876f0
> GPR24: c019d088 00000000 22008424 00000000 00000501 e87d7c58 00000000 e84511c8
> NIP [c019f568] xfs_btree_make_block_unfull+0xe4/0x1f4
> LR [c019f54c] xfs_btree_make_block_unfull+0xc8/0x1f4
> Call Trace:
> [e87d7ba0] [c019f54c] xfs_btree_make_block_unfull+0xc8/0x1f4 (unreliable)
> [e87d7be0] [c019f9ec] xfs_btree_insrec+0x374/0x4b0
> [e87d7c50] [c019fba4] xfs_btree_insert+0x7c/0x1c0
> [e87d7cb0] [c01866ac] xfs_free_ag_extent+0x408/0x810
> [e87d7d20] [c0187188] xfs_free_extent+0xdc/0x104
> [e87d7db0] [c018fe70] xfs_bmap_finish+0x154/0x1a0
> [e87d7de0] [c01b6998] xfs_itruncate_finish+0x254/0x3b8
> [e87d7e60] [c01d0ea0] xfs_free_eofblocks+0x254/0x29c
> [e87d7ee0] [c01da70c] xfs_file_release+0x14/0x28
> [e87d7ef0] [c00957dc] __fput+0xe8/0x1dc
> [e87d7f10] [c00920d8] filp_close+0x70/0xb0
> [e87d7f30] [c00921ac] sys_close+0x94/0xc0
> [e87d7f40] [c000f7cc] ret_from_syscall+0x0/0x3c
> Instruction dump:
> 7f85e378 3863ed7c 7f46d378 4cc63182 4be97ea1 2f9c0000 419e00f8 2f9a0000
> 419e00f0 57c9103a 7d29fa14 80090050 <901a0000> 901c0000 4bffff88 3b810010
> ---[ end trace f245b6a670339d8f ]---
> </snip>
>
> As you see, after printing "*stat = 0x00000001, oindex = 00000501,
> index = 22008424", OOPS happened.
> Although my BUG() was not invoked, it did access bad area.
>

This is what gdb shows:

(gdb) list *xfs_btree_make_block_unfull+0xe4
0xc019f568 is in xfs_btree_make_block_unfull (fs/xfs/xfs_btree.c:2650).
2645 if (oindex == NULL || index == NULL) {
2646 printk("BUG occured!\n");
2647 printk("oindex = %p, index = %p\n",
oindex, index);
2648 BUG();
2649 }
2650 *oindex = *index = cur->bc_ptrs[level];
/* why alaways here????? */
2651 return 0;
2652 }
2653
2654 /*
(gdb)
Why suddenly abnormal? memory corrupt? If so, why this OOPS always
occured at the same place?

>
>
> 2009/12/14 Eric Sandeen <sandeen@...>:
>> hank peng wrote:
>>> Hi,Eric:
>>> I think I have found the reason to this problem, but I need you a little help.
>>> We have tested it again, and the same OOPS occured again:
>>
>> Ok, let's keep this on the list please ...
>>
>>> Unable to handle kernel paging request for data at address 0x00000000
>>> Faulting instruction address: 0xc019f4b8
>>> Oops: Kernel access of bad area, sig: 11 [#1]
>>> MPC85xx CDS
>>> Modules linked in:
>>> NIP: c019f4b8 LR: c019f490 CTR: 00000000
>>> REGS: ef965af0 TRAP: 0300 Not tainted (2.6.31.6-svn40)
>>> MSR: 00029000 <EE,ME,CE> CR: 22008284 XER: 00000000
>>> DEAR: 00000000, ESR: 00800000
>>> TASK = e8a56580[3450] 'SS_Server' THREAD: ef964000
>>> GPR00: 000001fd ef965ba0 e8a56580 00000000 00000000 00000001 00000001 00000001
>>> GPR08: e8fa10e8 e8fa1a18 e8fa10f0 000001fd 22008222 1016d410 3fff5400 100a0000
>>> GPR16: 100d2408 00000000 00000000 d42b12f8 c019d01c 00029000 ef965c5c c0187660
>>> GPR24: c019cff8 00000000 22008224 ef965c08 00000000 ef965c58 00000000 e8fa1a18
>>> NIP [c019f4b8] xfs_btree_make_block_unfull+0xc4/0x1b0
>>> LR [c019f490] xfs_btree_make_block_unfull+0x9c/0x1b0
>>> Call Trace:
>>> [ef965ba0] [c019f490] xfs_btree_make_block_unfull+0x9c/0x1b0 (unreliable)
>>> [ef965be0] [c019f918] xfs_btree_insrec+0x374/0x4b0
>>> [ef965c50] [c019fad0] xfs_btree_insert+0x7c/0x1c0
>>> [ef965cb0] [c018661c] xfs_free_ag_extent+0x408/0x810
>>> [ef965d20] [c01870f8] xfs_free_extent+0xdc/0x104
>>> [ef965db0] [c018fde0] xfs_bmap_finish+0x154/0x1a0
>>> [ef965de0] [c01b68c4] xfs_itruncate_finish+0x254/0x3b8
>>> [ef965e60] [c01d0dcc] xfs_free_eofblocks+0x254/0x29c
>>> [ef965ee0] [c01da638] xfs_file_release+0x14/0x28
>>> [ef965ef0] [c009574c] __fput+0xe8/0x1dc
>>> [ef965f10] [c0092048] filp_close+0x70/0xb0
>>> [ef965f30] [c009211c] sys_close+0x94/0xc0
>>> [ef965f40] [c000f784] ret_from_syscall+0x0/0x3c
>>> Instruction dump:
>>> 7fa5eb78 4bffdf59 7c7c1b79 40a2ffd4 801d0000 2f800000 419e0064 57c9103a
>>> 7f83e378 7d29fa14 80090050 90170000 <90190000> 80010044 bae1001c 38210040
>>> ---[ end trace 356726176eeecd9c ]---
>>> Oops: Exception in kernel mode, sig: 4 [#2]
>>> MPC85xx CDS
>>> Modules linked in:
>>> NIP: c0187660 LR: c019b26c CTR: c0187660
>>> REGS: d42076a0 TRAP: 0700 Tainted: G D (2.6.31.6-svn40)
>>> MSR: 00029000 <EE,ME,CE> CR: 22222082 XER: 00000000
>>> TASK = e08a6ee0[8533] 'pdflush' THREAD: d4206000
>>> GPR00: 00000004 d4207750 e08a6ee0 d42b1098 00000001 00000001 e8e97d80 00000003
>>> GPR08: c2c65300 c0187660 41425443 41425443 00001000 1001a1c4 c01842f8 00000001
>>> GPR16: d4207880 d42077e0 00000002 d42077d8 d42077e0 d42077e8 d42b10ec 00000001
>>> GPR24: c0486be0 00000000 d42b1098 09c40000 c019b4f0 00000011 e88bf000 d4207750
>>> NIP [c0187660] xfs_allocbt_get_maxrecs+0x0/0x20
>>> LR [c019b26c] xfs_btree_check_sblock+0xb0/0xf8
>>> Call Trace:
>>> [d4207770] [c019b4f0] xfs_btree_read_buf_block+0x8c/0xb8
>>> [d42077a0] [c019b5a8] xfs_btree_lookup_get_block+0x8c/0xfc
>>> [d42077d0] [c019c638] xfs_btree_lookup+0x124/0x3fc
>>> [d4207850] [c01842f8] xfs_alloc_lookup_ge+0x20/0x30
>>> [d4207860] [c0185828] xfs_alloc_ag_vextent_near+0x60/0xa4c
>>> [d42078e0] [c0186af4] xfs_alloc_ag_vextent+0xd0/0x168
>>> [d4207900] [c01873f0] xfs_alloc_vextent+0x2d0/0x524
>>> [d4207940] [c01940fc] xfs_bmap_btalloc+0x274/0xa60
>>> [d4207a00] [c01988bc] xfs_bmapi+0xb30/0x10dc
>>> [d4207b40] [c01bb190] xfs_iomap_write_allocate+0x11c/0x450
>>> [d4207c00] [c01bc2e8] xfs_iomap+0x320/0x35c
>>> [d4207c80] [c01d5d5c] xfs_map_blocks+0x2c/0x40
>>> [d4207ca0] [c01d6dc0] xfs_page_state_convert+0x2e8/0x744
>>> [d4207d60] [c01d7384] xfs_vm_writepage+0x7c/0x128
>>> [d4207d90] [c006d740] __writepage+0x24/0x80
>>> [d4207da0] [c006db44] write_cache_pages+0x1e4/0x3a0
>>> [d4207e50] [c01d5e14] xfs_vm_writepages+0x24/0x34
>>> [d4207e60] [c006dd70] do_writepages+0x48/0x7c
>>> [d4207e70] [c00b2120] writeback_single_inode+0xf8/0x2e4
>>> [d4207ec0] [c00b2788] generic_sync_sb_inodes+0x280/0x398
>>> [d4207ef0] [c00b295c] writeback_inodes+0xb8/0xd4
>>> [d4207f10] [c006ece0] wb_kupdate+0xd4/0x154
>>> [d4207f70] [c006f3bc] pdflush+0xd4/0x1c4
>>> [d4207fc0] [c004c750] kthread+0x78/0x7c
>>> <...>
>>>
>>>
>>> There were another OOPS which followed the first one.
>>
>> After the first oops I think the rest is not interesting, things
>> are in bad shape by now.
>>
>>> Please note that
>>> in the second OOPS, a SIGILL has been invoked and address of illegal
>>> instrucion is 0xc0187660.
>>> In the first OOPS, look at the following registers:
>>>
>>> GPR00: 000001fd ef965ba0 e8a56580 00000000 00000000 00000001 00000001 00000001
>>> GPR08: e8fa10e8 e8fa1a18 e8fa10f0 000001fd 22008222 1016d410 3fff5400 100a0000
>>> GPR16: 100d2408 00000000 00000000 d42b12f8 c019d01c 00029000 ef965c5c c0187660
>>> GPR24: c019cff8 00000000 22008224 ef965c08 00000000 ef965c58 00000000 e8fa1a18
>>>
>>> I noticed that the value of r23 is also 0xc0187660. I have a little
>>> powerpc assembly code knowledge, if I am not wrong,
>>> *oindex = *index = cur->bc_ptrs[level];' in fs/xfs/xfs_btree.c was
>>> built into the following asm code which I send it to you ealier:
>>> 80 09 00 50 lwz r0,80(r9)
>>> 90 17 00 00 stw r0,0(r23)
>>> 90 19 00 00 stw r0,0(r25) <OOPs occured here>
>>>
>>> So, r23 should have pointed to address of index and never had a chace
>>> to point to a code adress, but it did. What's worse, the code at
>>> 0xc0187660 had been changed and the second OOPS happened imediately.
>>>
>>> Could you correct my analysis if I am wrong?
>>> In addition, I think the problem may be caused by stack overflow, what
>>> is your comments?
>>>
>>>
>> Perhaps, but if this is the 2nd oops I think it is not worth investigating;
>> we need to figure out why the first one happened, and from that stack trace
>> I don't think you are close to overflowing...
>>
>> -eric
>>
>>>
>>> 2009/12/9 hank peng <pengxihan@...>:
>>>> 2009/12/9 hank peng <pengxihan@...>:
>>>>> 2009/12/9 Eric Sandeen <sandeen@...>:
>>>>>> hank peng wrote:
>>>>>>> 2009/12/9 Eric Sandeen <sandeen@...>:
>>>>>>>> hank peng wrote:
>>>>>>>>
>>>>>>>>> Thanks for your replay.
>>>>>>>>>
>>>>>>>>> I made this conclusion from assembly code, correct me if I am wrong.
>>>>>>>>> #powerpc-linux-gnuspe-objdump vmlinux | less
>>>>>>>>> <snip>
>>>>>>>> (off list; if this works maybe you can reply on-list?)
>>>>>>>>
>>>>>>>> Could you use gdb to look? Maybe:
>>>>>>>>
>>>>>>>> (gdb) list *xfs_btree_make_block_unfull+0xc4
>>>>>>>>
>>>>>>> I use gdb on my PC and get this:
>>>>>>>
>>>>>>> [root@localhost linux-2.6.31.6]# gdb vmlinux
>>>>>>> GNU gdb Red Hat Linux (6.5-37.el5rh)
>>>>>>> Copyright (C) 2006 Free Software Foundation, Inc.
>>>>>>> GDB is free software, covered by the GNU General Public License, and you are
>>>>>>> welcome to change it and/or distribute copies of it under certain conditions.
>>>>>>> Type "show copying" to see the conditions.
>>>>>>> There is absolutely no warranty for GDB. Type "show warranty" for details.
>>>>>>> This GDB was configured as "i386-redhat-linux-gnu"...Using host
>>>>>>> libthread_db library "/lib/libthread_db.so.1".
>>>>>>>
>>>>>>> (gdb) list *xfs_btree_make_block_unfull+0xc4
>>>>>>> No source file for address 0xc019ea28.
>>>>>>> (gdb)
>>>>>>>
>>>>>>>> -Eric
>>>>>> so I guess it is not built with debugging symbols perhaps?
>>>>>>
>>>>>> Try rebuilding it with CONFIG_DEBUG_INFO on maybe?
>>>>>>
>>>>> yes, you are right, now I get the result:
>>>>> (gdb) l *xfs_btree_make_block_unfull+0xc4
>>>>> 0xc019ea30 is in xfs_btree_make_block_unfull (fs/xfs/xfs_btree.c:2643).
>>>>> 2638 error = xfs_btree_lshift(cur, level, stat);
>>>>> 2639 if (error)
>>>>> 2640 return error;
>>>>> 2641
>>>>> 2642 if (*stat) {
>>>>> 2643 *oindex = *index = cur->bc_ptrs[level];
>>>>> 2644 return 0;
>>>>> 2645 }
>>>>> 2646
>>>>> 2647 /*
>>>>>
>>>>> It indeed points to "*oindex = *index = cur->bc_ptrs[level];"
>>>>>
>>>> Very strange, as you said, xfs_btree_insrec passes address local
>>>> variable to xfs_btree_make_block_unfull, so it is impossible for
>>>> oindex to be NULL.
>>>> Do you think it may be an memory corrupt?
>>>>>> -Eric
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> The simplest is not all best but the best is surely the simplest!
>>>>>
>>>>
>>>>
>>>> --
>>>> The simplest is not all best but the best is surely the simplest!
>>>>
>>>
>>>
>>>
>>
>>
>
>
>
> --
> The simplest is not all best but the best is surely the simplest!
>

--
The simplest is not all best but the best is surely the simplest!

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs

Re: [BUG report]xfs_btree_make_block_unfull generated an OOPS

2009-12-14T16:49:37Z

Hi, Eric:
I add some code like this:
if (*stat) {
printk("*stat = 0x%08x, oindex = %p, index = %p\n",
*stat, oindex, index);
if (oindex == NULL || index == NULL) {
printk("BUG occured!\n");
printk("oindex = %p, index = %p\n", oindex, index);
BUG();
}
*oindex = *index = cur->bc_ptrs[level];
return 0;
}

And the same OOPS happened again but a little different, kernel messages are:

<snip>
*stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
*stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
*stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
*stat = 0x00000001, oindex = e87d7bf8, index = e87d7bfc
*stat = 0x00000001, oindex = 00000501, index = 22008424
Unable to handle kernel paging request for data at address 0x22008424
Faulting instruction address: 0xc019f568
Oops: Kernel access of bad area, sig: 11 [#1]
MPC85xx CDS
Modules linked in:
NIP: c019f568 LR: c019f54c CTR: c023f9f4
REGS: e87d7af0 TRAP: 0300 Not tainted (2.6.31.6-svn40)
MSR: 00029000 <EE,ME,CE> CR: 22008424 XER: 20000000
DEAR: 22008424, ESR: 00800000
TASK = efb03390[17279] 'SS_Server' THREAD: e87d6000
GPR00: 000001fd e87d7ba0 efb03390 0000003b 00031d91 ffffffff c023cfa4 00031d91
GPR08: c04a7c40 e84511c8 00031d91 00004000 20008482 1016d410 3fff5400 100a0000
GPR16: 100d0408 00000000 00000000 e8fa3558 c019d0ac 00029000 e87d7c5c c01876f0
GPR24: c019d088 00000000 22008424 00000000 00000501 e87d7c58 00000000 e84511c8
NIP [c019f568] xfs_btree_make_block_unfull+0xe4/0x1f4
LR [c019f54c] xfs_btree_make_block_unfull+0xc8/0x1f4
Call Trace:
[e87d7ba0] [c019f54c] xfs_btree_make_block_unfull+0xc8/0x1f4 (unreliable)
[e87d7be0] [c019f9ec] xfs_btree_insrec+0x374/0x4b0
[e87d7c50] [c019fba4] xfs_btree_insert+0x7c/0x1c0
[e87d7cb0] [c01866ac] xfs_free_ag_extent+0x408/0x810
[e87d7d20] [c0187188] xfs_free_extent+0xdc/0x104
[e87d7db0] [c018fe70] xfs_bmap_finish+0x154/0x1a0
[e87d7de0] [c01b6998] xfs_itruncate_finish+0x254/0x3b8
[e87d7e60] [c01d0ea0] xfs_free_eofblocks+0x254/0x29c
[e87d7ee0] [c01da70c] xfs_file_release+0x14/0x28
[e87d7ef0] [c00957dc] __fput+0xe8/0x1dc
[e87d7f10] [c00920d8] filp_close+0x70/0xb0
[e87d7f30] [c00921ac] sys_close+0x94/0xc0
[e87d7f40] [c000f7cc] ret_from_syscall+0x0/0x3c
Instruction dump:
7f85e378 3863ed7c 7f46d378 4cc63182 4be97ea1 2f9c0000 419e00f8 2f9a0000
419e00f0 57c9103a 7d29fa14 80090050 <901a0000> 901c0000 4bffff88 3b810010
---[ end trace f245b6a670339d8f ]---
</snip>

As you see, after printing "*stat = 0x00000001, oindex = 00000501,
index = 22008424", OOPS happened.
Although my BUG() was not invoked, it did access bad area.

2009/12/14 Eric Sandeen <sandeen@...>:

> hank peng wrote:
>> Hi,Eric:
>> I think I have found the reason to this problem, but I need you a little help.
>> We have tested it again, and the same OOPS occured again:
>
> Ok, let's keep this on the list please ...
>
>> Unable to handle kernel paging request for data at address 0x00000000
>> Faulting instruction address: 0xc019f4b8
>> Oops: Kernel access of bad area, sig: 11 [#1]
>> MPC85xx CDS
>> Modules linked in:
>> NIP: c019f4b8 LR: c019f490 CTR: 00000000
>> REGS: ef965af0 TRAP: 0300 Not tainted (2.6.31.6-svn40)
>> MSR: 00029000 <EE,ME,CE> CR: 22008284 XER: 00000000
>> DEAR: 00000000, ESR: 00800000
>> TASK = e8a56580[3450] 'SS_Server' THREAD: ef964000
>> GPR00: 000001fd ef965ba0 e8a56580 00000000 00000000 00000001 00000001 00000001
>> GPR08: e8fa10e8 e8fa1a18 e8fa10f0 000001fd 22008222 1016d410 3fff5400 100a0000
>> GPR16: 100d2408 00000000 00000000 d42b12f8 c019d01c 00029000 ef965c5c c0187660
>> GPR24: c019cff8 00000000 22008224 ef965c08 00000000 ef965c58 00000000 e8fa1a18
>> NIP [c019f4b8] xfs_btree_make_block_unfull+0xc4/0x1b0
>> LR [c019f490] xfs_btree_make_block_unfull+0x9c/0x1b0
>> Call Trace:
>> [ef965ba0] [c019f490] xfs_btree_make_block_unfull+0x9c/0x1b0 (unreliable)
>> [ef965be0] [c019f918] xfs_btree_insrec+0x374/0x4b0
>> [ef965c50] [c019fad0] xfs_btree_insert+0x7c/0x1c0
>> [ef965cb0] [c018661c] xfs_free_ag_extent+0x408/0x810
>> [ef965d20] [c01870f8] xfs_free_extent+0xdc/0x104
>> [ef965db0] [c018fde0] xfs_bmap_finish+0x154/0x1a0
>> [ef965de0] [c01b68c4] xfs_itruncate_finish+0x254/0x3b8
>> [ef965e60] [c01d0dcc] xfs_free_eofblocks+0x254/0x29c
>> [ef965ee0] [c01da638] xfs_file_release+0x14/0x28
>> [ef965ef0] [c009574c] __fput+0xe8/0x1dc
>> [ef965f10] [c0092048] filp_close+0x70/0xb0
>> [ef965f30] [c009211c] sys_close+0x94/0xc0
>> [ef965f40] [c000f784] ret_from_syscall+0x0/0x3c
>> Instruction dump:
>> 7fa5eb78 4bffdf59 7c7c1b79 40a2ffd4 801d0000 2f800000 419e0064 57c9103a
>> 7f83e378 7d29fa14 80090050 90170000 <90190000> 80010044 bae1001c 38210040
>> ---[ end trace 356726176eeecd9c ]---
>> Oops: Exception in kernel mode, sig: 4 [#2]
>> MPC85xx CDS
>> Modules linked in:
>> NIP: c0187660 LR: c019b26c CTR: c0187660
>> REGS: d42076a0 TRAP: 0700 Tainted: G D (2.6.31.6-svn40)
>> MSR: 00029000 <EE,ME,CE> CR: 22222082 XER: 00000000
>> TASK = e08a6ee0[8533] 'pdflush' THREAD: d4206000
>> GPR00: 00000004 d4207750 e08a6ee0 d42b1098 00000001 00000001 e8e97d80 00000003
>> GPR08: c2c65300 c0187660 41425443 41425443 00001000 1001a1c4 c01842f8 00000001
>> GPR16: d4207880 d42077e0 00000002 d42077d8 d42077e0 d42077e8 d42b10ec 00000001
>> GPR24: c0486be0 00000000 d42b1098 09c40000 c019b4f0 00000011 e88bf000 d4207750
>> NIP [c0187660] xfs_allocbt_get_maxrecs+0x0/0x20
>> LR [c019b26c] xfs_btree_check_sblock+0xb0/0xf8
>> Call Trace:
>> [d4207770] [c019b4f0] xfs_btree_read_buf_block+0x8c/0xb8
>> [d42077a0] [c019b5a8] xfs_btree_lookup_get_block+0x8c/0xfc
>> [d42077d0] [c019c638] xfs_btree_lookup+0x124/0x3fc
>> [d4207850] [c01842f8] xfs_alloc_lookup_ge+0x20/0x30
>> [d4207860] [c0185828] xfs_alloc_ag_vextent_near+0x60/0xa4c
>> [d42078e0] [c0186af4] xfs_alloc_ag_vextent+0xd0/0x168
>> [d4207900] [c01873f0] xfs_alloc_vextent+0x2d0/0x524
>> [d4207940] [c01940fc] xfs_bmap_btalloc+0x274/0xa60
>> [d4207a00] [c01988bc] xfs_bmapi+0xb30/0x10dc
>> [d4207b40] [c01bb190] xfs_iomap_write_allocate+0x11c/0x450
>> [d4207c00] [c01bc2e8] xfs_iomap+0x320/0x35c
>> [d4207c80] [c01d5d5c] xfs_map_blocks+0x2c/0x40
>> [d4207ca0] [c01d6dc0] xfs_page_state_convert+0x2e8/0x744
>> [d4207d60] [c01d7384] xfs_vm_writepage+0x7c/0x128
>> [d4207d90] [c006d740] __writepage+0x24/0x80
>> [d4207da0] [c006db44] write_cache_pages+0x1e4/0x3a0
>> [d4207e50] [c01d5e14] xfs_vm_writepages+0x24/0x34
>> [d4207e60] [c006dd70] do_writepages+0x48/0x7c
>> [d4207e70] [c00b2120] writeback_single_inode+0xf8/0x2e4
>> [d4207ec0] [c00b2788] generic_sync_sb_inodes+0x280/0x398
>> [d4207ef0] [c00b295c] writeback_inodes+0xb8/0xd4
>> [d4207f10] [c006ece0] wb_kupdate+0xd4/0x154
>> [d4207f70] [c006f3bc] pdflush+0xd4/0x1c4
>> [d4207fc0] [c004c750] kthread+0x78/0x7c
>> <...>
>>
>>
>> There were another OOPS which followed the first one.
>
> After the first oops I think the rest is not interesting, things
> are in bad shape by now.
>
>> Please note that
>> in the second OOPS, a SIGILL has been invoked and address of illegal
>> instrucion is 0xc0187660.
>> In the first OOPS, look at the following registers:
>>
>> GPR00: 000001fd ef965ba0 e8a56580 00000000 00000000 00000001 00000001 00000001
>> GPR08: e8fa10e8 e8fa1a18 e8fa10f0 000001fd 22008222 1016d410 3fff5400 100a0000
>> GPR16: 100d2408 00000000 00000000 d42b12f8 c019d01c 00029000 ef965c5c c0187660
>> GPR24: c019cff8 00000000 22008224 ef965c08 00000000 ef965c58 00000000 e8fa1a18
>>
>> I noticed that the value of r23 is also 0xc0187660. I have a little
>> powerpc assembly code knowledge, if I am not wrong,
>> *oindex = *index = cur->bc_ptrs[level];' in fs/xfs/xfs_btree.c was
>> built into the following asm code which I send it to you ealier:
>> 80 09 00 50 lwz r0,80(r9)
>> 90 17 00 00 stw r0,0(r23)
>> 90 19 00 00 stw r0,0(r25) <OOPs occured here>
>>
>> So, r23 should have pointed to address of index and never had a chace
>> to point to a code adress, but it did. What's worse, the code at
>> 0xc0187660 had been changed and the second OOPS happened imediately.
>>
>> Could you correct my analysis if I am wrong?
>> In addition, I think the problem may be caused by stack overflow, what
>> is your comments?
>>
>>
> Perhaps, but if this is the 2nd oops I think it is not worth investigating;
> we need to figure out why the first one happened, and from that stack trace
> I don't think you are close to overflowing...
>
> -eric
>
>>
>> 2009/12/9 hank peng <pengxihan@...>:
>>> 2009/12/9 hank peng <pengxihan@...>:
>>>> 2009/12/9 Eric Sandeen <sandeen@...>:
>>>>> hank peng wrote:
>>>>>> 2009/12/9 Eric Sandeen <sandeen@...>:
>>>>>>> hank peng wrote:
>>>>>>>
>>>>>>>> Thanks for your replay.
>>>>>>>>
>>>>>>>> I made this conclusion from assembly code, correct me if I am wrong.
>>>>>>>> #powerpc-linux-gnuspe-objdump vmlinux | less
>>>>>>>> <snip>
>>>>>>> (off list; if this works maybe you can reply on-list?)
>>>>>>>
>>>>>>> Could you use gdb to look? Maybe:
>>>>>>>
>>>>>>> (gdb) list *xfs_btree_make_block_unfull+0xc4
>>>>>>>
>>>>>> I use gdb on my PC and get this:
>>>>>>
>>>>>> [root@localhost linux-2.6.31.6]# gdb vmlinux
>>>>>> GNU gdb Red Hat Linux (6.5-37.el5rh)
>>>>>> Copyright (C) 2006 Free Software Foundation, Inc.
>>>>>> GDB is free software, covered by the GNU General Public License, and you are
>>>>>> welcome to change it and/or distribute copies of it under certain conditions.
>>>>>> Type "show copying" to see the conditions.
>>>>>> There is absolutely no warranty for GDB. Type "show warranty" for details.
>>>>>> This GDB was configured as "i386-redhat-linux-gnu"...Using host
>>>>>> libthread_db library "/lib/libthread_db.so.1".
>>>>>>
>>>>>> (gdb) list *xfs_btree_make_block_unfull+0xc4
>>>>>> No source file for address 0xc019ea28.
>>>>>> (gdb)
>>>>>>
>>>>>>> -Eric
>>>>> so I guess it is not built with debugging symbols perhaps?
>>>>>
>>>>> Try rebuilding it with CONFIG_DEBUG_INFO on maybe?
>>>>>
>>>> yes, you are right, now I get the result:
>>>> (gdb) l *xfs_btree_make_block_unfull+0xc4
>>>> 0xc019ea30 is in xfs_btree_make_block_unfull (fs/xfs/xfs_btree.c:2643).
>>>> 2638 error = xfs_btree_lshift(cur, level, stat);
>>>> 2639 if (error)
>>>> 2640 return error;
>>>> 2641
>>>> 2642 if (*stat) {
>>>> 2643 *oindex = *index = cur->bc_ptrs[level];
>>>> 2644 return 0;
>>>> 2645 }
>>>> 2646
>>>> 2647 /*
>>>>
>>>> It indeed points to "*oindex = *index = cur->bc_ptrs[level];"
>>>>
>>> Very strange, as you said, xfs_btree_insrec passes address local
>>> variable to xfs_btree_make_block_unfull, so it is impossible for
>>> oindex to be NULL.
>>> Do you think it may be an memory corrupt?
>>>>> -Eric
>>>>>
>>>>
>>>>
>>>> --
>>>> The simplest is not all best but the best is surely the simplest!
>>>>
>>>
>>>
>>> --
>>> The simplest is not all best but the best is surely the simplest!
>>>
>>
>>
>>
>
>

--
The simplest is not all best but the best is surely the simplest!

_______________________________________________
xfs mailing list
xfs@...
http://oss.sgi.com/mailman/listinfo/xfs