Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1c0b8a7a authored by Mikulas Patocka's avatar Mikulas Patocka Committed by Linus Torvalds
Browse files

hpfs: optimize quad buffer loading 



HPFS needs to load 4 consecutive 512-byte sectors when accessing the
directory nodes or bitmaps.  We can't switch to 2048-byte block size
because files are allocated in the units of 512-byte sectors.

Previously, the driver would allocate a 2048-byte area using kmalloc,
copy the data from four buffers to this area and eventually copy them
back if they were modified.

In the current implementation of the buffer cache, buffers are allocated
in the pagecache.  That means that 4 consecutive 512-byte buffers are
stored in consecutive areas in the kernel address space.  So, we don't
need to allocate extra memory and copy the content of the buffers there.

This patch optimizes the code to avoid copying the buffers.  It checks
if the four buffers are stored in contiguous memory - if they are not,
it falls back to allocating a 2048-byte area and copying data there.

Signed-off-by: default avatarMikulas Patocka <mikulas@artax.karlin.mff.cuni.cz>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 2cbe5c76

fs/hpfs/buffer.c

+50 −46
Original line number Original line Diff line number Diff line
@@ -86,7 +86,6 @@ void *hpfs_get_sector(struct super_block *s, unsigned secno, struct buffer_head 
void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffer_head *qbh,

void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffer_head *qbh,

		   int ahead)

		   int ahead)

{

{

	struct buffer_head *bh;

	char *data;

	char *data;





	hpfs_lock_assert(s);

	hpfs_lock_assert(s);
@@ -100,34 +99,32 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe 




	hpfs_prefetch_sectors(s, secno, 4 + ahead);

	hpfs_prefetch_sectors(s, secno, 4 + ahead);





	if (!(qbh->bh[0] = sb_bread(s, secno + 0))) goto bail0;

	if (!(qbh->bh[1] = sb_bread(s, secno + 1))) goto bail1;

	if (!(qbh->bh[2] = sb_bread(s, secno + 2))) goto bail2;

	if (!(qbh->bh[3] = sb_bread(s, secno + 3))) goto bail3;



	if (likely(qbh->bh[1]->b_data == qbh->bh[0]->b_data + 1 * 512) &&

	    likely(qbh->bh[2]->b_data == qbh->bh[0]->b_data + 2 * 512) &&

	    likely(qbh->bh[3]->b_data == qbh->bh[0]->b_data + 3 * 512)) {

		return qbh->data = qbh->bh[0]->b_data;

	}



	qbh->data = data = kmalloc(2048, GFP_NOFS);

	qbh->data = data = kmalloc(2048, GFP_NOFS);

	if (!data) {

	if (!data) {

		printk("HPFS: hpfs_map_4sectors: out of memory\n");

		printk("HPFS: hpfs_map_4sectors: out of memory\n");

		goto bail;

		goto bail4;

	}

	}





	qbh->bh[0] = bh = sb_bread(s, secno);

	memcpy(data + 0 * 512, qbh->bh[0]->b_data, 512);

	if (!bh)

	memcpy(data + 1 * 512, qbh->bh[1]->b_data, 512);

		goto bail0;

	memcpy(data + 2 * 512, qbh->bh[2]->b_data, 512);

	memcpy(data, bh->b_data, 512);

	memcpy(data + 3 * 512, qbh->bh[3]->b_data, 512);



	qbh->bh[1] = bh = sb_bread(s, secno + 1);

	if (!bh)

		goto bail1;

	memcpy(data + 512, bh->b_data, 512);



	qbh->bh[2] = bh = sb_bread(s, secno + 2);

	if (!bh)

		goto bail2;

	memcpy(data + 2 * 512, bh->b_data, 512);



	qbh->bh[3] = bh = sb_bread(s, secno + 3);

	if (!bh)

		goto bail3;

	memcpy(data + 3 * 512, bh->b_data, 512);





	return data;

	return data;





 bail4:

	brelse(qbh->bh[3]);

 bail3:

 bail3:

	brelse(qbh->bh[2]);

	brelse(qbh->bh[2]);

 bail2:

 bail2:
@@ -135,9 +132,6 @@ void *hpfs_map_4sectors(struct super_block *s, unsigned secno, struct quad_buffe 
 bail1:

 bail1:

	brelse(qbh->bh[0]);

	brelse(qbh->bh[0]);

 bail0:

 bail0:

	kfree(data);

	printk("HPFS: hpfs_map_4sectors: read error\n");

 bail:

	return NULL;

	return NULL;

}

}
@@ -155,24 +149,31 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno, 
		return NULL;

		return NULL;

	}

	}





	/*return hpfs_map_4sectors(s, secno, qbh, 0);*/

	if (!hpfs_get_sector(s, secno + 0, &qbh->bh[0])) goto bail0;

	if (!hpfs_get_sector(s, secno + 1, &qbh->bh[1])) goto bail1;

	if (!hpfs_get_sector(s, secno + 2, &qbh->bh[2])) goto bail2;

	if (!hpfs_get_sector(s, secno + 3, &qbh->bh[3])) goto bail3;



	if (likely(qbh->bh[1]->b_data == qbh->bh[0]->b_data + 1 * 512) &&

	    likely(qbh->bh[2]->b_data == qbh->bh[0]->b_data + 2 * 512) &&

	    likely(qbh->bh[3]->b_data == qbh->bh[0]->b_data + 3 * 512)) {

		return qbh->data = qbh->bh[0]->b_data;

	}



	if (!(qbh->data = kmalloc(2048, GFP_NOFS))) {

	if (!(qbh->data = kmalloc(2048, GFP_NOFS))) {

		printk("HPFS: hpfs_get_4sectors: out of memory\n");

		printk("HPFS: hpfs_get_4sectors: out of memory\n");

		return NULL;

		goto bail4;

	}

	}

	if (!(hpfs_get_sector(s, secno, &qbh->bh[0]))) goto bail0;

	if (!(hpfs_get_sector(s, secno + 1, &qbh->bh[1]))) goto bail1;

	if (!(hpfs_get_sector(s, secno + 2, &qbh->bh[2]))) goto bail2;

	if (!(hpfs_get_sector(s, secno + 3, &qbh->bh[3]))) goto bail3;

	memcpy(qbh->data, qbh->bh[0]->b_data, 512);

	memcpy(qbh->data + 512, qbh->bh[1]->b_data, 512);

	memcpy(qbh->data + 2*512, qbh->bh[2]->b_data, 512);

	memcpy(qbh->data + 3*512, qbh->bh[3]->b_data, 512);

	return qbh->data;

	return qbh->data;





	bail3:	brelse(qbh->bh[2]);

