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

Commit ea817398 authored by Badari Pulavarty's avatar Badari Pulavarty Committed by Linus Torvalds
Browse files

[PATCH] Manage jbd allocations from its own slabs 

JBD currently allocates commit and frozen buffers from slabs.  With
CONFIG_SLAB_DEBUG, its possible for an allocation to cross the page
boundary causing IO problems.

https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=200127



So, instead of allocating these from regular slabs - manage allocation from
its own slabs and disable slab debug for these slabs.

[akpm@osdl.org: cleanups]
Signed-off-by: default avatarBadari Pulavarty <pbadari@us.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 4c4d50f7

fs/jbd/commit.c

+3 −3
Original line number Original line Diff line number Diff line
@@ -261,7 +261,7 @@ void journal_commit_transaction(journal_t *journal) 
			struct buffer_head *bh = jh2bh(jh);

			struct buffer_head *bh = jh2bh(jh);





			jbd_lock_bh_state(bh);

			jbd_lock_bh_state(bh);

			kfree(jh->b_committed_data);

			jbd_slab_free(jh->b_committed_data, bh->b_size);

			jh->b_committed_data = NULL;

			jh->b_committed_data = NULL;

			jbd_unlock_bh_state(bh);

			jbd_unlock_bh_state(bh);

		}

		}
@@ -745,14 +745,14 @@ void journal_commit_transaction(journal_t *journal) 
		 * Otherwise, we can just throw away the frozen data now.

		 * Otherwise, we can just throw away the frozen data now.

		 */

		 */

		if (jh->b_committed_data) {

		if (jh->b_committed_data) {

			kfree(jh->b_committed_data);

			jbd_slab_free(jh->b_committed_data, bh->b_size);

			jh->b_committed_data = NULL;

			jh->b_committed_data = NULL;

			if (jh->b_frozen_data) {

			if (jh->b_frozen_data) {

				jh->b_committed_data = jh->b_frozen_data;

				jh->b_committed_data = jh->b_frozen_data;

				jh->b_frozen_data = NULL;

				jh->b_frozen_data = NULL;

			}

			}

		} else if (jh->b_frozen_data) {

		} else if (jh->b_frozen_data) {

			kfree(jh->b_frozen_data);

			jbd_slab_free(jh->b_frozen_data, bh->b_size);

			jh->b_frozen_data = NULL;

			jh->b_frozen_data = NULL;

		}

		}

fs/jbd/journal.c

+86 −6
Original line number Original line Diff line number Diff line
@@ -84,6 +84,7 @@ EXPORT_SYMBOL(journal_force_commit); 




static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);

static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);

static void __journal_abort_soft (journal_t *journal, int errno);

static void __journal_abort_soft (journal_t *journal, int errno);

static int journal_create_jbd_slab(size_t slab_size);





