patch-2.3.13 linux/fs/fat/buffer.c

• Lines: 343
• Date: Mon Aug 9 11:43:49 1999
• Orig file: v2.3.12/linux/fs/fat/buffer.c
• Orig date: Wed Jun 24 14:30:09 1998

diff -u --recursive --new-file v2.3.12/linux/fs/fat/buffer.c linux/fs/fat/buffer.c
@@ -17,195 +17,189 @@
 #  define PRINTK(x)
 #endif
 
-struct buffer_head *fat_bread (
+struct buffer_head *fat_bread(struct super_block *sb, int block)
+{
+	return MSDOS_SB(sb)->cvf_format->cvf_bread(sb,block);
+}
+struct buffer_head *fat_getblk(struct super_block *sb, int block)
+{
+	return MSDOS_SB(sb)->cvf_format->cvf_getblk(sb,block);
+}
+void fat_brelse (struct super_block *sb, struct buffer_head *bh)
+{
+	if (bh) 
+		MSDOS_SB(sb)->cvf_format->cvf_brelse(sb,bh);
+}
+void fat_mark_buffer_dirty (
 	struct super_block *sb,
-	int block)
+	struct buffer_head *bh,
+	int dirty)
 {
-	struct buffer_head *ret = NULL;
-
-	PRINTK(("fat_bread: block=0x%x\n", block));
-	/*
-	 * Note that the blocksize is 512, 1024 or 2048, but the first read
-	 * is always of size 1024 (or 2048). Doing readahead may be
-	 * counterproductive or just plain wrong.
-	 */
+	MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty(sb,bh,dirty);
+}
+void fat_set_uptodate (
+	struct super_block *sb,
+	struct buffer_head *bh,
+	int val)
+{
+	MSDOS_SB(sb)->cvf_format->cvf_set_uptodate(sb,bh,val);
+}
+int fat_is_uptodate(struct super_block *sb, struct buffer_head *bh)
+{
+	return MSDOS_SB(sb)->cvf_format->cvf_is_uptodate(sb,bh);
+}
+void fat_ll_rw_block (
+	struct super_block *sb,
+	int opr,
+	int nbreq,
+	struct buffer_head *bh[32])
+{
+	MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block(sb,opr,nbreq,bh);
+}
 
-	if(MSDOS_SB(sb)->cvf_format &&
-	   MSDOS_SB(sb)->cvf_format->cvf_bread)
-		return MSDOS_SB(sb)->cvf_format->cvf_bread(sb,block);
+struct buffer_head *default_fat_bread(struct super_block *sb, int block)
+{
+	return bread (sb->s_dev,block,512);
+}
+struct buffer_head *default_fat_getblk(struct super_block *sb, int block)
+{
+	return getblk (sb->s_dev,block,512);
+}
+void default_fat_brelse(struct super_block *sb, struct buffer_head *bh)
+{
+	brelse (bh);
+}
+void default_fat_mark_buffer_dirty (
+	struct super_block *sb,
+	struct buffer_head *bh,
+	int dirty)
+{
+	mark_buffer_dirty (bh,dirty);
+}
+void default_fat_set_uptodate (
+	struct super_block *sb,
+	struct buffer_head *bh,
+	int val)
+{
+	mark_buffer_uptodate(bh, val);
+}
+int default_fat_is_uptodate (struct super_block *sb, struct buffer_head *bh)
+{
+	return buffer_uptodate(bh);
+}
+void default_fat_ll_rw_block (
+	struct super_block *sb,
+	int opr,
+	int nbreq,
+	struct buffer_head *bh[32])
+{
+	ll_rw_block(opr,nbreq,bh);
+}
 