bail4:

	bail2:	brelse(qbh->bh[1]);

	brelse(qbh->bh[3]);

	bail1:	brelse(qbh->bh[0]);

bail3:

	brelse(qbh->bh[2]);

bail2:

	brelse(qbh->bh[1]);

bail1:

	brelse(qbh->bh[0]);

bail0:

bail0:

	return NULL;

	return NULL;

}

}
@@ -180,19 +181,22 @@ void *hpfs_get_4sectors(struct super_block *s, unsigned secno, 




void hpfs_brelse4(struct quad_buffer_head *qbh)

void hpfs_brelse4(struct quad_buffer_head *qbh)

{

{

	brelse(qbh->bh[3]);

	if (unlikely(qbh->data != qbh->bh[0]->b_data))

	brelse(qbh->bh[2]);

	brelse(qbh->bh[1]);

	brelse(qbh->bh[0]);

		kfree(qbh->data);

		kfree(qbh->data);

	brelse(qbh->bh[0]);

	brelse(qbh->bh[1]);

	brelse(qbh->bh[2]);

	brelse(qbh->bh[3]);

}	

}	





void hpfs_mark_4buffers_dirty(struct quad_buffer_head *qbh)

void hpfs_mark_4buffers_dirty(struct quad_buffer_head *qbh)

{

{

	memcpy(qbh->bh[0]->b_data, qbh->data, 512);

	if (unlikely(qbh->data != qbh->bh[0]->b_data)) {

	memcpy(qbh->bh[1]->b_data, qbh->data + 512, 512);

		memcpy(qbh->bh[0]->b_data, qbh->data + 0 * 512, 512);

		memcpy(qbh->bh[1]->b_data, qbh->data + 1 * 512, 512);

		memcpy(qbh->bh[2]->b_data, qbh->data + 2 * 512, 512);

		memcpy(qbh->bh[2]->b_data, qbh->data + 2 * 512, 512);

		memcpy(qbh->bh[3]->b_data, qbh->data + 3 * 512, 512);

		memcpy(qbh->bh[3]->b_data, qbh->data + 3 * 512, 512);

	}

	mark_buffer_dirty(qbh->bh[0]);

	mark_buffer_dirty(qbh->bh[0]);

	mark_buffer_dirty(qbh->bh[1]);

	mark_buffer_dirty(qbh->bh[1]);

	mark_buffer_dirty(qbh->bh[2]);

	mark_buffer_dirty(qbh->bh[2]);