--- linux-2.6.18-rc4-cmm/fs/jbd2/journal.c | 52 ++++++++-------- linux-2.6.18-rc4-cmm/fs/jbd2/revoke.c | 92 +++++++++++++++--------------- linux-2.6.18-rc4-cmm/include/linux/jbd2.h | 20 +++--- 3 files changed, 82 insertions(+), 82 deletions(-) diff -puN fs/jbd2/journal.c~jbd2-rename-revoke fs/jbd2/journal.c --- linux-2.6.18-rc4/fs/jbd2/journal.c~jbd2-rename-revoke 2006-08-07 16:27:33.000000000 -0700 +++ linux-2.6.18-rc4-cmm/fs/jbd2/journal.c 2006-08-07 17:01:00.000000000 -0700 @@ -97,7 +97,7 @@ static void commit_timeout(unsigned long } /* - * kjournald: The main thread function used to manage a logging device + * kjournald2: The main thread function used to manage a logging device * journal. * * This kernel thread is responsible for two things: @@ -112,7 +112,7 @@ static void commit_timeout(unsigned long * known as checkpointing, and this thread is responsible for that job. */ -static int kjournald(void *arg) +static int kjournald2(void *arg) { journal_t *journal = arg; transaction_t *transaction; @@ -128,7 +128,7 @@ static int kjournald(void *arg) journal->j_task = current; wake_up(&journal->j_wait_done_commit); - printk(KERN_INFO "kjournald starting. Commit interval %ld seconds\n", + printk(KERN_INFO "kjournald2 starting. Commit interval %ld seconds\n", journal->j_commit_interval / HZ); /* @@ -159,7 +159,7 @@ loop: * good idea, because that depends on threads that may * be already stopped. */ - jbd_debug(1, "Now suspending kjournald\n"); + jbd_debug(1, "Now suspending kjournald2\n"); spin_unlock(&journal->j_state_lock); refrigerator(); spin_lock(&journal->j_state_lock); @@ -189,7 +189,7 @@ loop: finish_wait(&journal->j_wait_commit, &wait); } - jbd_debug(1, "kjournald wakes\n"); + jbd_debug(1, "kjournald2 wakes\n"); /* * Were we woken up by a commit wakeup event? @@ -212,7 +212,7 @@ end_loop: static void jbd2_journal_start_thread(journal_t *journal) { - kthread_run(kjournald, journal, "kjournald"); + kthread_run(kjournald2, journal, "kjournald2"); wait_event(journal->j_wait_done_commit, journal->j_task != 0); } @@ -1606,7 +1606,7 @@ int jbd2_journal_blocks_per_page(struct * Simple support for retrying memory allocations. Introduced to help to * debug different VM deadlock avoidance strategies. */ -void * __jbd2_jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry) +void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry) { return kmalloc(size, flags | (retry ? __GFP_NOFAIL : 0)); } @@ -1614,35 +1614,35 @@ void * __jbd2_jbd_kmalloc (const char *w /* * Journal_head storage management */ -static kmem_cache_t *journal_head_cache; +static kmem_cache_t *jbd2_journal_head_cache; #ifdef CONFIG_JBD_DEBUG static atomic_t nr_journal_heads = ATOMIC_INIT(0); #endif -static int journal_init_journal_head_cache(void) +static int journal_init_jbd2_journal_head_cache(void) { int retval; - J_ASSERT(journal_head_cache == 0); - journal_head_cache = kmem_cache_create("journal_head", + J_ASSERT(jbd2_journal_head_cache == 0); + jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head", sizeof(struct journal_head), 0, /* offset */ 0, /* flags */ NULL, /* ctor */ NULL); /* dtor */ retval = 0; - if (journal_head_cache == 0) { + if (jbd2_journal_head_cache == 0) { retval = -ENOMEM; printk(KERN_EMERG "JBD: no memory for journal_head cache\n"); } return retval; } -static void jbd2_journal_destroy_journal_head_cache(void) +static void jbd2_journal_destroy_jbd2_journal_head_cache(void) { - J_ASSERT(journal_head_cache != NULL); - kmem_cache_destroy(journal_head_cache); - journal_head_cache = NULL; + J_ASSERT(jbd2_journal_head_cache != NULL); + kmem_cache_destroy(jbd2_journal_head_cache); + jbd2_journal_head_cache = NULL; } /* @@ -1656,7 +1656,7 @@ static struct journal_head *journal_allo #ifdef CONFIG_JBD_DEBUG atomic_inc(&nr_journal_heads); #endif - ret = kmem_cache_alloc(journal_head_cache, GFP_NOFS); + ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS); if (ret == 0) { jbd_debug(1, "out of memory for journal_head\n"); if (time_after(jiffies, last_warning + 5*HZ)) { @@ -1666,7 +1666,7 @@ static struct journal_head *journal_allo } while (ret == 0) { yield(); - ret = kmem_cache_alloc(journal_head_cache, GFP_NOFS); + ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS); } } return ret; @@ -1678,7 +1678,7 @@ static void journal_free_journal_head(st atomic_dec(&nr_journal_heads); memset(jh, JBD_POISON_FREE, sizeof(*jh)); #endif - kmem_cache_free(journal_head_cache, jh); + kmem_cache_free(jbd2_journal_head_cache, jh); } /* @@ -1917,17 +1917,17 @@ static void __exit jbd2_remove_jbd_proc_ #endif -kmem_cache_t *jbd2_jbd_handle_cache; +kmem_cache_t *jbd2_handle_cache; static int __init journal_init_handle_cache(void) { - jbd2_jbd_handle_cache = kmem_cache_create("journal_handle", + jbd2_handle_cache = kmem_cache_create("jbd2_journal_handle", sizeof(handle_t), 0, /* offset */ 0, /* flags */ NULL, /* ctor */ NULL); /* dtor */ - if (jbd2_jbd_handle_cache == NULL) { + if (jbd2_handle_cache == NULL) { printk(KERN_EMERG "JBD: failed to create handle cache\n"); return -ENOMEM; } @@ -1936,8 +1936,8 @@ static int __init journal_init_handle_ca static void jbd2_journal_destroy_handle_cache(void) { - if (jbd2_jbd_handle_cache) - kmem_cache_destroy(jbd2_jbd_handle_cache); + if (jbd2_handle_cache) + kmem_cache_destroy(jbd2_handle_cache); } /* @@ -1950,7 +1950,7 @@ static int __init journal_init_caches(vo ret = jbd2_journal_init_revoke_caches(); if (ret == 0) - ret = journal_init_journal_head_cache(); + ret = journal_init_jbd2_journal_head_cache(); if (ret == 0) ret = journal_init_handle_cache(); return ret; @@ -1959,7 +1959,7 @@ static int __init journal_init_caches(vo static void jbd2_journal_destroy_caches(void) { jbd2_journal_destroy_revoke_caches(); - jbd2_journal_destroy_journal_head_cache(); + jbd2_journal_destroy_jbd2_journal_head_cache(); jbd2_journal_destroy_handle_cache(); } diff -puN fs/jbd2/revoke.c~jbd2-rename-revoke fs/jbd2/revoke.c --- linux-2.6.18-rc4/fs/jbd2/revoke.c~jbd2-rename-revoke 2006-08-07 16:27:33.000000000 -0700 +++ linux-2.6.18-rc4-cmm/fs/jbd2/revoke.c 2006-08-07 17:20:13.000000000 -0700 @@ -70,14 +70,14 @@ #include #endif -static kmem_cache_t *revoke_record_cache; -static kmem_cache_t *revoke_table_cache; +static kmem_cache_t *jbd2_revoke_record_cache; +static kmem_cache_t *jbd2_revoke_table_cache; /* Each revoke record represents one single revoked block. During journal replay, this involves recording the transaction ID of the last transaction to revoke this block. */ -struct jbd_revoke_record_s +struct jbd2_revoke_record_s { struct list_head hash; tid_t sequence; /* Used for recovery only */ @@ -86,7 +86,7 @@ struct jbd_revoke_record_s /* The revoke table is just a simple hash table of revoke records. */ -struct jbd_revoke_table_s +struct jbd2_revoke_table_s { /* It is conceivable that we might want a larger hash table * for recovery. Must be a power of two. */ @@ -99,7 +99,7 @@ struct jbd_revoke_table_s #ifdef __KERNEL__ static void write_one_revoke_record(journal_t *, transaction_t *, struct journal_head **, int *, - struct jbd_revoke_record_s *); + struct jbd2_revoke_record_s *); static void flush_descriptor(journal_t *, struct journal_head *, int); #endif @@ -108,7 +108,7 @@ static void flush_descriptor(journal_t * /* Borrowed from buffer.c: this is a tried and tested block hash function */ static inline int hash(journal_t *journal, unsigned long block) { - struct jbd_revoke_table_s *table = journal->j_revoke; + struct jbd2_revoke_table_s *table = journal->j_revoke; int hash_shift = table->hash_shift; return ((block << (hash_shift - 6)) ^ @@ -120,10 +120,10 @@ static int insert_revoke_hash(journal_t tid_t seq) { struct list_head *hash_list; - struct jbd_revoke_record_s *record; + struct jbd2_revoke_record_s *record; repeat: - record = kmem_cache_alloc(revoke_record_cache, GFP_NOFS); + record = kmem_cache_alloc(jbd2_revoke_record_cache, GFP_NOFS); if (!record) goto oom; @@ -145,22 +145,22 @@ oom: /* Find a revoke record in the journal's hash table. */ -static struct jbd_revoke_record_s *find_revoke_record(journal_t *journal, +static struct jbd2_revoke_record_s *find_revoke_record(journal_t *journal, unsigned long blocknr) { struct list_head *hash_list; - struct jbd_revoke_record_s *record; + struct jbd2_revoke_record_s *record; hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)]; spin_lock(&journal->j_revoke_lock); - record = (struct jbd_revoke_record_s *) hash_list->next; + record = (struct jbd2_revoke_record_s *) hash_list->next; while (&(record->hash) != hash_list) { if (record->blocknr == blocknr) { spin_unlock(&journal->j_revoke_lock); return record; } - record = (struct jbd_revoke_record_s *) record->hash.next; + record = (struct jbd2_revoke_record_s *) record->hash.next; } spin_unlock(&journal->j_revoke_lock); return NULL; @@ -168,18 +168,18 @@ static struct jbd_revoke_record_s *find_ int __init jbd2_journal_init_revoke_caches(void) { - revoke_record_cache = kmem_cache_create("revoke_record", - sizeof(struct jbd_revoke_record_s), + jbd2_revoke_record_cache = kmem_cache_create("revoke_record2", + sizeof(struct jbd2_revoke_record_s), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); - if (revoke_record_cache == 0) + if (jbd2_revoke_record_cache == 0) return -ENOMEM; - revoke_table_cache = kmem_cache_create("revoke_table", - sizeof(struct jbd_revoke_table_s), + jbd2_revoke_table_cache = kmem_cache_create("revoke_table2", + sizeof(struct jbd2_revoke_table_s), 0, 0, NULL, NULL); - if (revoke_table_cache == 0) { - kmem_cache_destroy(revoke_record_cache); - revoke_record_cache = NULL; + if (jbd2_revoke_table_cache == 0) { + kmem_cache_destroy(jbd2_revoke_record_cache); + jbd2_revoke_record_cache = NULL; return -ENOMEM; } return 0; @@ -187,10 +187,10 @@ int __init jbd2_journal_init_revoke_cach void jbd2_journal_destroy_revoke_caches(void) { - kmem_cache_destroy(revoke_record_cache); - revoke_record_cache = NULL; - kmem_cache_destroy(revoke_table_cache); - revoke_table_cache = NULL; + kmem_cache_destroy(jbd2_revoke_record_cache); + jbd2_revoke_record_cache = NULL; + kmem_cache_destroy(jbd2_revoke_table_cache); + jbd2_revoke_table_cache = NULL; } /* Initialise the revoke table for a given journal to a given size. */ @@ -206,7 +206,7 @@ int jbd2_journal_init_revoke(journal_t * while((tmp >>= 1UL) != 0UL) shift++; - journal->j_revoke_table[0] = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL); + journal->j_revoke_table[0] = kmem_cache_alloc(jbd2_revoke_table_cache, GFP_KERNEL); if (!journal->j_revoke_table[0]) return -ENOMEM; journal->j_revoke = journal->j_revoke_table[0]; @@ -221,7 +221,7 @@ int jbd2_journal_init_revoke(journal_t * journal->j_revoke->hash_table = kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL); if (!journal->j_revoke->hash_table) { - kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]); + kmem_cache_free(jbd2_revoke_table_cache, journal->j_revoke_table[0]); journal->j_revoke = NULL; return -ENOMEM; } @@ -229,10 +229,10 @@ int jbd2_journal_init_revoke(journal_t * for (tmp = 0; tmp < hash_size; tmp++) INIT_LIST_HEAD(&journal->j_revoke->hash_table[tmp]); - journal->j_revoke_table[1] = kmem_cache_alloc(revoke_table_cache, GFP_KERNEL); + journal->j_revoke_table[1] = kmem_cache_alloc(jbd2_revoke_table_cache, GFP_KERNEL); if (!journal->j_revoke_table[1]) { kfree(journal->j_revoke_table[0]->hash_table); - kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]); + kmem_cache_free(jbd2_revoke_table_cache, journal->j_revoke_table[0]); return -ENOMEM; } @@ -249,8 +249,8 @@ int jbd2_journal_init_revoke(journal_t * kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL); if (!journal->j_revoke->hash_table) { kfree(journal->j_revoke_table[0]->hash_table); - kmem_cache_free(revoke_table_cache, journal->j_revoke_table[0]); - kmem_cache_free(revoke_table_cache, journal->j_revoke_table[1]); + kmem_cache_free(jbd2_revoke_table_cache, journal->j_revoke_table[0]); + kmem_cache_free(jbd2_revoke_table_cache, journal->j_revoke_table[1]); journal->j_revoke = NULL; return -ENOMEM; } @@ -267,7 +267,7 @@ int jbd2_journal_init_revoke(journal_t * void jbd2_journal_destroy_revoke(journal_t *journal) { - struct jbd_revoke_table_s *table; + struct jbd2_revoke_table_s *table; struct list_head *hash_list; int i; @@ -281,7 +281,7 @@ void jbd2_journal_destroy_revoke(journal } kfree(table->hash_table); - kmem_cache_free(revoke_table_cache, table); + kmem_cache_free(jbd2_revoke_table_cache, table); journal->j_revoke = NULL; table = journal->j_revoke_table[1]; @@ -294,7 +294,7 @@ void jbd2_journal_destroy_revoke(journal } kfree(table->hash_table); - kmem_cache_free(revoke_table_cache, table); + kmem_cache_free(jbd2_revoke_table_cache, table); journal->j_revoke = NULL; } @@ -420,7 +420,7 @@ int jbd2_journal_revoke(handle_t *handle */ int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh) { - struct jbd_revoke_record_s *record; + struct jbd2_revoke_record_s *record; journal_t *journal = handle->h_transaction->t_journal; int need_cancel; int did_revoke = 0; /* akpm: debug */ @@ -447,7 +447,7 @@ int jbd2_journal_cancel_revoke(handle_t spin_lock(&journal->j_revoke_lock); list_del(&record->hash); spin_unlock(&journal->j_revoke_lock); - kmem_cache_free(revoke_record_cache, record); + kmem_cache_free(jbd2_revoke_record_cache, record); did_revoke = 1; } } @@ -502,8 +502,8 @@ void jbd2_journal_write_revoke_records(j transaction_t *transaction) { struct journal_head *descriptor; - struct jbd_revoke_record_s *record; - struct jbd_revoke_table_s *revoke; + struct jbd2_revoke_record_s *record; + struct jbd2_revoke_table_s *revoke; struct list_head *hash_list; int i, offset, count; @@ -519,14 +519,14 @@ void jbd2_journal_write_revoke_records(j hash_list = &revoke->hash_table[i]; while (!list_empty(hash_list)) { - record = (struct jbd_revoke_record_s *) + record = (struct jbd2_revoke_record_s *) hash_list->next; write_one_revoke_record(journal, transaction, &descriptor, &offset, record); count++; list_del(&record->hash); - kmem_cache_free(revoke_record_cache, record); + kmem_cache_free(jbd2_revoke_record_cache, record); } } if (descriptor) @@ -543,7 +543,7 @@ static void write_one_revoke_record(jour transaction_t *transaction, struct journal_head **descriptorp, int *offsetp, - struct jbd_revoke_record_s *record) + struct jbd2_revoke_record_s *record) { struct journal_head *descriptor; int offset; @@ -644,7 +644,7 @@ int jbd2_journal_set_revoke(journal_t *j unsigned long blocknr, tid_t sequence) { - struct jbd_revoke_record_s *record; + struct jbd2_revoke_record_s *record; record = find_revoke_record(journal, blocknr); if (record) { @@ -668,7 +668,7 @@ int jbd2_journal_test_revoke(journal_t * unsigned long blocknr, tid_t sequence) { - struct jbd_revoke_record_s *record; + struct jbd2_revoke_record_s *record; record = find_revoke_record(journal, blocknr); if (!record) @@ -687,17 +687,17 @@ void jbd2_journal_clear_revoke(journal_t { int i; struct list_head *hash_list; - struct jbd_revoke_record_s *record; - struct jbd_revoke_table_s *revoke; + struct jbd2_revoke_record_s *record; + struct jbd2_revoke_table_s *revoke; revoke = journal->j_revoke; for (i = 0; i < revoke->hash_size; i++) { hash_list = &revoke->hash_table[i]; while (!list_empty(hash_list)) { - record = (struct jbd_revoke_record_s*) hash_list->next; + record = (struct jbd2_revoke_record_s*) hash_list->next; list_del(&record->hash); - kmem_cache_free(revoke_record_cache, record); + kmem_cache_free(jbd2_revoke_record_cache, record); } } } diff -puN include/linux/jbd2.h~jbd2-rename-revoke include/linux/jbd2.h --- linux-2.6.18-rc4/include/linux/jbd2.h~jbd2-rename-revoke 2006-08-07 16:27:33.000000000 -0700 +++ linux-2.6.18-rc4-cmm/include/linux/jbd2.h 2006-08-07 16:27:33.000000000 -0700 @@ -71,11 +71,11 @@ extern int jbd2_journal_enable_debug; #define jbd_debug(f, a...) /**/ #endif -extern void * __jbd2_jbd_kmalloc (const char *where, size_t size, gfp_t flags, int retry); +extern void * __jbd2_kmalloc (const char *where, size_t size, gfp_t flags, int retry); #define jbd_kmalloc(size, flags) \ - __jbd2_jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry) + __jbd2_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry) #define jbd_rep_kmalloc(size, flags) \ - __jbd2_jbd_kmalloc(__FUNCTION__, (size), (flags), 1) + __jbd2_kmalloc(__FUNCTION__, (size), (flags), 1) #define JFS_MIN_JOURNAL_BLOCKS 1024 @@ -356,7 +356,7 @@ static inline void jbd_unlock_bh_journal bit_spin_unlock(BH_JournalHead, &bh->b_state); } -struct jbd_revoke_table_s; +struct jbd2_revoke_table_s; /** * struct handle_s - The handle_s type is the concrete type associated with @@ -442,7 +442,7 @@ struct transaction_s /* * Transaction's current state - * [no locking - only kjournald alters this] + * [no locking - only kjournald2 alters this] * FIXME: needs barriers * KLUDGE: [use j_state_lock] */ @@ -802,8 +802,8 @@ struct journal_s * current transaction. [j_revoke_lock] */ spinlock_t j_revoke_lock; - struct jbd_revoke_table_s *j_revoke; - struct jbd_revoke_table_s *j_revoke_table[2]; + struct jbd2_revoke_table_s *j_revoke; + struct jbd2_revoke_table_s *j_revoke_table[2]; /* * array of bhs for jbd2_journal_commit_transaction @@ -946,16 +946,16 @@ void jbd2_journal_put_journal_head(struc /* * handle management */ -extern kmem_cache_t *jbd2_jbd_handle_cache; +extern kmem_cache_t *jbd2_handle_cache; static inline handle_t *jbd_alloc_handle(gfp_t gfp_flags) { - return kmem_cache_alloc(jbd2_jbd_handle_cache, gfp_flags); + return kmem_cache_alloc(jbd2_handle_cache, gfp_flags); } static inline void jbd_free_handle(handle_t *handle) { - kmem_cache_free(jbd2_jbd_handle_cache, handle); + kmem_cache_free(jbd2_handle_cache, handle); } /* Primary revoke support */ _