Attachment 200431 Details for Bug 241540 – patch to use page allocations for anything sent to block layer

[patch] patch to use page allocations for anything sent to block layer

no_jbd_kmalloc.patch (text/plain), 7.76 KB, created by Eric Sandeen on 2007-09-20 03:12:58 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Eric Sandeen

Created: 2007-09-20 03:12:58 UTC

Size: 7.76 KB

patch

obsolete

>Index: linux-2.6.18-24.el5/fs/jbd/journal.c
>===================================================================
>--- linux-2.6.18-24.el5.orig/fs/jbd/journal.c
>+++ linux-2.6.18-24.el5/fs/jbd/journal.c
>@@ -84,7 +84,6 @@ EXPORT_SYMBOL(journal_force_commit);
> 
> static int journal_convert_superblock_v1(journal_t *, journal_superblock_t *);
> 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
>@@ -329,10 +328,10 @@ repeat:
> 		char *tmp;
> 
> 		jbd_unlock_bh_state(bh_in);
>-		tmp = jbd_slab_alloc(bh_in->b_size, GFP_NOFS);
>+		tmp = jbd_alloc(bh_in->b_size, GFP_NOFS);
> 		jbd_lock_bh_state(bh_in);
> 		if (jh_in->b_frozen_data) {
>-			jbd_slab_free(tmp, bh_in->b_size);
>+			jbd_free(tmp, bh_in->b_size);
> 			goto repeat;
> 		}
> 
>@@ -649,7 +648,7 @@ static journal_t * journal_init_common (
> 	journal_t *journal;
> 	int err;
> 
>-	journal = jbd_kmalloc(sizeof(*journal), GFP_KERNEL);
>+	journal = kmalloc(sizeof(*journal), GFP_KERNEL|__GFP_NOFAIL);
> 	if (!journal)
> 		goto fail;
> 	memset(journal, 0, sizeof(*journal));
>@@ -1091,13 +1090,6 @@ 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
> 	 * data from the journal. */
> 	if (journal_recover(journal))
>@@ -1611,86 +1603,6 @@ int journal_blocks_per_page(struct inode
> }
> 
> /*
>- * Simple support for retrying memory allocations.  Introduced to help to
>- * debug different VM deadlock avoidance strategies. 
>- */
>-void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry)
>-{
>-	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
>  */
> static kmem_cache_t *journal_head_cache;
>@@ -1878,13 +1790,13 @@ static void __journal_remove_journal_hea
> 				printk(KERN_WARNING "%s: freeing "
> 						"b_frozen_data\n",
> 						__FUNCTION__);
>-				jbd_slab_free(jh->b_frozen_data, bh->b_size);
>+				jbd_free(jh->b_frozen_data, bh->b_size);
> 			}
> 			if (jh->b_committed_data) {
> 				printk(KERN_WARNING "%s: freeing "
> 						"b_committed_data\n",
> 						__FUNCTION__);
>-				jbd_slab_free(jh->b_committed_data, bh->b_size);
>+				jbd_free(jh->b_committed_data, bh->b_size);
> 			}
> 			bh->b_private = NULL;
> 			jh->b_bh = NULL;	/* debug, really */
>@@ -2040,7 +1952,6 @@ static void journal_destroy_caches(void)
> 	journal_destroy_revoke_caches();
> 	journal_destroy_journal_head_cache();
> 	journal_destroy_handle_cache();
>-	journal_destroy_jbd_slabs();
> }
> 
> static int __init journal_init(void)
>Index: linux-2.6.18-24.el5/include/linux/jbd.h
>===================================================================
>--- linux-2.6.18-24.el5.orig/include/linux/jbd.h
>+++ linux-2.6.18-24.el5/include/linux/jbd.h
>@@ -71,14 +71,16 @@ extern int journal_enable_debug;
> #define jbd_debug(f, a...)	/**/
> #endif
> 
>-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) \
>-	__jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
>-#define jbd_rep_kmalloc(size, flags) \
>-	__jbd_kmalloc(__FUNCTION__, (size), (flags), 1)
>+
>+static inline void *jbd_alloc(size_t size, gfp_t flags)
>+{
>+	return (void *)__get_free_pages(flags, get_order(size));
>+}
>+
>+static inline void jbd_free(void *ptr, size_t size)
>+{
>+	free_pages((unsigned long)ptr, get_order(size));
>+};
> 
> #define JFS_MIN_JOURNAL_BLOCKS 1024
> 
>Index: linux-2.6.18-24.el5/fs/jbd/commit.c
>===================================================================
>--- linux-2.6.18-24.el5.orig/fs/jbd/commit.c
>+++ linux-2.6.18-24.el5/fs/jbd/commit.c
>@@ -376,7 +376,7 @@ void journal_commit_transaction(journal_
> 			struct buffer_head *bh = jh2bh(jh);
> 
> 			jbd_lock_bh_state(bh);
>-			jbd_slab_free(jh->b_committed_data, bh->b_size);
>+			jbd_free(jh->b_committed_data, bh->b_size);
> 			jh->b_committed_data = NULL;
> 			jbd_unlock_bh_state(bh);
> 		}
>@@ -793,14 +793,14 @@ restart_loop:
> 		 * Otherwise, we can just throw away the frozen data now.
> 		 */
> 		if (jh->b_committed_data) {
>-			jbd_slab_free(jh->b_committed_data, bh->b_size);
>+			jbd_free(jh->b_committed_data, bh->b_size);
> 			jh->b_committed_data = NULL;
> 			if (jh->b_frozen_data) {
> 				jh->b_committed_data = jh->b_frozen_data;
> 				jh->b_frozen_data = NULL;
> 			}
> 		} else if (jh->b_frozen_data) {
>-			jbd_slab_free(jh->b_frozen_data, bh->b_size);
>+			jbd_free(jh->b_frozen_data, bh->b_size);
> 			jh->b_frozen_data = NULL;
> 		}
> 
>Index: linux-2.6.18-24.el5/fs/jbd/transaction.c
>===================================================================
>--- linux-2.6.18-24.el5.orig/fs/jbd/transaction.c
>+++ linux-2.6.18-24.el5/fs/jbd/transaction.c
>@@ -95,8 +95,8 @@ static int start_this_handle(journal_t *
> 
> alloc_transaction:
> 	if (!journal->j_running_transaction) {
>-		new_transaction = jbd_kmalloc(sizeof(*new_transaction),
>-						GFP_NOFS);
>+		new_transaction = kmalloc(sizeof(*new_transaction),
>+						GFP_NOFS|__GFP_NOFAIL);
> 		if (!new_transaction) {
> 			ret = -ENOMEM;
> 			goto out;
>@@ -667,7 +667,7 @@ repeat:
> 				JBUFFER_TRACE(jh, "allocate memory for buffer");
> 				jbd_unlock_bh_state(bh);
> 				frozen_buffer =
>-					jbd_slab_alloc(jh2bh(jh)->b_size,
>+					jbd_alloc(jh2bh(jh)->b_size,
> 							 GFP_NOFS);
> 				if (!frozen_buffer) {
> 					printk(KERN_EMERG
>@@ -727,7 +727,7 @@ done:
> 
> out:
> 	if (unlikely(frozen_buffer))	/* It's usually NULL */
>-		jbd_slab_free(frozen_buffer, bh->b_size);
>+		jbd_free(frozen_buffer, bh->b_size);
> 
> 	JBUFFER_TRACE(jh, "exit");
> 	return error;
>@@ -880,7 +880,7 @@ int journal_get_undo_access(handle_t *ha
> 
> repeat:
> 	if (!jh->b_committed_data) {
>-		committed_data = jbd_slab_alloc(jh2bh(jh)->b_size, GFP_NOFS);
>+		committed_data = jbd_alloc(jh2bh(jh)->b_size, GFP_NOFS);
> 		if (!committed_data) {
> 			printk(KERN_EMERG "%s: No memory for committed data\n",
> 				__FUNCTION__);
>@@ -907,7 +907,7 @@ repeat:
> out:
> 	journal_put_journal_head(jh);
> 	if (unlikely(committed_data))
>-		jbd_slab_free(committed_data, bh->b_size);
>+		jbd_free(committed_data, bh->b_size);
> 	return err;
> }
> 
>

Actions: View | Diff

Attachments on bug 241540: 197531 | 200431