[PATCH, RFC] Ext4 patches planned for submission upstream - Kernel

This is a discussion on [PATCH, RFC] Ext4 patches planned for submission upstream - Kernel ; From: Takashi Sato This patch set supports large block size(>4k, just enlarging the block size limit. But it is NOT possible to have 64kB blocksize on ext2 without some changes to the directory handling code. The reason is that an ...

+ Reply to Thread
Page 2 of 2 FirstFirst 1 2
Results 21 to 31 of 31

Thread: [PATCH, RFC] Ext4 patches planned for submission upstream

  1. [PATCH] Support large blocksize up to PAGESIZE (max 64KB) for ext2

    From: Takashi Sato

    This patch set supports large block size(>4k, <=64k) in ext2,
    just enlarging the block size limit. But it is NOT possible to have 64kB
    blocksize on ext2 without some changes to the directory handling
    code. The reason is that an empty 64kB directory block would have a
    rec_len == (__u16)2^16 == 0, and this would cause an error to be hit in
    the filesystem. The proposed solution is treat 64k rec_len
    with a an impossible value like rec_len = 0xffff to handle this.

    The Patch-set consists of the following 2 patches.
    [1/2] ext2: enlarge blocksize
    - Allow blocksize up to pagesize

    [2/2] ext2: fix rec_len overflow
    - prevent rec_len from overflow with 64KB blocksize

    Now on 64k page ppc64 box runs with this patch set we could create a 64k
    block size ext2, and able to handle empty directory block.

    Signed-off-by: Takashi Sato
    Signed-off-by: Mingming Cao
    ---
    fs/ext2/super.c | 3 ++-
    include/linux/ext2_fs.h | 4 ++--
    2 files changed, 4 insertions(+), 3 deletions(-)

    diff --git a/fs/ext2/super.c b/fs/ext2/super.c
    index 639a32c..765c805 100644
    --- a/fs/ext2/super.c
    +++ b/fs/ext2/super.c
    @@ -775,7 +775,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
    brelse(bh);

    if (!sb_set_blocksize(sb, blocksize)) {
    - printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
    + printk(KERN_ERR "EXT2-fs: bad blocksize %d.\n",
    + blocksize);
    goto failed_sbi;
    }

    diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
    index 153d755..910a705 100644
    --- a/include/linux/ext2_fs.h
    +++ b/include/linux/ext2_fs.h
    @@ -86,8 +86,8 @@ static inline struct ext2_sb_info *EXT2_SB(struct super_block *sb)
    * Macro-instructions used to manage several block sizes
    */
    #define EXT2_MIN_BLOCK_SIZE 1024
    -#define EXT2_MAX_BLOCK_SIZE 4096
    -#define EXT2_MIN_BLOCK_LOG_SIZE 10
    +#define EXT2_MAX_BLOCK_SIZE 65536
    +#define EXT2_MIN_BLOCK_LOG_SIZE 10
    #ifdef __KERNEL__
    # define EXT2_BLOCK_SIZE(s) ((s)->s_blocksize)
    #else
    --
    1.5.3.2.81.g17ed

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  2. Re: [PATCH] jbd/jbd2: JBD memory allocation cleanups

    On Thu, Oct 04, 2007 at 01:50:36AM -0400, Theodore Ts'o wrote:
    > From: Mingming Cao
    >
    > JBD: Replace slab allocations with page cache allocations


    It's page allocations, not page cache allocations.

    > Also this patch cleans up jbd_kmalloc and replace it with kmalloc directly


    That sounds like it should be a different patch..

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  3. [PATCH] jbd: JBD slab allocation cleanups

    JBD: JBD slab allocation cleanups

    From: Mingming Cao

    JBD: Replace slab allocations with page allocations

    JBD allocate memory for committed_data and frozen_data from slab. However
    JBD should not pass slab pages down to the block layer. Use page allocator pages instead. This will also prepare JBD for the large blocksize patchset.

    Signed-off-by: Christoph Lameter
    Signed-off-by: Mingming Cao
    ---

    fs/jbd/commit.c | 6 +--
    fs/jbd/journal.c | 88 ++-------------------------------------------------
    fs/jbd/transaction.c | 8 ++--
    include/linux/jbd.h | 13 +++++--
    4 files changed, 21 insertions(+), 94 deletions(-)


    Index: linux-2.6.23-rc9/fs/jbd/commit.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd/commit.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd/commit.c 2007-10-05 12:08:08.000000000 -0700
    @@ -375,7 +375,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);
    }
    @@ -792,14 +792,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.23-rc9/fs/jbd/journal.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd/journal.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd/journal.c 2007-10-05 12:08:08.000000000 -0700
    @@ -83,7 +83,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
    @@ -334,10 +333,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;
    }

    @@ -1095,13 +1094,6 @@ int journal_load(journal_t *journal)
    }
    }

    - /*
    - * Create a slab for this blocksize
    - */
    - err = journal_create_jbd_slab(be32_to_cpu(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))
    @@ -1624,77 +1616,6 @@ void * __jbd_kmalloc (const char *where,
    }

    /*
    - * 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 struct kmem_cache *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);
    - 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 struct kmem_cache *journal_head_cache;
    @@ -1881,13 +1802,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 */
    @@ -2042,7 +1963,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.23-rc9/fs/jbd/transaction.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd/transaction.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd/transaction.c 2007-10-05 12:08:08.000000000 -0700
    @@ -668,7 +668,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
    @@ -728,7 +728,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;
    @@ -881,7 +881,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__);
    @@ -908,7 +908,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;
    }

    Index: linux-2.6.23-rc9/include/linux/jbd.h
    ================================================== =================
    --- linux-2.6.23-rc9.orig/include/linux/jbd.h 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/include/linux/jbd.h 2007-10-05 12:08:08.000000000 -0700
    @@ -72,14 +72,21 @@ extern int journal_enable_debug;
    #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

    #ifdef __KERNEL__


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  4. Re: [PATCH] jbd/jbd2: JBD memory allocation cleanups

    On Thu, 2007-10-04 at 07:52 +0100, Christoph Hellwig wrote:
    > On Thu, Oct 04, 2007 at 01:50:36AM -0400, Theodore Ts'o wrote:
    > > From: Mingming Cao
    > >
    > > JBD: Replace slab allocations with page cache allocations

    >
    > It's page allocations, not page cache allocations.
    >
    > > Also this patch cleans up jbd_kmalloc and replace it with kmalloc directly

    >
    > That sounds like it should be a different patch..


    Okay. Will sent the patches, that also separate JBD2 changes to a
    different patch.

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  5. [PATCH] jbd: JBD replace jbd_kmalloc with kmalloc

    JBD: JBD replace jbd_kmalloc with kmalloc

    From: Mingming Cao

    This patch cleans up jbd_kmalloc and replace it with kmalloc directly

    Signed-off-by: Mingming Cao
    ---

    fs/jbd/journal.c | 11 +----------
    fs/jbd/transaction.c | 4 ++--
    include/linux/jbd.h | 6 ------
    3 files changed, 3 insertions(+), 18 deletions(-)


    Index: linux-2.6.23-rc9/fs/jbd/journal.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd/journal.c 2007-10-05 12:08:08.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd/journal.c 2007-10-05 12:08:29.000000000 -0700
    @@ -653,7 +653,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);
    if (!journal)
    goto fail;
    memset(journal, 0, sizeof(*journal));
    @@ -1607,15 +1607,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));
    -}
    -
    -/*
    * Journal_head storage management
    */
    static struct kmem_cache *journal_head_cache;
    Index: linux-2.6.23-rc9/fs/jbd/transaction.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd/transaction.c 2007-10-05 12:08:08.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd/transaction.c 2007-10-05 12:08:29.000000000 -0700
    @@ -96,8 +96,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;
    Index: linux-2.6.23-rc9/include/linux/jbd.h
    ================================================== =================
    --- linux-2.6.23-rc9.orig/include/linux/jbd.h 2007-10-05 12:08:08.000000000 -0700
    +++ linux-2.6.23-rc9/include/linux/jbd.h 2007-10-05 12:08:29.000000000 -0700
    @@ -71,12 +71,6 @@ 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);
    -#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));


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  6. [PATCH] jbd2: JBD2 slab allocation cleanups

    JBD2: jbd2 slab allocation cleanups

    From: Mingming Cao

    JBD2: Replace slab allocations with page allocations

    JBD2 allocate memory for committed_data and frozen_data from slab. However
    JBD2 should not pass slab pages down to the block layer. Use page allocator
    pages instead. This will also prepare JBD for the large blocksize patchset.

    Signed-off-by: Christoph Lameter
    Signed-off-by: Mingming Cao
    ---

    fs/jbd2/commit.c | 6 +--
    fs/jbd2/journal.c | 88 ++------------------------------------------------
    fs/jbd2/transaction.c | 14 +++----
    include/linux/jbd2.h | 18 +++++++---
    4 files changed, 27 insertions(+), 99 deletions(-)


    Index: linux-2.6.23-rc9/fs/jbd2/commit.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd2/commit.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd2/commit.c 2007-10-05 12:08:26.000000000 -0700
    @@ -384,7 +384,7 @@ void jbd2_journal_commit_transaction(jou
    struct buffer_head *bh = jh2bh(jh);

    jbd_lock_bh_state(bh);
    - jbd2_slab_free(jh->b_committed_data, bh->b_size);
    + jbd2_free(jh->b_committed_data, bh->b_size);
    jh->b_committed_data = NULL;
    jbd_unlock_bh_state(bh);
    }
    @@ -801,14 +801,14 @@ restart_loop:
    * Otherwise, we can just throw away the frozen data now.
    */
    if (jh->b_committed_data) {
    - jbd2_slab_free(jh->b_committed_data, bh->b_size);
    + jbd2_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) {
    - jbd2_slab_free(jh->b_frozen_data, bh->b_size);
    + jbd2_free(jh->b_frozen_data, bh->b_size);
    jh->b_frozen_data = NULL;
    }

    Index: linux-2.6.23-rc9/fs/jbd2/journal.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd2/journal.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd2/journal.c 2007-10-05 12:08:26.000000000 -0700
    @@ -84,7 +84,6 @@ EXPORT_SYMBOL(jbd2_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 jbd2_journal_create_jbd_slab(size_t slab_size);

    /*
    * Helper function used to manage commit timeouts
    @@ -335,10 +334,10 @@ repeat:
    char *tmp;

    jbd_unlock_bh_state(bh_in);
    - tmp = jbd2_slab_alloc(bh_in->b_size, GFP_NOFS);
    + tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
    jbd_lock_bh_state(bh_in);
    if (jh_in->b_frozen_data) {
    - jbd2_slab_free(tmp, bh_in->b_size);
    + jbd2_free(tmp, bh_in->b_size);
    goto repeat;
    }

    @@ -1096,13 +1095,6 @@ int jbd2_journal_load(journal_t *journal
    }
    }

    - /*
    - * Create a slab for this blocksize
    - */
    - err = jbd2_journal_create_jbd_slab(be32_to_cpu(sb->s_blocksize));
    - if (err)
    - return err;
    -
    /* Let the recovery code check whether it needs to recover any
    * data from the journal. */
    if (jbd2_journal_recover(journal))
    @@ -1636,77 +1628,6 @@ void * __jbd2_kmalloc (const char *where
    }

    /*
    - * 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 struct kmem_cache *jbd_slab[JBD_MAX_SLABS];
    -static const char *jbd_slab_names[JBD_MAX_SLABS] = {
    - "jbd2_1k", "jbd2_2k", "jbd2_4k", NULL, "jbd2_8k"
    -};
    -
    -static void jbd2_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 jbd2_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);
    - if (!jbd_slab[i]) {
    - printk(KERN_EMERG "JBD: no memory for jbd_slab cache\n");
    - return -ENOMEM;
    - }
    - return 0;
    -}
    -
    -void * jbd2_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 jbd2_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 struct kmem_cache *jbd2_journal_head_cache;
    @@ -1893,13 +1814,13 @@ static void __journal_remove_journal_hea
    printk(KERN_WARNING "%s: freeing "
    "b_frozen_data\n",
    __FUNCTION__);
    - jbd2_slab_free(jh->b_frozen_data, bh->b_size);
    + jbd2_free(jh->b_frozen_data, bh->b_size);
    }
    if (jh->b_committed_data) {
    printk(KERN_WARNING "%s: freeing "
    "b_committed_data\n",
    __FUNCTION__);
    - jbd2_slab_free(jh->b_committed_data, bh->b_size);
    + jbd2_free(jh->b_committed_data, bh->b_size);
    }
    bh->b_private = NULL;
    jh->b_bh = NULL; /* debug, really */
    @@ -2040,7 +1961,6 @@ static void jbd2_journal_destroy_caches(
    jbd2_journal_destroy_revoke_caches();
    jbd2_journal_destroy_jbd2_journal_head_cache();
    jbd2_journal_destroy_handle_cache();
    - jbd2_journal_destroy_jbd_slabs();
    }

    static int __init journal_init(void)
    Index: linux-2.6.23-rc9/fs/jbd2/transaction.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd2/transaction.c 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd2/transaction.c 2007-10-05 12:08:26.000000000 -0700
    @@ -236,7 +236,7 @@ out:
    /* Allocate a new handle. This should probably be in a slab... */
    static handle_t *new_handle(int nblocks)
    {
    - handle_t *handle = jbd_alloc_handle(GFP_NOFS);
    + handle_t *handle = jbd2_alloc_handle(GFP_NOFS);
    if (!handle)
    return NULL;
    memset(handle, 0, sizeof(*handle));
    @@ -282,7 +282,7 @@ handle_t *jbd2_journal_start(journal_t *

    err = start_this_handle(journal, handle);
    if (err < 0) {
    - jbd_free_handle(handle);
    + jbd2_free_handle(handle);
    current->journal_info = NULL;
    handle = ERR_PTR(err);
    }
    @@ -668,7 +668,7 @@ repeat:
    JBUFFER_TRACE(jh, "allocate memory for buffer");
    jbd_unlock_bh_state(bh);
    frozen_buffer =
    - jbd2_slab_alloc(jh2bh(jh)->b_size,
    + jbd2_alloc(jh2bh(jh)->b_size,
    GFP_NOFS);
    if (!frozen_buffer) {
    printk(KERN_EMERG
    @@ -728,7 +728,7 @@ done:

    out:
    if (unlikely(frozen_buffer)) /* It's usually NULL */
    - jbd2_slab_free(frozen_buffer, bh->b_size);
    + jbd2_free(frozen_buffer, bh->b_size);

    JBUFFER_TRACE(jh, "exit");
    return error;
    @@ -881,7 +881,7 @@ int jbd2_journal_get_undo_access(handle_

    repeat:
    if (!jh->b_committed_data) {
    - committed_data = jbd2_slab_alloc(jh2bh(jh)->b_size, GFP_NOFS);
    + committed_data = jbd2_alloc(jh2bh(jh)->b_size, GFP_NOFS);
    if (!committed_data) {
    printk(KERN_EMERG "%s: No memory for committed data\n",
    __FUNCTION__);
    @@ -908,7 +908,7 @@ repeat:
    out:
    jbd2_journal_put_journal_head(jh);
    if (unlikely(committed_data))
    - jbd2_slab_free(committed_data, bh->b_size);
    + jbd2_free(committed_data, bh->b_size);
    return err;
    }

    @@ -1411,7 +1411,7 @@ int jbd2_journal_stop(handle_t *handle)
    spin_unlock(&journal->j_state_lock);
    }

    - jbd_free_handle(handle);
    + jbd2_free_handle(handle);
    return err;
    }

    Index: linux-2.6.23-rc9/include/linux/jbd2.h
    ================================================== =================
    --- linux-2.6.23-rc9.orig/include/linux/jbd2.h 2007-10-05 12:03:43.000000000 -0700
    +++ linux-2.6.23-rc9/include/linux/jbd2.h 2007-10-05 12:08:26.000000000 -0700
    @@ -72,14 +72,22 @@ extern u8 jbd2_journal_enable_debug;
    #endif

    extern void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry);
    -extern void * jbd2_slab_alloc(size_t size, gfp_t flags);
    -extern void jbd2_slab_free(void *ptr, size_t size);
    -
    #define jbd_kmalloc(size, flags) \
    __jbd2_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
    #define jbd_rep_kmalloc(size, flags) \
    __jbd2_kmalloc(__FUNCTION__, (size), (flags), 1)

    +
    +static inline void *jbd2_alloc(size_t size, gfp_t flags)
    +{
    + return (void *)__get_free_pages(flags, get_order(size));
    +}
    +
    +static inline void jbd2_free(void *ptr, size_t size)
    +{
    + free_pages((unsigned long)ptr, get_order(size));
    +};
    +
    #define JBD2_MIN_JOURNAL_BLOCKS 1024

    #ifdef __KERNEL__
    @@ -959,12 +967,12 @@ void jbd2_journal_put_journal_head(struc
    */
    extern struct kmem_cache *jbd2_handle_cache;

    -static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags)
    +static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
    {
    return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
    }

    -static inline void jbd_free_handle(handle_t *handle)
    +static inline void jbd2_free_handle(handle_t *handle)
    {
    kmem_cache_free(jbd2_handle_cache, handle);
    }


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  7. [PATCH] jbd2: JBD replace jbd2_kmalloc with kmalloc

    JBD2: JBD2 replace jbd2_kmalloc with kmalloc

    From: Mingming Cao

    This patch cleans up jbd_kmalloc and replace it with kmalloc directly

    Signed-off-by: Mingming Cao
    ---

    fs/jbd2/journal.c | 11 +----------
    fs/jbd2/transaction.c | 4 ++--
    include/linux/jbd2.h | 7 -------
    3 files changed, 3 insertions(+), 19 deletions(-)


    Index: linux-2.6.23-rc9/fs/jbd2/journal.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd2/journal.c 2007-10-05 12:08:26.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd2/journal.c 2007-10-05 12:08:32.000000000 -0700
    @@ -654,7 +654,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);
    if (!journal)
    goto fail;
    memset(journal, 0, sizeof(*journal));
    @@ -1619,15 +1619,6 @@ size_t journal_tag_bytes(journal_t *jour
    }

    /*
    - * Simple support for retrying memory allocations. Introduced to help to
    - * debug different VM deadlock avoidance strategies.
    - */
    -void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry)
    -{
    - return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0));
    -}
    -
    -/*
    * Journal_head storage management
    */
    static struct kmem_cache *jbd2_journal_head_cache;
    Index: linux-2.6.23-rc9/fs/jbd2/transaction.c
    ================================================== =================
    --- linux-2.6.23-rc9.orig/fs/jbd2/transaction.c 2007-10-05 12:08:26.000000000 -0700
    +++ linux-2.6.23-rc9/fs/jbd2/transaction.c 2007-10-05 12:08:32.000000000 -0700
    @@ -96,8 +96,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;
    Index: linux-2.6.23-rc9/include/linux/jbd2.h
    ================================================== =================
    --- linux-2.6.23-rc9.orig/include/linux/jbd2.h 2007-10-05 12:08:26.000000000 -0700
    +++ linux-2.6.23-rc9/include/linux/jbd2.h 2007-10-05 12:08:32.000000000 -0700
    @@ -71,13 +71,6 @@ extern u8 jbd2_journal_enable_debug;
    #define jbd_debug(f, a...) /**/
    #endif

    -extern void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry);
    -#define jbd_kmalloc(size, flags) \
    - __jbd2_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
    -#define jbd_rep_kmalloc(size, flags) \
    - __jbd2_kmalloc(__FUNCTION__, (size), (flags), 1)
    -
    -
    static inline void *jbd2_alloc(size_t size, gfp_t flags)
    {
    return (void *)__get_free_pages(flags, get_order(size));


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  8. Re: [PATCH] jbd: JBD replace jbd_kmalloc with kmalloc

    On Fri, 5 Oct 2007, Mingming Cao wrote:

    > Index: linux-2.6.23-rc9/fs/jbd/transaction.c
    > ================================================== =================
    > --- linux-2.6.23-rc9.orig/fs/jbd/transaction.c 2007-10-05 12:08:08.000000000 -0700
    > +++ linux-2.6.23-rc9/fs/jbd/transaction.c 2007-10-05 12:08:29.000000000 -0700
    > @@ -96,8 +96,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);



    Why was a __GFP_NOFAIL added here? I do not see a use of jbd_rep_kmalloc?

    > -#define jbd_kmalloc(size, flags) \
    > - __jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)


    journal_oom_retry is no longer used?
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  9. Re: [PATCH] jbd: JBD replace jbd_kmalloc with kmalloc

    On Mon, 2007-10-08 at 10:46 -0700, Christoph Lameter wrote:
    > On Fri, 5 Oct 2007, Mingming Cao wrote:
    >
    > > Index: linux-2.6.23-rc9/fs/jbd/transaction.c
    > > ================================================== =================
    > > --- linux-2.6.23-rc9.orig/fs/jbd/transaction.c 2007-10-05 12:08:08.000000000 -0700
    > > +++ linux-2.6.23-rc9/fs/jbd/transaction.c 2007-10-05 12:08:29.000000000 -0700
    > > @@ -96,8 +96,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);

    >
    >
    > Why was a __GFP_NOFAIL added here? I do not see a use of jbd_rep_kmalloc?
    >
    > > -#define jbd_kmalloc(size, flags) \
    > > - __jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)

    >
    > journal_oom_retry is no longer used?
    > -


    journal_oom_retry (which is defined as 1 currently) is still being used
    in revoke.c, the cleanup patch doesn't remove the define of
    journal_oom_retry.

    Since journal_oom_retry is always 1 to __jbd_kmalloc,

    void * __jbd_kmalloc (const char *where, size_t size, gfp_t flags, int
    retry)
    {
    return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0));
    }

    So we replace jbd_kmalloc() to kmalloc() with __GFP_NOFAIL flag on in
    start_this_handle(). Other two places replacing to kmalloc() is part of
    the init process, so no need for __GFP_NOFAIL flag there.

    Mingming

    > To unsubscribe from this list: send the line "unsubscribe linux-ext4" in
    > the body of a message to majordomo@vger.kernel.org
    > More majordomo info at http://vger.kernel.org/majordomo-info.html


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  10. Re: [PATCH] jbd2: JBD replace jbd2_kmalloc with kmalloc

    Acked-by: Christoph Lameter


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

  11. Re: [PATCH] jbd: JBD replace jbd_kmalloc with kmalloc

    On Mon, 8 Oct 2007, Mingming Cao wrote:

    > So we replace jbd_kmalloc() to kmalloc() with __GFP_NOFAIL flag on in
    > start_this_handle(). Other two places replacing to kmalloc() is part of
    > the init process, so no need for __GFP_NOFAIL flag there.


    Acked-by: Christoph Lameter

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

+ Reply to Thread
Page 2 of 2 FirstFirst 1 2