-	if (sb->s_blocksize == 512) {
-		ret = bread (sb->s_dev,block,512);
+struct buffer_head *bigblock_fat_bread (
+	struct super_block *sb,
+	int block)
+{
+	struct buffer_head *ret = NULL;
+	struct buffer_head *real;
+	if (sb->s_blocksize == 1024){
+		real = bread (sb->s_dev,block>>1,1024);
 	} else {
-		struct buffer_head *real;
-		if (sb->s_blocksize == 1024){
-			real = bread (sb->s_dev,block>>1,1024);
-		} else {
-			real = bread (sb->s_dev,block>>2,2048);
-		}
+		real = bread (sb->s_dev,block>>2,2048);
+	}
 
-		if (real != NULL){
-			ret = (struct buffer_head *)
-				kmalloc (sizeof(struct buffer_head), GFP_KERNEL);
-			if (ret != NULL) {
-				/* #Specification: msdos / strategy / special device / dummy blocks
-				 * Many special device (Scsi optical disk for one) use
-				 * larger hardware sector size. This allows for higher
-				 * capacity.
-
-				 * Most of the time, the MS-DOS filesystem that sits
-				 * on this device is totally unaligned. It use logically
-				 * 512 bytes sector size, with logical sector starting
-				 * in the middle of a hardware block. The bad news is
-				 * that a hardware sector may hold data own by two
-				 * different files. This means that the hardware sector
-				 * must be read, patch and written almost all the time.
-
-				 * Needless to say that it kills write performance
-				 * on all OS.
-
-				 * Internally the linux msdos fs is using 512 bytes
-				 * logical sector. When accessing such a device, we
-				 * allocate dummy buffer cache blocks, that we stuff
-				 * with the information of a real one (1k large).
-
-				 * This strategy is used to hide this difference to
-				 * the core of the msdos fs. The slowdown is not
-				 * hidden though!
-				 */
-				/*
-				 * The memset is there only to catch errors. The msdos
-				 * fs is only using b_data
-				 */
-				memset (ret,0,sizeof(*ret));
-				ret->b_data = real->b_data;
-				if (sb->s_blocksize == 2048) {
-					if (block & 3) ret->b_data += (block & 3) << 9;
-				}else{
-					if (block & 1) ret->b_data += 512;
-				}
-				ret->b_next = real;
+	if (real != NULL) {
+		ret = (struct buffer_head *)
+			kmalloc (sizeof(struct buffer_head), GFP_KERNEL);
+		if (ret != NULL) {
+			/* #Specification: msdos / strategy / special device / dummy blocks
+			 * Many special device (Scsi optical disk for one) use
+			 * larger hardware sector size. This allows for higher
+			 * capacity.
+
+			 * Most of the time, the MS-DOS filesystem that sits
+			 * on this device is totally unaligned. It use logically
+			 * 512 bytes sector size, with logical sector starting
+			 * in the middle of a hardware block. The bad news is
+			 * that a hardware sector may hold data own by two
+			 * different files. This means that the hardware sector
+			 * must be read, patch and written almost all the time.
+
+			 * Needless to say that it kills write performance
+			 * on all OS.
+
+			 * Internally the linux msdos fs is using 512 bytes
+			 * logical sector. When accessing such a device, we
+			 * allocate dummy buffer cache blocks, that we stuff
+			 * with the information of a real one (1k large).
+
+			 * This strategy is used to hide this difference to
+			 * the core of the msdos fs. The slowdown is not
+			 * hidden though!
+			 */
+			/*
+			 * The memset is there only to catch errors. The msdos
+			 * fs is only using b_data
+			 */
+			memset (ret,0,sizeof(*ret));
+			ret->b_data = real->b_data;
+			if (sb->s_blocksize == 2048) {
+				if (block & 3) ret->b_data += (block & 3) << 9;
 			}else{
-				brelse (real);
+				if (block & 1) ret->b_data += 512;
 			}
+			ret->b_next = real;
+		}else{
+			brelse (real);
 		}
 	}
 	return ret;
 }
 
-struct buffer_head *fat_getblk(struct super_block *sb, int block)
-{
-	struct buffer_head *ret = NULL;
-	PRINTK(("fat_getblk: block=0x%x\n", block));
-
-	if (MSDOS_SB(sb)->cvf_format &&
-	    MSDOS_SB(sb)->cvf_format->cvf_getblk)
-		return MSDOS_SB(sb)->cvf_format->cvf_getblk(sb,block);
-
-	if (sb->s_blocksize == 512){
-		ret = getblk (sb->s_dev,block,512);
-	} else {
-		/*
-		 * #Specification: msdos / special device / writing
-		 * A write is always preceded by a read of the complete block
-		 * (large hardware sector size). This defeat write performance.
-		 * There is a possibility to optimize this when writing large
-		 * chunk by making sure we are filling large block. Volunteer ?
-		 */
-		ret = fat_bread (sb,block);
-	}
-	return ret;
-}
-
-void fat_brelse (
+void bigblock_fat_brelse (
 	struct super_block *sb,
 	struct buffer_head *bh)
 {
-	if (bh != NULL) {
-		if (MSDOS_SB(sb)->cvf_format &&
-		    MSDOS_SB(sb)->cvf_format->cvf_brelse)
-			return MSDOS_SB(sb)->cvf_format->cvf_brelse(sb,bh);
-
-		if (sb->s_blocksize == 512){
-			brelse (bh);
-		}else{
-			brelse (bh->b_next);
-			/* We can free the dummy because a new one is allocated at
-				each fat_getblk() and fat_bread().
-			*/
-			kfree (bh);
-		}
-	}
+	brelse (bh->b_next);
+	/*
+	 * We can free the dummy because a new one is allocated at
+	 * each fat_getblk() and fat_bread().
+	 */
+	kfree (bh);
 }
-	
-void fat_mark_buffer_dirty (
+
+void bigblock_fat_mark_buffer_dirty (
 	struct super_block *sb,
 	struct buffer_head *bh,
 	int dirty)
 {
-	if (MSDOS_SB(sb)->cvf_format &&
-	    MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty) {
-		MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty(sb,bh,dirty);
-		return;
-	}
- 
-	if (sb->s_blocksize != 512){
-		bh = bh->b_next;
-	}
-	mark_buffer_dirty (bh,dirty);
+	mark_buffer_dirty (bh->b_next,dirty);
 }
 
-void fat_set_uptodate (
+void bigblock_fat_set_uptodate (
 	struct super_block *sb,
 	struct buffer_head *bh,
 	int val)
 {
-	if (MSDOS_SB(sb)->cvf_format && 
-	    MSDOS_SB(sb)->cvf_format->cvf_set_uptodate) {
-		MSDOS_SB(sb)->cvf_format->cvf_set_uptodate(sb,bh,val);
-		return;
-	}
- 
-	if (sb->s_blocksize != 512){
-		bh = bh->b_next;
-	}
-	mark_buffer_uptodate(bh, val);
+	mark_buffer_uptodate(bh->b_next, val);
 }
-int fat_is_uptodate (
+
+int bigblock_fat_is_uptodate (
 	struct super_block *sb,
 	struct buffer_head *bh)
 {
-	if(MSDOS_SB(sb)->cvf_format &&
-	   MSDOS_SB(sb)->cvf_format->cvf_is_uptodate)
-		return MSDOS_SB(sb)->cvf_format->cvf_is_uptodate(sb,bh);
- 
-	if (sb->s_blocksize != 512){
-		bh = bh->b_next;
-	}
-	return buffer_uptodate(bh);
+	return buffer_uptodate(bh->b_next);
 }
 
-void fat_ll_rw_block (
+void bigblock_fat_ll_rw_block (
 	struct super_block *sb,
 	int opr,
 	int nbreq,
 	struct buffer_head *bh[32])
 {
-        if (MSDOS_SB(sb)->cvf_format &&
-	    MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block) {
-		MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block(sb,opr,nbreq,bh);
-		return;
-	}
- 
-	if (sb->s_blocksize == 512){
-		ll_rw_block(opr,nbreq,bh);
-	}else{
-		struct buffer_head *tmp[32];
-		int i;
-		for (i=0; i<nbreq; i++){
-			tmp[i] = bh[i]->b_next;
-		}
-		ll_rw_block(opr,nbreq,tmp);
-	}
+	struct buffer_head *tmp[32];
+	int i;
+	for (i=0; i<nbreq; i++)
+		tmp[i] = bh[i]->b_next;
+	ll_rw_block(opr,nbreq,tmp);
 }
-