Oops: Quota race in 2.4.12?
Some of our dual CPU web servers with 2.4.12 are Oopsing while running quotacheck. They don't seem to die immediately, but oops many times and eventually break. The old tools didn't warn about quotachecking on a live file system, so some of our servers were set up to run quotacheck nightly. The new tools still allow you to do it, but warn that it may not be consistent. We didn't have any problems with 2.2 kernels.
First oops, as already processed (grumble) by klogd:
Oct 28 04:22:32 pro kernel: remove_free_dquot: dquot not on the free list?? Oct 28 04:22:32 pro last message repeated 90 times Oct 28 04:22:32 pro kernel: Unable to handle kernel NULL pointer dereference at virtual address 00000004
...dates stripped:
Unable to handle kernel NULL pointer dereference at virtual address 00000004
printing eip:
c0149edc
*pde = 00000000
Oops: 0002
CPU: 1
EIP: 0010:[dqput+148/188] Not tainted
EFLAGS: 00010246
eax: d58c8830 ebx: cf330cc0 ecx: cf330cd0 edx: 00000000
esi: cf330cc0 edi: d2847f6c ebp: 00000000 esp: d2847f30
ds: 0018 es: 0018 ss: 0018
Process quotacheck (pid: 3933, stackpage=d2847000)
Stack: 00000000 c014a93e cf330cc0 00006000 c1a58800 00000000 d2847fa4 00000000
00000000 00000000 00000000 00000000 00000000 00000000 00000000 c014b8f0
c1a58800 0000f465 00000000 00000004 bffffd54 d2846000 bffffd54 001e8ca0
Call Trace: [set_dqblk+390/404] [sys_quotactl+780/892] [sys_read+188/196] [system_call+51/56]
Code: 89 4a 04 89 53 10 89 41 04 89 08 ff 05 e4 ab 34 c0 8d 43 24 Perhaps there is some obviously broken locking/code in the quotactl syscall?
The next Oops, 6 seconds later:
<1>Unable to handle kernel NULL pointer dereference at virtual address 00000004 printing eip:c0149edc
*pde = 00000000
Oops: 0002
CPU: 1
EIP: 0010:[dqput+148/188] Not tainted
EFLAGS: 00010246
eax: d58c8830 ebx: cf330c40 ecx: cf330c50 edx: 00000000
esi: d4a08ca4 edi: d4a08bc0 ebp: c36f5a40 esp: d16f5efc
ds: 0018 es: 0018 ss: 0018
Process mv (pid: 7146, stackpage=d16f5000)
Stack: 00000000 c014acda cf330c40 d16f4000 c1a58c00 c0155a8f d4a08bc0 d4a08bc0
d4a08bc0 c0156370 c36f5a40 c36f5a40 00000022 00000000 e2757480 c01563f7
c015641d d4a08bc0 d4a08bc0 d16f4000 c0146c19 d4a08bc0 c36f5a40 d4a08bc0
Call Trace: [dquot_drop+54/68] [ext2_free_inode+231/616] [ext2_delete_inode+0/296] [ext2_delete_inode+135/296] [ext2_delete_inode+173/296]
[iput+389/600] [d_delete+98/160] [vfs_unlink+492/540] [sys_unlink+169/288] [system_call+51/56]
Code: 89 4a 04 89 53 10 89 41 04 89 08 ff 05 e4 ab 34 c0 8d 43 24 ...Many more oopses follow over time.
Simon-
[ Stormix Technologies Inc. ][ NetNation Communications Inc. ]
[ [email protected] ][ [email protected] ]
[ Opinions expressed are not necessarily those of my employers. ]
Jan Kara
reviewerHello,
Quoted 33 lines
Some of our dual CPU web servers with 2.4.12 are Oopsing while running quotacheck. They don't seem to die immediately, but oops many times and eventually break. The old tools didn't warn about quotachecking on a live file system, so some of our servers were set up to run quotacheck nightly. The new tools still allow you to do it, but warn that it may not be consistent. We didn't have any problems with 2.2 kernels.
First oops, as already processed (grumble) by klogd:
Oct 28 04:22:32 pro kernel: remove_free_dquot: dquot not on the free list?? Oct 28 04:22:32 pro last message repeated 90 times Oct 28 04:22:32 pro kernel: Unable to handle kernel NULL pointer dereference at virtual address 00000004...dates stripped:
Unable to handle kernel NULL pointer dereference at virtual address 00000004 printing eip: c0149edc *pde = 00000000 Oops: 0002 CPU: 1 EIP: 0010:[dqput+148/188] Not tainted EFLAGS: 00010246 eax: d58c8830 ebx: cf330cc0 ecx: cf330cd0 edx: 00000000 esi: cf330cc0 edi: d2847f6c ebp: 00000000 esp: d2847f30 ds: 0018 es: 0018 ss: 0018 Process quotacheck (pid: 3933, stackpage=d2847000) Stack: 00000000 c014a93e cf330cc0 00006000 c1a58800 00000000 d2847fa4 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 c014b8f0 c1a58800 0000f465 00000000 00000004 bffffd54 d2846000 bffffd54 001e8ca0 Call Trace: [set_dqblk+390/404] [sys_quotactl+780/892] [sys_read+188/196] [system_call+51/56] Code: 89 4a 04 89 53 10 89 41 04 89 08 ff 05 e4 ab 34 c0 8d 43 24
Quoted 1 line
Perhaps there is some obviously broken locking/code in the quotactl syscall?
I'd also blame some SMP locking (I think that on UP everything was tested well) but
everything should be protected by lock_kernel() and it seems to me that everything really is protected. Anyway I'll try to find the problem.
Thanks for report
Honza
--
Jan Kara <[email protected]>
SuSE CR Labs
Quoted 3 lines · Jan Kara
I'd also blame some SMP locking (I think that on UP everything was tested well) but
everything should be protected bylock_kernel()and it seems to me that everything really is protected. Anyway I'll try to find the problem.
I notice you just recently posted a patch to fix possible list corruption. Could this be related?
Simon-
[ Stormix Technologies Inc. ][ NetNation Communications Inc. ]
[ [email protected] ][ [email protected] ]
[ Opinions expressed are not necessarily those of my employers. ]
Jan Kara
reviewerQuoted 8 lines · Jan Kara
Quoted 4 lines
I'd also blame some SMP locking (I think that on UP everything was tested well) but
everything should be protected bylock_kernel()and it seems to me that everything really is protected. Anyway I'll try to find the problem.I notice you just recently posted a patch to fix possible list corruption. Could this be related?
Nope. That was a fix specific to code in -ac kernel..
Honza
--
Jan Kara <[email protected]>
SuSE CR Labs
Jan Kara
reviewerHello,
Quoted 16 lines · On Sunday October 28, [email protected] wrote:
Quoted 6 lines
Some of our dual CPU web servers with 2.4.12 are Oopsing while running quotacheck. They don't seem to die immediately, but oops many times and eventually break. The old tools didn't warn about quotachecking on a live file system, so some of our servers were set up to run quotacheck nightly. The new tools still allow you to do it, but warn that it may not be consistent. We didn't have any problems with 2.2 kernels.
quotacheck cannot be reliable on a live system as it scans through the filesystem counting the usage for each user and then updates the quotas file. If usage changes between scanning a file and updating
the quota record, you get an error. This is particularly a problem
if quotacheck takes a long time, and on one of my servers (heavily loaded NFS server) quotacheck takes a *long* time if the server is live (it isn't exactly quick if it isn't live either).
Quoted 4 lines
I wrote a little program which uses libext2fs to scan the block device for inodes and add up usage that way (as opposed to walking the filetree as I believe quotacheck does). It runs *much* faster (minutes instead of hours).
Note that quotacheck(8) uses e2fslib too if compiled properly...
Honza
Quoted 1 line
Jan Kara
reviewerHi,
Quoted 7 lines
Some of our dual CPU web servers with 2.4.12 are Oopsing while running quotacheck. They don't seem to die immediately, but oops many times and eventually break. The old tools didn't warn about quotachecking on a live file system, so some of our servers were set up to run quotacheck nightly. The new tools still allow you to do it, but warn that it may not be consistent. We didn't have any problems with 2.2 kernels.
Quoted 6 lines
First oops, as already processed (grumble) by klogd:
Oct 28 04:22:32 pro kernel: remove_free_dquot: dquot not on the free list?? Oct 28 04:22:32 pro last message repeated 90 times Oct 28 04:22:32 pro kernel: Unable to handle kernel NULL pointer dereference at virtual address 00000004...dates stripped:
<snip>
Attached is the patch against 2.4.13 which should solve some SMP races... Can you try
it if it fixes your problems? I know also about one possible race during quotaoff() which I'll fix tonight but that shouldn't be your case :).
Honza
fs/dquot.c +11 -20
@@ -330,24 +330,6 @@unlock_dquot (dquot); } -/* -* Unhash and selectively clear the dquot structure, -* but preserve the use count, list pointers, and -* wait queue. -*/ -void clear_dquot (struct dquot *dquot) -{ -/* unhash it first */ -remove_dquot_hash (dquot); - dquot->dq_sb =NULL ; - dquot->dq_id =0 ; - dquot->dq_dev =NODEV ; - dquot->dq_type =-1 ; - dquot->dq_flags =0 ; - dquot->dq_referenced =0 ; -memset (&dquot->dq_dqb,0 ,sizeof (struct dqblk )); -} -/* Invalidate all dquots on the list, wait for all users. Note that this function is called * after quota is disabled so no new quota might be created. As we only insert to the end of * inuse list, we don't have to restart searching... */
@@ -384,6 +366,7 @@struct list_head *head;struct dquot *dquot; +lock_kernel (); restart:for (head = inuse_list.next; head != &inuse_list; head = head->next) { dquot = list_entry(head, struct dquot, dq_inuse);
@@ -405,6 +388,7 @@ goto restart; } dqstats.syncs++; +unlock_kernel ();return 0 ; }
@@ -428,7 +412,9 @@int shrink_dqcache_memory (int priority,unsigned int gfp_mask) { +lock_kernel ();prune_dqcache (nr_free_dquots / (priority +1 )); +unlock_kernel ();kmem_cache_shrink (dquot_cachep);return 0 ; }
@@ -470,7 +456,7 @@wake_up (&dquot->dq_wait_free); } -struct dquot *get_empty_dquot (void ) +static struct dquot *get_empty_dquot (void ) {struct dquot *dquot;
@@ -633,9 +619,11 @@/* Free list of dquots - called from inode.c */ void put_dquot_list (struct list_head *tofree_head) { -struct list_head *act_head = tofree_head->next; +struct list_head *act_head;struct dquot *dquot; +lock_kernel (); + act_head = tofree_head->next;/* So now we have dquots on the list... Just free them */ while (act_head != tofree_head) { dquot = list_entry(act_head, struct dquot, dq_free);
@@ -644,6 +632,7 @@INIT_LIST_HEAD (&dquot->dq_free);dqput (dquot); } +unlock_kernel (); }static inline void dquot_incr_inodes (struct dquot *dquot,unsigned long number)
@@ -1289,6 +1278,7 @@short cnt;struct quota_mount_options *dqopt =sb_dqopt (sb); +lock_kernel ();if (!sb) goto out;
@@ -1313,6 +1303,7 @@ }up (&dqopt->dqoff_sem); out: +unlock_kernel ();return 0 ; }
fs/inode.c +3 -2
@@ -1210,9 +1210,9 @@if (!sb->dq_op)return ;/* nothing to do */ -/* We have to be protected against other CPUs */ -spin_lock (&inode_lock); +lock_kernel ();/* This lock is for quota code */ +spin_lock (&inode_lock);/* This lock is for inodes code */ list_for_each (act_head, &inode_in_use) { inode = list_entry(act_head, struct inode, i_list);
@@ -1235,6 +1235,7 @@remove_inode_dquot_ref (inode, type, &tofree_head); }spin_unlock (&inode_lock); +unlock_kernel ();put_dquot_list (&tofree_head); }