/*

/*

 * Helper function used to manage commit timeouts

 * Helper function used to manage commit timeouts
@@ -328,10 +329,10 @@ int journal_write_metadata_buffer(transaction_t *transaction, 
		char *tmp;

		char *tmp;





		jbd_unlock_bh_state(bh_in);

		jbd_unlock_bh_state(bh_in);

		tmp = jbd_rep_kmalloc(bh_in->b_size, GFP_NOFS);

		tmp = jbd_slab_alloc(bh_in->b_size, GFP_NOFS);

		jbd_lock_bh_state(bh_in);

		jbd_lock_bh_state(bh_in);

		if (jh_in->b_frozen_data) {

		if (jh_in->b_frozen_data) {

			kfree(tmp);

			jbd_slab_free(tmp, bh_in->b_size);

			goto repeat;

			goto repeat;

		}

		}
@@ -1069,17 +1070,17 @@ static int load_superblock(journal_t *journal) 
int journal_load(journal_t *journal)

int journal_load(journal_t *journal)

{

{

	int err;

	int err;

	journal_superblock_t *sb;





	err = load_superblock(journal);

	err = load_superblock(journal);

	if (err)

	if (err)

		return err;

		return err;





	sb = journal->j_superblock;

	/* If this is a V2 superblock, then we have to check the

	/* If this is a V2 superblock, then we have to check the

	 * features flags on it. */

	 * features flags on it. */





	if (journal->j_format_version >= 2) {

	if (journal->j_format_version >= 2) {

		journal_superblock_t *sb = journal->j_superblock;



		if ((sb->s_feature_ro_compat &

		if ((sb->s_feature_ro_compat &

		     ~cpu_to_be32(JFS_KNOWN_ROCOMPAT_FEATURES)) ||

		     ~cpu_to_be32(JFS_KNOWN_ROCOMPAT_FEATURES)) ||

		    (sb->s_feature_incompat &

		    (sb->s_feature_incompat &
@@ -1090,6 +1091,13 @@ int journal_load(journal_t *journal) 
		}

		}

	}

	}





	/*

	 * Create a slab for this blocksize

	 */

	err = journal_create_jbd_slab(cpu_to_be32(sb->s_blocksize));

	if (err)

		return err;



	/* Let the recovery code check whether it needs to recover any

	/* Let the recovery code check whether it needs to recover any

	 * data from the journal. */

	 * data from the journal. */

	if (journal_recover(journal))

	if (journal_recover(journal))
@@ -1611,6 +1619,77 @@ void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry) 
	return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0));

	return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0));

}

}





/*

 * jbd slab management: create 1k, 2k, 4k, 8k slabs as needed

 * and allocate frozen and commit buffers from these slabs.

 *

 * Reason for doing this is to avoid, SLAB_DEBUG - since it could

 * cause bh to cross page boundary.

 */



#define JBD_MAX_SLABS 5

#define JBD_SLAB_INDEX(size)  (size >> 11)



static kmem_cache_t *jbd_slab[JBD_MAX_SLABS];

static const char *jbd_slab_names[JBD_MAX_SLABS] = {

	"jbd_1k", "jbd_2k", "jbd_4k", NULL, "jbd_8k"

};



static void journal_destroy_jbd_slabs(void)

{

	int i;



	for (i = 0; i < JBD_MAX_SLABS; i++) {

		if (jbd_slab[i])

			kmem_cache_destroy(jbd_slab[i]);

		jbd_slab[i] = NULL;

	}

}



static int journal_create_jbd_slab(size_t slab_size)

{

	int i = JBD_SLAB_INDEX(slab_size);



	BUG_ON(i >= JBD_MAX_SLABS);



	/*

	 * Check if we already have a slab created for this size

	 */

	if (jbd_slab[i])

		return 0;



	/*

	 * Create a slab and force alignment to be same as slabsize -

	 * this will make sure that allocations won't cross the page

	 * boundary.

	 */

	jbd_slab[i] = kmem_cache_create(jbd_slab_names[i],

				slab_size, slab_size, 0, NULL, NULL);

	if (!jbd_slab[i]) {

		printk(KERN_EMERG "JBD: no memory for jbd_slab cache\n");

		return -ENOMEM;

	}

	return 0;

}



void * jbd_slab_alloc(size_t size, gfp_t flags)

{

	int idx;



	idx = JBD_SLAB_INDEX(size);

	BUG_ON(jbd_slab[idx] == NULL);

	return kmem_cache_alloc(jbd_slab[idx], flags | __GFP_NOFAIL);

}



void jbd_slab_free(void *ptr,  size_t size)

{

	int idx;



	idx = JBD_SLAB_INDEX(size);

	BUG_ON(jbd_slab[idx] == NULL);

	kmem_cache_free(jbd_slab[idx], ptr);

}



/*

/*

 * Journal_head storage management

 * Journal_head storage management

 */

 */
