Skip to contentSkip to conversation

ext4: Fix discard of inode prealloc space with delayed allocation.

PATCH Applied Aneesh Kumar K.V 3 participants 4 messages Feb 25, 2009 – Feb 26, 2009 ext4 file system

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 ext4: Fix discard of inode prealloc space with delayed allocation.

With delayed allocation we should not/cannot discard inode prealloc space during file close. We would still have dirty pages for which we haven't allocated blocks yet. With this fix after each get_blocks request we check whether we have zero reserved blocks and if yes and we don't have any writers on the file we discard inode prealloc space.

---
 fs/ext4/file.c  |    9 ++++++++-
 fs/ext4/inode.c |    6 ++++++
 2 files changed, 14 insertions(+), 1 deletions(-)
fs/ext4/file.c +8 -1
index f731cb5..4e468e2 100644
@@ -33,9 +33,16 @@
  */
 static int ext4_release_file(struct inode *inode, struct file *filp)
 {
+	int rsv_data_blocks;
+
+	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
+	rsv_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
+	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
+
 	/* if we are the last writer on the inode, drop the block reservation */
 	if ((filp->f_mode & FMODE_WRITE) &&
-			(atomic_read(&inode->i_writecount) == 1))
+			(atomic_read(&inode->i_writecount) == 1) &&
+		        !rsv_data_blocks)
 	{
 		down_write(&EXT4_I(inode)->i_data_sem);
 		ext4_discard_preallocations(inode);
fs/ext4/inode.c +6 -0
index 51cdd13..26dcec4 100644
@@ -1038,6 +1038,12 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
 	EXT4_I(inode)->i_reserved_data_blocks -= used;
 
 	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
+	/*
+	 * If have done all the pending block allocation and if the
+	 * we don't have any writer on the inode
+	 */
+	if (!total && (atomic_read(&inode->i_writecount) == 0))
+		ext4_discard_preallocations(inode);
 }
 
 /*
Signature · 1 line
tg: (694593e..) fix_prealloc_discard (depends on: master)
#1 lore raw
Quoted 18 lines · Aneesh Kumar K.V

With delayed allocation we should not/cannot discard inode prealloc space during file close. We would still have dirty pages for which we haven't allocated blocks yet. With this fix after each get_blocks request we check whether we have zero reserved blocks and if yes and we don't have any writers on the file we discard inode prealloc space.

---
 fs/ext4/file.c  |    9 ++++++++-
 fs/ext4/inode.c |    6 ++++++
 2 files changed, 14 insertions(+), 1 deletions(-)
fs/ext4/file.c +0 -0
index f731cb5..4e468e2 100644

fs/ext4/file.c line 41

Quoted 9 lines
fs/ext4/file.c +6 -0
@@ -33,9 +33,16 @@
  */
 static int ext4_release_file(struct inode *inode, struct file *filp)
 {
+	int rsv_data_blocks;
+
+	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
+	rsv_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
+	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
+

Seems we have race condition here because at this point someone may:
1)open file
2)then perform some write activity => (i_reserved_data_blocks != 0) 3)close file => (inode->i_writecount == 1)

fs/ext4/file.c line 47

Quoted 7 lines
fs/ext4/file.c +2 -1
 	/* if we are the last writer on the inode, drop the block reservation */
 	if ((filp->f_mode & FMODE_WRITE) &&
-			(atomic_read(&inode->i_writecount) == 1))
+			(atomic_read(&inode->i_writecount) == 1) &&
+		        !rsv_data_blocks)
 	{
 		down_write(&EXT4_I(inode)->i_data_sem);

After we have grabbed i_data_sem we are protected from get_block activity, and may safely recheck i_reserved_data_blocks again here.

fs/ext4/inode.c static void ext4_da_update_reserve_space(struct inode *inode, int used) · line 1044

Quoted 13 lines
fs/ext4/file.c +0 -0
 		ext4_discard_preallocations(inode);
fs/ext4/inode.c +4 -0
index 51cdd13..26dcec4 100644
@@ -1038,6 +1038,12 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
 	EXT4_I(inode)->i_reserved_data_blocks -= used;
 
 	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
+	/*
+	 * If have done all the pending block allocation and if the
+	 * we don't have any writer on the inode
+	 */

No problem here because we are hold i_data_sem.

Quoted 5 lines
fs/ext4/inode.c +2 -0
+	if (!total && (atomic_read(&inode->i_writecount) == 0))
+		ext4_discard_preallocations(inode);
 }
 
 /*
#2 lore raw
Quoted 25 lines · Dmitri Monakhov
Quoted 23 lines · Aneesh Kumar K.V

With delayed allocation we should not/cannot discard inode prealloc space during file close. We would still have dirty pages for which we haven't allocated blocks yet. With this fix after each get_blocks request we check whether we have zero reserved blocks and if yes and we don't have any writers on the file we discard inode prealloc space.

---
 fs/ext4/file.c  |    9 ++++++++-
 fs/ext4/inode.c |    6 ++++++
 2 files changed, 14 insertions(+), 1 deletions(-)
fs/ext4/file.c +2 -0
index f731cb5..4e468e2 100644
@@ -33,9 +33,16 @@
  */
 static int ext4_release_file(struct inode *inode, struct file *filp)
 {
+	int rsv_data_blocks;
+
Quoted 9 lines

fs/ext4/file.c line 41

Quoted 4 lines
fs/ext4/file.c +4 -0
+	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
+	rsv_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
+	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
+

Seems we have race condition here because at this point someone may:
1)open file
2)then perform some write activity => (i_reserved_data_blocks != 0) 3)close file => (inode->i_writecount == 1)

i_data_sem doesn't actually ensure i_reserved_data_blocks won't change. We update i_reserved_data_blocks during block reservation (ext4_da_write_begin). But yes what you mentioned is possible. But I am not sure we need to be worried about that. It is true that throwing away prealloc space is not good. But we still do block allocation based on goal blocks. So we may end up allocating blocks within the discarded prealloc space again.

What is bad is that if we don't discard the prealloc space even after all the needed block allocation. That would mean nothing can be allocated out of that prealloc space. With the current code We would be discarding the prealloc space only when we hit ENOSPC
. But then that would be bad.

-aneesh

maintainer Applied
#3 lore raw
In reply to Aneesh Kumar K.V
Quoted 6 lines · Aneesh Kumar K.V

With delayed allocation we should not/cannot discard inode prealloc space during file close. We would still have dirty pages for which we haven't allocated blocks yet. With this fix after each get_blocks request we check whether we have zero reserved blocks and if yes and we don't have any writers on the file we discard inode prealloc space.

Thanks, applied in the ext4 patch queue.

- Ted