Skip to contentSkip to conversation

ufs: change b_blocknr

RFC PATCH In review Evgeniy Dushistov 2 participants 3 messages May 14, 2006 VFS

lore
Share & tools
lore
#0 lore raw

RFC PATCH 3/3 ufs: change b_blocknr

Because of ufs's layout, code which works with UFS should time to time change such map "online":
physical location<-->logical inode block

Current implementation of this cause kernel "hang up" and damage of data.

This patch should solve this problems. It passes some tests, but I'm not sure that it completely correct.
The most tricky part is ufs_change_blocknr function. May be some one can comment this patch?

---

fs/ufs/balloc.c +87 -24
diff -upr -X linux-2.6.17-rc4/Documentation/dontdiff linux-2.6.17-rc4-vanilla/fs/ufs/balloc.c linux-2.6.17-rc4/fs/ufs/balloc.c
@@ -39,7 +39,8 @@ static void ufs_clusteracct(struct super
 /*
  * Free 'count' fragments from fragment number 'fragment'
  */
-void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count)
+{
 	struct super_block * sb;
 	struct ufs_sb_private_info * uspi;
 	struct ufs_super_block_first * usb1;
@@ -134,7 +135,8 @@ failed:
 /*
  * Free 'count' fragments from fragment number 'fragment' (free whole blocks)
  */
-void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count)
+{
 	struct super_block * sb;
 	struct ufs_sb_private_info * uspi;
 	struct ufs_super_block_first * usb1;
@@ -222,15 +224,92 @@ failed:
 	return;
 }
 
+/*
+ * Modify inode page cache in such way:
+ * have - blocks with b_blocknr equal to oldb...oldb+count-1
+ * get - blocks with b_blocknr equal to newb...newb+count-1
+ * also we suppose that oldb...oldb+count-1 blocks 
+ * situated at the end of file
+ */
+static void ufs_change_blocknr(struct inode *inode, unsigned int count, 
+			       unsigned int oldb, unsigned int newb, 
+			       struct page *locked_page)
+{
+	unsigned int blk_per_page = 1UL << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+	sector_t baseblk=((inode->i_size-1)>>inode->i_blkbits)+1-count;
+	struct address_space *mapping = inode->i_mapping;
+	pgoff_t cur_index=locked_page->index;
+	unsigned int i, j;
+	struct page *page;
+	struct buffer_head *head, *bh;
+
+	UFSD(("ENTER, ino %lu, count %u, oldb %u, newb %u\n", inode->i_ino, count, oldb, newb));
+
+	for (i=0; i<count; i+=blk_per_page) {
+		pgoff_t index = (baseblk+i) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
+
+		if (likely(cur_index!=index))
+			page = find_lock_page(mapping, index);
+		else
+			page = locked_page;
+
+		if (!page) {
+			page = read_cache_page(mapping, index,
+					       (filler_t*)mapping->a_ops->readpage, NULL);
+			if (IS_ERR(page)) {
+				printk(KERN_ERR "ufs_change_blocknr: read_cache_page error: "
+				       "ino %lu, index: %lu\n", inode->i_ino, index);
+				continue;
+			}
+
+			wait_on_page_locked(page);
+			
+			if (!PageUptodate(page) || PageError(page)) {
+				page_cache_release(page);
+				printk(KERN_ERR "ufs_change_blocknr: can not read page: "
+				       "ino %lu, index: %lu\n", inode->i_ino, index);
+				continue;
+			}
+		  
+			lock_page(page);
+		}
+
+		if (!page_has_buffers(page))
+			goto out;
+
+		j=i;
+		head = page_buffers(page);
+		bh = head;
+		do {
+			if (likely(bh->b_blocknr==j+oldb && j<count)) {
+				get_bh(bh);
+				lock_buffer(bh);
+				bh->b_blocknr = newb+j++;
+				mark_buffer_dirty(bh);
+				unlock_buffer(bh);
+				put_bh(bh);
+			}
+ 
+			bh = bh->b_this_page;
+		} while (bh != head);
+ 
+		__set_page_dirty_buffers(page);
+	out:
+		if (likely(cur_index!=index)) {
+			unlock_page(page);
+			page_cache_release(page);
+		}
+ 	}
+	UFSD(("EXIT\n"));
+}
 
-unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
-	unsigned goal, unsigned count, int * err )
+unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
+			   unsigned goal, unsigned count, int * err, struct page *locked_page)
 {
 	struct super_block * sb;
 	struct ufs_sb_private_info * uspi;
 	struct ufs_super_block_first * usb1;
-	struct buffer_head * bh;
-	unsigned cgno, oldcount, newcount, tmp, request, i, result;
+	unsigned cgno, oldcount, newcount, tmp, request, result;
 	
 	UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count))
 	
@@ -343,24 +422,8 @@ unsigned ufs_new_fragments (struct inode
 	}
 	result = ufs_alloc_fragments (inode, cgno, goal, request, err);
 	if (result) {
-		for (i = 0; i < oldcount; i++) {
-			bh = sb_bread(sb, tmp + i);
-			if(bh)
-			{
-				clear_buffer_dirty(bh);
-				bh->b_blocknr = result + i;
-				mark_buffer_dirty (bh);
-				if (IS_SYNC(inode))
-					sync_dirty_buffer(bh);
-				brelse (bh);
-			}
-			else
-			{
-				printk(KERN_ERR "ufs_new_fragments: bread fail\n");
-				unlock_super(sb);
-				return 0;
-			}
-		}
+		ufs_change_blocknr(inode, oldcount, tmp, result, locked_page);
+
 		*p = cpu_to_fs32(sb, result);
 		*err = 0;
 		inode->i_blocks += count << uspi->s_nspfshift;
fs/ufs/inode.c +25 -19

94 lines not on this page · raw message

include/linux/ufs_fs.h +2 -1
diff -upr -X linux-2.6.17-rc4/Documentation/dontdiff linux-2.6.17-rc4-vanilla/include/linux/ufs_fs.h linux-2.6.17-rc4/include/linux/ufs_fs.h
@@ -876,7 +876,8 @@ struct ufs_super_block_third {
 /* balloc.c */
 extern void ufs_free_fragments (struct inode *, unsigned, unsigned);
 extern void ufs_free_blocks (struct inode *, unsigned, unsigned);
-extern unsigned ufs_new_fragments (struct inode *, __fs32 *, unsigned, unsigned, unsigned, int *);
+extern unsigned ufs_new_fragments(struct inode *, __fs32 *, unsigned, unsigned, 
+				  unsigned, int *, struct page *);
 
 /* cylinder.c */
 extern struct ufs_cg_private_info * ufs_load_cylinder (struct super_block *, unsigned);
Signature · 1 line
/Evgeniy
#1 lore raw
Quoted 4 lines · Evgeniy Dushistov

Because of ufs's layout, code which works with UFS should time to time change such map "online":
physical location<-->logical inode block

It does? You mean that certain parts of a file will get moved from one set of disk blocks to another?

I never knew that. It'd be hard to do that while avoiding races.

Quoted 8 lines

Current implementation of this cause kernel "hang up" and damage of data.

This patch should solve this problems. It passes some tests, but I'm not sure that it completely correct.
The most tricky part is ufs_change_blocknr function. May be some one can comment this patch?

I don't know of anyone who knows the UFS code, sorry. Apart from you ;)

Quoted 7 lines

+/*
+ * Modify inode page cache in such way:
+ * have - blocks with b_blocknr equal to oldb...oldb+count-1
+ * get - blocks with b_blocknr equal to newb...newb+count-1
+ * also we suppose that oldb...oldb+count-1 blocks
+ * situated at the end of file
+ */

It would be good if this comment could describe the operation of `locked_page'. What it does, how we use it.

fs/ufs/balloc.c failed: · line 244

Quoted 11 lines
fs/ufs/balloc.c +11 -0
+static void ufs_change_blocknr(struct inode *inode, unsigned int count, 
+			       unsigned int oldb, unsigned int newb, 
+			       struct page *locked_page)
+{
+	unsigned int blk_per_page = 1UL << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+	sector_t baseblk=((inode->i_size-1)>>inode->i_blkbits)+1-count;
+	struct address_space *mapping = inode->i_mapping;
+	pgoff_t cur_index=locked_page->index;
+	unsigned int i, j;
+	struct page *page;
+	struct buffer_head *head, *bh;

Please note that we put spaces around "+", "-" and "=".

fs/ufs/balloc.c failed: · line 248

Quoted 3 lines
fs/ufs/balloc.c +3 -0
+	UFSD(("ENTER, ino %lu, count %u, oldb %u, newb %u\n", inode->i_ino, count, oldb, newb));
+
+	for (i=0; i<count; i+=blk_per_page) {

and around "<" and "+=".

Quoted 7 lines
fs/ufs/balloc.c +7 -0
+		pgoff_t index = (baseblk+i) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
+
+		if (likely(cur_index!=index))
+			page = find_lock_page(mapping, index);
+		else
+			page = locked_page;
+

fs/ufs/balloc.c failed: · line 265

Quoted 10 lines
fs/ufs/balloc.c +10 -0
+		if (!page) {
+			page = read_cache_page(mapping, index,
+					       (filler_t*)mapping->a_ops->readpage, NULL);
+			if (IS_ERR(page)) {
+				printk(KERN_ERR "ufs_change_blocknr: read_cache_page error: "
+				       "ino %lu, index: %lu\n", inode->i_ino, index);
+				continue;
+			}
+
+			wait_on_page_locked(page);

You may as well do lock_page() here, and remove the later lock_page().

fs/ufs/balloc.c failed: · line 271

Quoted 5 lines
fs/ufs/balloc.c +5 -0
+			if (!PageUptodate(page) || PageError(page)) {
+				page_cache_release(page);
+				printk(KERN_ERR "ufs_change_blocknr: can not read page: "
+				       "ino %lu, index: %lu\n", inode->i_ino, index);
+				continue;

And here, do

	if (page != locked_page)
		unlock_page(page);

because right now, this code can result in locked_page being unlocked, which I think is wrong, yes?

fs/ufs/balloc.c failed: · line 278

Quoted 7 lines
fs/ufs/balloc.c +7 -0
+			}
+		  
+			lock_page(page);
+		}
+
+		if (!page_has_buffers(page))
+			goto out;

Yes, you need that test - there are rare conditions under which the buffers might have been stripped while the page was unlocked.

fs/ufs/balloc.c failed: · line 285

Quoted 6 lines
fs/ufs/balloc.c +6 -0
+		j=i;
+		head = page_buffers(page);
+		bh = head;
+		do {
+			if (likely(bh->b_blocknr==j+oldb && j<count)) {
+				get_bh(bh);

The get_bh() isn't needed - the page lock will protect the buffers.

fs/ufs/balloc.c failed: · line 290

Quoted 5 lines
fs/ufs/balloc.c +5 -0
+				lock_buffer(bh);
+				bh->b_blocknr = newb+j++;
+				mark_buffer_dirty(bh);
+				unlock_buffer(bh);
+				put_bh(bh);

We're about to take a new block from the device and attach it to a pagecache page and to then put it under I/O.

But for some filesystems (I don't know if this is true for UFS), it can be the case that there's still a buffer dirty against that block from a different address_space: the blockdev's address_space (the cache for /dev/hda1, used for filesystem metadata). In other words: even though that disk block is presently unallocated as far as the filesystem is concerned, there can be a pending write against it due to that dirty buffer.

So we need to shoot down that dirty blockdev buffer before marking this other buffer (which uses the same block) as dirty. Otherwise the old blockdev's buffer can get written to disk after this one, corrupting data.

We do that with unmap_underlying_metadata().

fs/ufs/balloc.c failed: · line 296

Quoted 6 lines
fs/ufs/balloc.c +6 -0
+			}
+ 
+			bh = bh->b_this_page;
+		} while (bh != head);
+ 
+		__set_page_dirty_buffers(page);

I suppose so. It might be cleaner to use set_page_dirty() here, so the reader doesn't have to go off and check that __set_page_dirty_buffers() is a correct optimisation for that.

Quoted 48 lines

diff -upr -X linux-2.6.17-rc4/Documentation/dontdiff linux-2.6.17-rc4-vanilla/fs/ufs/inode.c linux-2.6.17-rc4/fs/ufs/inode.c

fs/ufs/inode.c +11 -7
@@ -173,9 +173,10 @@ static inline void ufs_clear_block(struc
 }
 
 
-static struct buffer_head * ufs_inode_getfrag (struct inode *inode,
-	unsigned int fragment, unsigned int new_fragment,
-	unsigned int required, int *err, int metadata, long *phys, int *new)
+static struct buffer_head *ufs_inode_getfrag(struct inode *inode,
+					     unsigned int fragment, unsigned int new_fragment,
+					     unsigned int required, int *err, int metadata, 
+					     long *phys, int *new, struct page *locked_page)
 {
 	struct ufs_inode_info *ufsi = UFS_I(inode);
 	struct super_block * sb;
@@ -233,7 +234,8 @@ repeat:
 		if (lastblockoff) {
 			p2 = ufsi->i_u1.i_data + lastblock;
 			tmp = ufs_new_fragments (inode, p2, lastfrag, 
-				fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff, err);
+						 fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff, 
+						 err, locked_page);
 			if (!tmp) {
 				if (lastfrag != ufsi->i_lastfrag)
 					goto repeat;
@@ -245,14 +247,16 @@ repeat:
 		}
 		goal = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock]) + uspi->s_fpb;
 		tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
-			goal, required + blockoff, err);
+					 goal, required + blockoff, 
+					 err, locked_page);
 	}
 	/*
 	 * We will extend last allocated block
 	 */
 	else if (lastblock == block) {
-		tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
-			fs32_to_cpu(sb, *p), required +  (blockoff - lastblockoff), err);
+		tmp = ufs_new_fragments(inode, p, fragment - (blockoff - lastblockoff),
+					fs32_to_cpu(sb, *p), required +  (blockoff - lastblockoff), 
+					err, locked_page);
 	}
 	/*
 	 * We will allocate new block before last allocated block

fs/ufs/inode.c repeat: · line 269

Quoted 8 lines
fs/ufs/inode.c +2 -2
@@ -260,8 +264,8 @@ repeat:
 	else /* (lastblock > block) */ {
 		if (lastblock && (tmp = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock-1])))
 			goal = tmp + uspi->s_fpb;
-		tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
-			goal, uspi->s_fpb, err);
+		tmp = ufs_new_fragments(inode, p, fragment - blockoff, 
+					goal, uspi->s_fpb, err, locked_page);
 	}

yeah, I don't know UFS and I don't have a clue what all that's doing, sorry.

#2 lore raw
Quoted 9 lines · Andrew Morton
Quoted 4 lines · Evgeniy Dushistov

Because of ufs's layout, code which works with UFS should time to time change such map "online":
physical location<-->logical inode block

It does? You mean that certain parts of a file will get moved from one set of disk blocks to another?

In short file: consist of several blocks and fragments. sizeof(block)=8*sizeof(fragment),
fragments used to prevent unwanted waste of space.

When file is growing and we occupy 8 fragments in tail of it, we should allocate whole block and move all 8 fragments to it.

In 2.2 I suppose such code works fine:
bh = sb_bread
bh->b_blocknr=newvalue
mark_buffer_dirty

I doubt that it is normal for 2.4,
and this was completely wrong for 2.6.

Signature · 1 line
/Evgeniy