@@ -1799,13 +1878,13 @@ static void __journal_remove_journal_head(struct buffer_head *bh) 
				printk(KERN_WARNING "%s: freeing "

				printk(KERN_WARNING "%s: freeing "

						"b_frozen_data\n",

						"b_frozen_data\n",

						__FUNCTION__);

						__FUNCTION__);

				kfree(jh->b_frozen_data);

				jbd_slab_free(jh->b_frozen_data, bh->b_size);

			}

			}

			if (jh->b_committed_data) {

			if (jh->b_committed_data) {

				printk(KERN_WARNING "%s: freeing "

				printk(KERN_WARNING "%s: freeing "

						"b_committed_data\n",

						"b_committed_data\n",

						__FUNCTION__);

						__FUNCTION__);

				kfree(jh->b_committed_data);

				jbd_slab_free(jh->b_committed_data, bh->b_size);

			}

			}

			bh->b_private = NULL;

			bh->b_private = NULL;

			jh->b_bh = NULL;	/* debug, really */

			jh->b_bh = NULL;	/* debug, really */
@@ -1961,6 +2040,7 @@ static void journal_destroy_caches(void) 
	journal_destroy_revoke_caches();

	journal_destroy_revoke_caches();

	journal_destroy_journal_head_cache();

	journal_destroy_journal_head_cache();

	journal_destroy_handle_cache();

	journal_destroy_handle_cache();

	journal_destroy_jbd_slabs();

}

}





static int __init journal_init(void)

static int __init journal_init(void)

fs/jbd/transaction.c

+5 −4
Original line number Original line Diff line number Diff line
@@ -666,7 +666,8 @@ do_get_write_access(handle_t *handle, struct journal_head *jh, 
			if (!frozen_buffer) {

			if (!frozen_buffer) {

				JBUFFER_TRACE(jh, "allocate memory for buffer");

				JBUFFER_TRACE(jh, "allocate memory for buffer");

				jbd_unlock_bh_state(bh);

				jbd_unlock_bh_state(bh);

				frozen_buffer = jbd_kmalloc(jh2bh(jh)->b_size,

				frozen_buffer =

					jbd_slab_alloc(jh2bh(jh)->b_size,

							 GFP_NOFS);

							 GFP_NOFS);

				if (!frozen_buffer) {

				if (!frozen_buffer) {

					printk(KERN_EMERG

					printk(KERN_EMERG
@@ -879,7 +880,7 @@ int journal_get_undo_access(handle_t *handle, struct buffer_head *bh) 




repeat:

repeat:

	if (!jh->b_committed_data) {

	if (!jh->b_committed_data) {

		committed_data = jbd_kmalloc(jh2bh(jh)->b_size, GFP_NOFS);

		committed_data = jbd_slab_alloc(jh2bh(jh)->b_size, GFP_NOFS);

		if (!committed_data) {

		if (!committed_data) {

			printk(KERN_EMERG "%s: No memory for committed data\n",

			printk(KERN_EMERG "%s: No memory for committed data\n",

				__FUNCTION__);

				__FUNCTION__);
@@ -906,7 +907,7 @@ int journal_get_undo_access(handle_t *handle, struct buffer_head *bh) 
out:

out:

	journal_put_journal_head(jh);

	journal_put_journal_head(jh);

	if (unlikely(committed_data))

	if (unlikely(committed_data))

		kfree(committed_data);

		jbd_slab_free(committed_data, bh->b_size);

	return err;

	return err;

}

}

include/linux/jbd.h

+3 −0
Original line number Original line Diff line number Diff line
@@ -72,6 +72,9 @@ extern int journal_enable_debug; 
#endif

#endif





extern void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry);

extern void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry);

extern void * jbd_slab_alloc(size_t size, gfp_t flags);

extern void jbd_slab_free(void *ptr, size_t size);



#define jbd_kmalloc(size, flags) \

#define jbd_kmalloc(size, flags) \

	__jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)

	__jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)

#define jbd_rep_kmalloc(size, flags) \

#define jbd_rep_kmalloc(size, flags) \