diff options
Diffstat (limited to 'fs/reiserfs/journal.c')
| -rw-r--r-- | fs/reiserfs/journal.c | 1406 |
1 files changed, 757 insertions, 649 deletions
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c index 73feacc49b2..e8870de4627 100644 --- a/fs/reiserfs/journal.c +++ b/fs/reiserfs/journal.c @@ -1,38 +1,38 @@ /* -** Write ahead logging implementation copyright Chris Mason 2000 -** -** The background commits make this code very interrelated, and -** overly complex. I need to rethink things a bit....The major players: -** -** journal_begin -- call with the number of blocks you expect to log. -** If the current transaction is too -** old, it will block until the current transaction is -** finished, and then start a new one. -** Usually, your transaction will get joined in with -** previous ones for speed. -** -** journal_join -- same as journal_begin, but won't block on the current -** transaction regardless of age. Don't ever call -** this. Ever. There are only two places it should be -** called from, and they are both inside this file. -** -** journal_mark_dirty -- adds blocks into this transaction. clears any flags -** that might make them get sent to disk -** and then marks them BH_JDirty. Puts the buffer head -** into the current transaction hash. -** -** journal_end -- if the current transaction is batchable, it does nothing -** otherwise, it could do an async/synchronous commit, or -** a full flush of all log and real blocks in the -** transaction. -** -** flush_old_commits -- if the current transaction is too old, it is ended and -** commit blocks are sent to disk. Forces commit blocks -** to disk for all backgrounded commits that have been -** around too long. -** -- Note, if you call this as an immediate flush from -** from within kupdate, it will ignore the immediate flag -*/ + * Write ahead logging implementation copyright Chris Mason 2000 + * + * The background commits make this code very interrelated, and + * overly complex. I need to rethink things a bit....The major players: + * + * journal_begin -- call with the number of blocks you expect to log. + * If the current transaction is too + * old, it will block until the current transaction is + * finished, and then start a new one. + * Usually, your transaction will get joined in with + * previous ones for speed. + * + * journal_join -- same as journal_begin, but won't block on the current + * transaction regardless of age. Don't ever call + * this. Ever. There are only two places it should be + * called from, and they are both inside this file. + * + * journal_mark_dirty -- adds blocks into this transaction. clears any flags + * that might make them get sent to disk + * and then marks them BH_JDirty. Puts the buffer head + * into the current transaction hash. + * + * journal_end -- if the current transaction is batchable, it does nothing + * otherwise, it could do an async/synchronous commit, or + * a full flush of all log and real blocks in the + * transaction. + * + * flush_old_commits -- if the current transaction is too old, it is ended and + * commit blocks are sent to disk. Forces commit blocks + * to disk for all backgrounded commits that have been + * around too long. + * -- Note, if you call this as an immediate flush from + * from within kupdate, it will ignore the immediate flag + */ #include <linux/time.h> #include <linux/semaphore.h> @@ -58,23 +58,19 @@ #define JOURNAL_WORK_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \ j_working_list)) -/* the number of mounted filesystems. This is used to decide when to -** start and kill the commit workqueue -*/ -static int reiserfs_mounted_fs_count; - -static struct workqueue_struct *commit_wq; - -#define JOURNAL_TRANS_HALF 1018 /* must be correct to keep the desc and commit - structs at 4k */ +/* must be correct to keep the desc and commit structs at 4k */ +#define JOURNAL_TRANS_HALF 1018 #define BUFNR 64 /*read ahead */ /* cnode stat bits. Move these into reiserfs_fs.h */ -#define BLOCK_FREED 2 /* this block was freed, and can't be written. */ -#define BLOCK_FREED_HOLDER 3 /* this block was freed during this transaction, and can't be written */ +/* this block was freed, and can't be written. */ +#define BLOCK_FREED 2 +/* this block was freed during this transaction, and can't be written */ +#define BLOCK_FREED_HOLDER 3 -#define BLOCK_NEEDS_FLUSH 4 /* used in flush_journal_list */ +/* used in flush_journal_list */ +#define BLOCK_NEEDS_FLUSH 4 #define BLOCK_DIRTIED 5 /* journal list state bits */ @@ -87,16 +83,14 @@ static struct workqueue_struct *commit_wq; #define COMMIT_NOW 2 /* end and commit this transaction */ #define WAIT 4 /* wait for the log blocks to hit the disk */ -static int do_journal_end(struct reiserfs_transaction_handle *, - struct super_block *, unsigned long nblocks, - int flags); +static int do_journal_end(struct reiserfs_transaction_handle *, int flags); static int flush_journal_list(struct super_block *s, struct reiserfs_journal_list *jl, int flushall); static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list *jl, int flushall); static int can_dirty(struct reiserfs_journal_cnode *cn); static int journal_join(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks); + struct super_block *sb); static void release_journal_dev(struct super_block *super, struct reiserfs_journal *journal); static int dirty_one_transaction(struct super_block *s, @@ -107,8 +101,10 @@ static void queue_log_writer(struct super_block *s); /* values for join in do_journal_begin_r */ enum { JBEGIN_REG = 0, /* regular journal begin */ - JBEGIN_JOIN = 1, /* join the running transaction if at all possible */ - JBEGIN_ABORT = 2, /* called from cleanup code, ignores aborted flag */ + /* join the running transaction if at all possible */ + JBEGIN_JOIN = 1, + /* called from cleanup code, ignores aborted flag */ + JBEGIN_ABORT = 2, }; static int do_journal_begin_r(struct reiserfs_transaction_handle *th, @@ -123,10 +119,11 @@ static void init_journal_hash(struct super_block *sb) } /* -** clears BH_Dirty and sticks the buffer on the clean list. Called because I can't allow refile_buffer to -** make schedule happen after I've freed a block. Look at remove_from_transaction and journal_mark_freed for -** more details. -*/ + * clears BH_Dirty and sticks the buffer on the clean list. Called because + * I can't allow refile_buffer to make schedule happen after I've freed a + * block. Look at remove_from_transaction and journal_mark_freed for + * more details. + */ static int reiserfs_clean_and_file_buffer(struct buffer_head *bh) { if (bh) { @@ -163,7 +160,7 @@ static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *sb) struct list_head *entry = journal->j_bitmap_nodes.next; journal->j_used_bitmap_nodes++; - repeat: +repeat: if (entry != &journal->j_bitmap_nodes) { bn = list_entry(entry, struct reiserfs_bitmap_node, list); @@ -204,7 +201,8 @@ static void allocate_bitmap_nodes(struct super_block *sb) list_add(&bn->list, &journal->j_bitmap_nodes); journal->j_free_bitmap_nodes++; } else { - break; /* this is ok, we'll try again when more are needed */ + /* this is ok, we'll try again when more are needed */ + break; } } } @@ -239,8 +237,8 @@ static void cleanup_bitmap_list(struct super_block *sb, } /* -** only call this on FS unmount. -*/ + * only call this on FS unmount. + */ static int free_list_bitmaps(struct super_block *sb, struct reiserfs_list_bitmap *jb_array) { @@ -275,9 +273,9 @@ static int free_bitmap_nodes(struct super_block *sb) } /* -** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps. -** jb_array is the array to be filled in. -*/ + * get memory for JOURNAL_NUM_BITMAPS worth of bitmaps. + * jb_array is the array to be filled in. + */ int reiserfs_allocate_list_bitmaps(struct super_block *sb, struct reiserfs_list_bitmap *jb_array, unsigned int bmap_nr) @@ -306,9 +304,9 @@ int reiserfs_allocate_list_bitmaps(struct super_block *sb, } /* -** find an available list bitmap. If you can't find one, flush a commit list -** and try again -*/ + * find an available list bitmap. If you can't find one, flush a commit list + * and try again + */ static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb, struct reiserfs_journal_list *jl) @@ -332,18 +330,18 @@ static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb, break; } } - if (jb->journal_list) { /* double check to make sure if flushed correctly */ + /* double check to make sure if flushed correctly */ + if (jb->journal_list) return NULL; - } jb->journal_list = jl; return jb; } /* -** allocates a new chunk of X nodes, and links them all together as a list. -** Uses the cnode->next and cnode->prev pointers -** returns NULL on failure -*/ + * allocates a new chunk of X nodes, and links them all together as a list. + * Uses the cnode->next and cnode->prev pointers + * returns NULL on failure + */ static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes) { struct reiserfs_journal_cnode *head; @@ -365,9 +363,7 @@ static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes) return head; } -/* -** pulls a cnode off the free list, or returns NULL on failure -*/ +/* pulls a cnode off the free list, or returns NULL on failure */ static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb) { struct reiserfs_journal_cnode *cn; @@ -393,8 +389,8 @@ static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb) } /* -** returns a cnode to the free list -*/ + * returns a cnode to the free list + */ static void free_cnode(struct super_block *sb, struct reiserfs_journal_cnode *cn) { @@ -419,7 +415,10 @@ static void clear_prepared_bits(struct buffer_head *bh) clear_buffer_journal_restore_dirty(bh); } -/* return a cnode with same dev, block number and size in table, or null if not found */ +/* + * return a cnode with same dev, block number and size in table, + * or null if not found + */ static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct super_block *sb, @@ -439,23 +438,24 @@ static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct } /* -** this actually means 'can this block be reallocated yet?'. If you set search_all, a block can only be allocated -** if it is not in the current transaction, was not freed by the current transaction, and has no chance of ever -** being overwritten by a replay after crashing. -** -** If you don't set search_all, a block can only be allocated if it is not in the current transaction. Since deleting -** a block removes it from the current transaction, this case should never happen. If you don't set search_all, make -** sure you never write the block without logging it. -** -** next_zero_bit is a suggestion about the next block to try for find_forward. -** when bl is rejected because it is set in a journal list bitmap, we search -** for the next zero bit in the bitmap that rejected bl. Then, we return that -** through next_zero_bit for find_forward to try. -** -** Just because we return something in next_zero_bit does not mean we won't -** reject it on the next call to reiserfs_in_journal -** -*/ + * this actually means 'can this block be reallocated yet?'. If you set + * search_all, a block can only be allocated if it is not in the current + * transaction, was not freed by the current transaction, and has no chance + * of ever being overwritten by a replay after crashing. + * + * If you don't set search_all, a block can only be allocated if it is not + * in the current transaction. Since deleting a block removes it from the + * current transaction, this case should never happen. If you don't set + * search_all, make sure you never write the block without logging it. + * + * next_zero_bit is a suggestion about the next block to try for find_forward. + * when bl is rejected because it is set in a journal list bitmap, we search + * for the next zero bit in the bitmap that rejected bl. Then, we return + * that through next_zero_bit for find_forward to try. + * + * Just because we return something in next_zero_bit does not mean we won't + * reject it on the next call to reiserfs_in_journal + */ int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr, int bit_nr, int search_all, b_blocknr_t * next_zero_bit) @@ -469,9 +469,11 @@ int reiserfs_in_journal(struct super_block *sb, *next_zero_bit = 0; /* always start this at zero. */ PROC_INFO_INC(sb, journal.in_journal); - /* If we aren't doing a search_all, this is a metablock, and it will be logged before use. - ** if we crash before the transaction that freed it commits, this transaction won't - ** have committed either, and the block will never be written + /* + * If we aren't doing a search_all, this is a metablock, and it + * will be logged before use. if we crash before the transaction + * that freed it commits, this transaction won't have committed + * either, and the block will never be written */ if (search_all) { for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { @@ -511,8 +513,7 @@ int reiserfs_in_journal(struct super_block *sb, return 0; } -/* insert cn into table -*/ +/* insert cn into table */ static inline void insert_journal_hash(struct reiserfs_journal_cnode **table, struct reiserfs_journal_cnode *cn) { @@ -558,10 +559,10 @@ static inline void put_journal_list(struct super_block *s, } /* -** this used to be much more involved, and I'm keeping it just in case things get ugly again. -** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a -** transaction. -*/ + * this used to be much more involved, and I'm keeping it just in case + * things get ugly again. it gets called by flush_commit_list, and + * cleans up any data stored about blocks freed during a transaction. + */ static void cleanup_freed_for_journal_list(struct super_block *sb, struct reiserfs_journal_list *jl) { @@ -756,11 +757,12 @@ static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh, jh = bh->b_private; list_del_init(&jh->list); } else { - no_jh: +no_jh: get_bh(bh); jh = alloc_jh(); spin_lock(&j->j_dirty_buffers_lock); - /* buffer must be locked for __add_jh, should be able to have + /* + * buffer must be locked for __add_jh, should be able to have * two adds at the same time */ BUG_ON(bh->b_private); @@ -818,7 +820,8 @@ static int write_ordered_buffers(spinlock_t * lock, spin_lock(lock); goto loop_next; } - /* in theory, dirty non-uptodate buffers should never get here, + /* + * in theory, dirty non-uptodate buffers should never get here, * but the upper layer io error paths still have a few quirks. * Handle them here as gracefully as we can */ @@ -833,7 +836,7 @@ static int write_ordered_buffers(spinlock_t * lock, reiserfs_free_jh(bh); unlock_buffer(bh); } - loop_next: +loop_next: put_bh(bh); cond_resched_lock(lock); } @@ -856,13 +859,14 @@ static int write_ordered_buffers(spinlock_t * lock, if (!buffer_uptodate(bh)) { ret = -EIO; } - /* ugly interaction with invalidatepage here. - * reiserfs_invalidate_page will pin any buffer that has a valid - * journal head from an older transaction. If someone else sets - * our buffer dirty after we write it in the first loop, and - * then someone truncates the page away, nobody will ever write - * the buffer. We're safe if we write the page one last time - * after freeing the journal header. + /* + * ugly interaction with invalidatepage here. + * reiserfs_invalidate_page will pin any buffer that has a + * valid journal head from an older transaction. If someone + * else sets our buffer dirty after we write it in the first + * loop, and then someone truncates the page away, nobody + * will ever write the buffer. We're safe if we write the + * page one last time after freeing the journal header. */ if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) { spin_unlock(lock); @@ -887,7 +891,7 @@ static int flush_older_commits(struct super_block *s, unsigned int other_trans_id; unsigned int first_trans_id; - find_first: +find_first: /* * first we walk backwards to find the oldest uncommitted transation */ @@ -923,9 +927,11 @@ static int flush_older_commits(struct super_block *s, if (!journal_list_still_alive(s, trans_id)) return 1; - /* the one we just flushed is gone, this means all - * older lists are also gone, so first_jl is no longer - * valid either. Go back to the beginning. + /* + * the one we just flushed is gone, this means + * all older lists are also gone, so first_jl + * is no longer valid either. Go back to the + * beginning. */ if (!journal_list_still_alive (s, other_trans_id)) { @@ -958,12 +964,12 @@ static int reiserfs_async_progress_wait(struct super_block *s) } /* -** if this journal list still has commit blocks unflushed, send them to disk. -** -** log areas must be flushed in order (transaction 2 can't commit before transaction 1) -** Before the commit block can by written, every other log block must be safely on disk -** -*/ + * if this journal list still has commit blocks unflushed, send them to disk. + * + * log areas must be flushed in order (transaction 2 can't commit before + * transaction 1) Before the commit block can by written, every other log + * block must be safely on disk + */ static int flush_commit_list(struct super_block *s, struct reiserfs_journal_list *jl, int flushall) { @@ -982,8 +988,9 @@ static int flush_commit_list(struct super_block *s, return 0; } - /* before we can put our commit blocks on disk, we have to make sure everyone older than - ** us is on disk too + /* + * before we can put our commit blocks on disk, we have to make + * sure everyone older than us is on disk too */ BUG_ON(jl->j_len <= 0); BUG_ON(trans_id == journal->j_trans_id); @@ -991,7 +998,10 @@ static int flush_commit_list(struct super_block *s, get_journal_list(jl); if (flushall) { if (flush_older_commits(s, jl) == 1) { - /* list disappeared during flush_older_commits. return */ + /* + * list disappeared during flush_older_commits. + * return + */ goto put_jl; } } @@ -1006,9 +1016,9 @@ static int flush_commit_list(struct super_block *s, BUG_ON(jl->j_trans_id == 0); /* this commit is done, exit */ - if (atomic_read(&(jl->j_commit_left)) <= 0) { + if (atomic_read(&jl->j_commit_left) <= 0) { if (flushall) { - atomic_set(&(jl->j_older_commits_done), 1); + atomic_set(&jl->j_older_commits_done, 1); } mutex_unlock(&jl->j_commit_mutex); goto put_jl; @@ -1063,9 +1073,10 @@ static int flush_commit_list(struct super_block *s, depth = reiserfs_write_unlock_nested(s); __wait_on_buffer(tbh); reiserfs_write_lock_nested(s, depth); - // since we're using ll_rw_blk above, it might have skipped over - // a locked buffer. Double check here - // + /* + * since we're using ll_rw_blk above, it might have skipped + * over a locked buffer. Double check here + */ /* redundant, sync_dirty_buffer() checks */ if (buffer_dirty(tbh)) { depth = reiserfs_write_unlock_nested(s); @@ -1079,17 +1090,21 @@ static int flush_commit_list(struct super_block *s, #endif retval = -EIO; } - put_bh(tbh); /* once for journal_find_get_block */ - put_bh(tbh); /* once due to original getblk in do_journal_end */ - atomic_dec(&(jl->j_commit_left)); + /* once for journal_find_get_block */ + put_bh(tbh); + /* once due to original getblk in do_journal_end */ + put_bh(tbh); + atomic_dec(&jl->j_commit_left); } - BUG_ON(atomic_read(&(jl->j_commit_left)) != 1); + BUG_ON(atomic_read(&jl->j_commit_left) != 1); - /* If there was a write error in the journal - we can't commit + /* + * If there was a write error in the journal - we can't commit * this transaction - it will be invalid and, if successful, * will just end up propagating the write error out to - * the file system. */ + * the file system. + */ if (likely(!retval && !reiserfs_is_journal_aborted (journal))) { if (buffer_dirty(jl->j_commit_bh)) BUG(); @@ -1102,9 +1117,11 @@ static int flush_commit_list(struct super_block *s, reiserfs_write_lock_nested(s, depth); } - /* If there was a write error in the journal - we can't commit this + /* + * If there was a write error in the journal - we can't commit this * transaction - it will be invalid and, if successful, will just end - * up propagating the write error out to the filesystem. */ + * up propagating the write error out to the filesystem. + */ if (unlikely(!buffer_uptodate(jl->j_commit_bh))) { #ifdef CONFIG_REISERFS_CHECK reiserfs_warning(s, "journal-615", "buffer write failed"); @@ -1119,7 +1136,10 @@ static int flush_commit_list(struct super_block *s, } journal->j_last_commit_id = jl->j_trans_id; - /* now, every commit block is on the disk. It is safe to allow blocks freed during this transaction to be reallocated */ + /* + * now, every commit block is on the disk. It is safe to allow + * blocks freed during this transaction to be reallocated + */ cleanup_freed_for_journal_list(s, jl); retval = retval ? retval : journal->j_errno; @@ -1127,13 +1147,13 @@ static int flush_commit_list(struct super_block *s, /* mark the metadata dirty */ if (!retval) dirty_one_transaction(s, jl); - atomic_dec(&(jl->j_commit_left)); + atomic_dec(&jl->j_commit_left); if (flushall) { - atomic_set(&(jl->j_older_commits_done), 1); + atomic_set(&jl->j_older_commits_done, 1); } mutex_unlock(&jl->j_commit_mutex); - put_jl: +put_jl: put_journal_list(s, jl); if (retval) @@ -1143,9 +1163,9 @@ static int flush_commit_list(struct super_block *s, } /* -** flush_journal_list frequently needs to find a newer transaction for a given block. This does that, or -** returns NULL if it can't find anything -*/ + * flush_journal_list frequently needs to find a newer transaction for a + * given block. This does that, or returns NULL if it can't find anything + */ static struct reiserfs_journal_list *find_newer_jl_for_cn(struct reiserfs_journal_cnode *cn) @@ -1163,31 +1183,17 @@ static struct reiserfs_journal_list *find_newer_jl_for_cn(struct return NULL; } -static int newer_jl_done(struct reiserfs_journal_cnode *cn) -{ - struct super_block *sb = cn->sb; - b_blocknr_t blocknr = cn->blocknr; - - cn = cn->hprev; - while (cn) { - if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist && - atomic_read(&cn->jlist->j_commit_left) != 0) - return 0; - cn = cn->hprev; - } - return 1; -} - static void remove_journal_hash(struct super_block *, struct reiserfs_journal_cnode **, struct reiserfs_journal_list *, unsigned long, int); /* -** once all the real blocks have been flushed, it is safe to remove them from the -** journal list for this transaction. Aside from freeing the cnode, this also allows the -** block to be reallocated for data blocks if it had been deleted. -*/ + * once all the real blocks have been flushed, it is safe to remove them + * from the journal list for this transaction. Aside from freeing the + * cnode, this also allows the block to be reallocated for data blocks + * if it had been deleted. + */ static void remove_all_from_journal_list(struct super_block *sb, struct reiserfs_journal_list *jl, int debug) @@ -1196,8 +1202,9 @@ static void remove_all_from_journal_list(struct super_block *sb, struct reiserfs_journal_cnode *cn, *last; cn = jl->j_realblock; - /* which is better, to lock once around the whole loop, or - ** to lock for each call to remove_journal_hash? + /* + * which is better, to lock once around the whole loop, or + * to lock for each call to remove_journal_hash? */ while (cn) { if (cn->blocknr != 0) { @@ -1219,12 +1226,13 @@ static void remove_all_from_journal_list(struct super_block *sb, } /* -** if this timestamp is greater than the timestamp we wrote last to the header block, write it to the header block. -** once this is done, I can safely say the log area for this transaction won't ever be replayed, and I can start -** releasing blocks in this transaction for reuse as data blocks. -** called by flush_journal_list, before it calls remove_all_from_journal_list -** -*/ + * if this timestamp is greater than the timestamp we wrote last to the + * header block, write it to the header block. once this is done, I can + * safely say the log area for this transaction won't ever be replayed, + * and I can start releasing blocks in this transaction for reuse as data + * blocks. called by flush_journal_list, before it calls + * remove_all_from_journal_list + */ static int _update_journal_header_block(struct super_block *sb, unsigned long offset, unsigned int trans_id) @@ -1294,10 +1302,11 @@ static int flush_older_journal_lists(struct super_block *sb, struct reiserfs_journal *journal = SB_JOURNAL(sb); unsigned int trans_id = jl->j_trans_id; - /* we know we are the only ones flushing things, no extra race + /* + * we know we are the only ones flushing things, no extra race * protection is required. */ - restart: +restart: entry = journal->j_journal_list.next; /* Did we wrap? */ if (entry == &journal->j_journal_list) @@ -1324,15 +1333,16 @@ static void del_from_work_list(struct super_block *s, } } -/* flush a journal list, both commit and real blocks -** -** always set flushall to 1, unless you are calling from inside -** flush_journal_list -** -** IMPORTANT. This can only be called while there are no journal writers, -** and the journal is locked. That means it can only be called from -** do_journal_end, or by journal_release -*/ +/* + * flush a journal list, both commit and real blocks + * + * always set flushall to 1, unless you are calling from inside + * flush_journal_list + * + * IMPORTANT. This can only be called while there are no journal writers, + * and the journal is locked. That means it can only be called from + * do_journal_end, or by journal_release + */ static int flush_journal_list(struct super_block *s, struct reiserfs_journal_list *jl, int flushall) { @@ -1353,7 +1363,6 @@ static int flush_journal_list(struct super_block *s, reiserfs_warning(s, "clm-2048", "called with wcount %d", atomic_read(&journal->j_wcount)); } - BUG_ON(jl->j_trans_id == 0); /* if flushall == 0, the lock is already held */ if (flushall) { @@ -1370,13 +1379,14 @@ static int flush_journal_list(struct super_block *s, } /* if all the work is already done, get out of here */ - if (atomic_read(&(jl->j_nonzerolen)) <= 0 && - atomic_read(&(jl->j_commit_left)) <= 0) { + if (atomic_read(&jl->j_nonzerolen) <= 0 && + atomic_read(&jl->j_commit_left) <= 0) { goto flush_older_and_return; } - /* start by putting the commit list on disk. This will also flush - ** the commit lists of any olders transactions + /* + * start by putting the commit list on disk. This will also flush + * the commit lists of any olders transactions */ flush_commit_list(s, jl, 1); @@ -1385,15 +1395,16 @@ static int flush_journal_list(struct super_block *s, BUG(); /* are we done now? */ - if (atomic_read(&(jl->j_nonzerolen)) <= 0 && - atomic_read(&(jl->j_commit_left)) <= 0) { + if (atomic_read(&jl->j_nonzerolen) <= 0 && + atomic_read(&jl->j_commit_left) <= 0) { goto flush_older_and_return; } - /* loop through each cnode, see if we need to write it, - ** or wait on a more recent transaction, or just ignore it + /* + * loop through each cnode, see if we need to write it, + * or wait on a more recent transaction, or just ignore it */ - if (atomic_read(&(journal->j_wcount)) != 0) { + if (atomic_read(&journal->j_wcount) != 0) { reiserfs_panic(s, "journal-844", "journal list is flushing, " "wcount is not 0"); } @@ -1407,20 +1418,25 @@ static int flush_journal_list(struct super_block *s, goto free_cnode; } - /* This transaction failed commit. Don't write out to the disk */ + /* + * This transaction failed commit. + * Don't write out to the disk + */ if (!(jl->j_state & LIST_DIRTY)) goto free_cnode; pjl = find_newer_jl_for_cn(cn); - /* the order is important here. We check pjl to make sure we - ** don't clear BH_JDirty_wait if we aren't the one writing this - ** block to disk + /* + * the order is important here. We check pjl to make sure we + * don't clear BH_JDirty_wait if we aren't the one writing this + * block to disk */ if (!pjl && cn->bh) { saved_bh = cn->bh; - /* we do this to make sure nobody releases the buffer while - ** we are working with it + /* + * we do this to make sure nobody releases the + * buffer while we are working with it */ get_bh(saved_bh); @@ -1429,13 +1445,17 @@ static int flush_journal_list(struct super_block *s, was_jwait = 1; was_dirty = 1; } else if (can_dirty(cn)) { - /* everything with !pjl && jwait should be writable */ + /* + * everything with !pjl && jwait + * should be writable + */ BUG(); } } - /* if someone has this block in a newer transaction, just make - ** sure they are committed, and don't try writing it to disk + /* + * if someone has this block in a newer transaction, just make + * sure they are committed, and don't try writing it to disk */ if (pjl) { if (atomic_read(&pjl->j_commit_left)) @@ -1443,16 +1463,18 @@ static int flush_journal_list(struct super_block *s, goto free_cnode; } - /* bh == NULL when the block got to disk on its own, OR, - ** the block got freed in a future transaction + /* + * bh == NULL when the block got to disk on its own, OR, + * the block got freed in a future transaction */ if (saved_bh == NULL) { goto free_cnode; } - /* this should never happen. kupdate_one_transaction has this list - ** locked while it works, so we should never see a buffer here that - ** is not marked JDirty_wait + /* + * this should never happen. kupdate_one_transaction has + * this list locked while it works, so we should never see a + * buffer here that is not marked JDirty_wait */ if ((!was_jwait) && !buffer_locked(saved_bh)) { reiserfs_warning(s, "journal-813", @@ -1463,7 +1485,10 @@ static int flush_journal_list(struct super_block *s, was_jwait ? ' ' : '!'); } if (was_dirty) { - /* we inc again because saved_bh gets decremented at free_cnode */ + /* + * we inc again because saved_bh gets decremented + * at free_cnode + */ get_bh(saved_bh); set_bit(BLOCK_NEEDS_FLUSH, &cn->state); lock_buffer(saved_bh); @@ -1479,13 +1504,16 @@ static int flush_journal_list(struct super_block *s, (unsigned long long)saved_bh-> b_blocknr, __func__); } - free_cnode: +free_cnode: last = cn; cn = cn->next; if (saved_bh) { - /* we incremented this to keep others from taking the buffer head away */ + /* + * we incremented this to keep others from + * taking the buffer head away + */ put_bh(saved_bh); - if (atomic_read(&(saved_bh->b_count)) < 0) { + if (atomic_read(&saved_bh->b_count) < 0) { reiserfs_warning(s, "journal-945", "saved_bh->b_count < 0"); } @@ -1515,8 +1543,10 @@ static int flush_journal_list(struct super_block *s, #endif err = -EIO; } - /* note, we must clear the JDirty_wait bit after the up to date - ** check, otherwise we race against our flushpage routine + /* + * note, we must clear the JDirty_wait bit + * after the up to date check, otherwise we + * race against our flushpage routine */ BUG_ON(!test_clear_buffer_journal_dirty (cn->bh)); @@ -1534,25 +1564,27 @@ static int flush_journal_list(struct super_block *s, reiserfs_abort(s, -EIO, "Write error while pushing transaction to disk in %s", __func__); - flush_older_and_return: +flush_older_and_return: - /* before we can update the journal header block, we _must_ flush all - ** real blocks from all older transactions to disk. This is because - ** once the header block is updated, this transaction will not be - ** replayed after a crash + /* + * before we can update the journal header block, we _must_ flush all + * real blocks from all older transactions to disk. This is because + * once the header block is updated, this transaction will not be + * replayed after a crash */ if (flushall) { flush_older_journal_lists(s, jl); } err = journal->j_errno; - /* before we can remove everything from the hash tables for this - ** transaction, we must make sure it can never be replayed - ** - ** since we are only called from do_journal_end, we know for sure there - ** are no allocations going on while we are flushing journal lists. So, - ** we only need to update the journal header block for the last list - ** being flushed + /* + * before we can remove everything from the hash tables for this + * transaction, we must make sure it can never be replayed + * + * since we are only called from do_journal_end, we know for sure there + * are no allocations going on while we are flushing journal lists. So, + * we only need to update the journal header block for the last list + * being flushed */ if (!err && flushall) { err = @@ -1577,11 +1609,12 @@ static int flush_journal_list(struct super_block *s, } journal->j_last_flush_id = jl->j_trans_id; - /* not strictly required since we are freeing the list, but it should + /* + * not strictly required since we are freeing the list, but it should * help find code using dead lists later on */ jl->j_len = 0; - atomic_set(&(jl->j_nonzerolen), 0); + atomic_set(&jl->j_nonzerolen, 0); jl->j_start = 0; jl->j_realblock = NULL; jl->j_commit_bh = NULL; @@ -1593,31 +1626,6 @@ static int flush_journal_list(struct super_block *s, return err; } -static int test_transaction(struct super_block *s, - struct reiserfs_journal_list *jl) -{ - struct reiserfs_journal_cnode *cn; - - if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) - return 1; - - cn = jl->j_realblock; - while (cn) { - /* if the blocknr == 0, this has been cleared from the hash, - ** skip it - */ - if (cn->blocknr == 0) { - goto next; - } - if (cn->bh && !newer_jl_done(cn)) - return 0; - next: - cn = cn->next; - cond_resched(); - } - return 0; -} - static int write_one_transaction(struct super_block *s, struct reiserfs_journal_list *jl, struct buffer_chunk *chunk) @@ -1633,15 +1641,17 @@ static int write_one_transaction(struct super_block *s, cn = jl->j_realblock; while (cn) { - /* if the blocknr == 0, this has been cleared from the hash, - ** skip it + /* + * if the blocknr == 0, this has been cleared from the hash, + * skip it */ if (cn->blocknr == 0) { goto next; } if (cn->bh && can_dirty(cn) && buffer_dirty(cn->bh)) { struct buffer_head *tmp_bh; - /* we can race against journal_mark_freed when we try + /* + * we can race against journal_mark_freed when we try * to lock_buffer(cn->bh), so we have to inc the buffer * count, and recheck things after locking */ @@ -1660,7 +1670,7 @@ static int write_one_transaction(struct super_block *s, } put_bh(tmp_bh); } - next: +next: cn = cn->next; cond_resched(); } @@ -1678,15 +1688,17 @@ static int dirty_one_transaction(struct super_block *s, jl->j_state |= LIST_DIRTY; cn = jl->j_realblock; while (cn) { - /* look for a more recent transaction that logged this - ** buffer. Only the most recent transaction with a buffer in - ** it is allowed to send that buffer to disk + /* + * look for a more recent transaction that logged this + * buffer. Only the most recent transaction with a buffer in + * it is allowed to send that buffer to disk */ pjl = find_newer_jl_for_cn(cn); if (!pjl && cn->blocknr && cn->bh && buffer_journal_dirty(cn->bh)) { BUG_ON(!can_dirty(cn)); - /* if the buffer is prepared, it will either be logged + /* + * if the buffer is prepared, it will either be logged * or restored. If restored, we need to make sure * it actually gets marked dirty */ @@ -1723,7 +1735,8 @@ static int kupdate_transactions(struct super_block *s, goto done; } - /* we've got j_flush_mutex held, nobody is going to delete any + /* + * we've got j_flush_mutex held, nobody is going to delete any * of these lists out from underneath us */ while ((num_trans && transactions_flushed < num_trans) || @@ -1757,20 +1770,21 @@ static int kupdate_transactions(struct super_block *s, write_chunk(&chunk); } - done: +done: mutex_unlock(&journal->j_flush_mutex); return ret; } -/* for o_sync and fsync heavy applications, they tend to use -** all the journa list slots with tiny transactions. These -** trigger lots and lots of calls to update the header block, which -** adds seeks and slows things down. -** -** This function tries to clear out a large chunk of the journal lists -** at once, which makes everything faster since only the newest journal -** list updates the header block -*/ +/* + * for o_sync and fsync heavy applications, they tend to use + * all the journa list slots with tiny transactions. These + * trigger lots and lots of calls to update the header block, which + * adds seeks and slows things down. + * + * This function tries to clear out a large chunk of the journal lists + * at once, which makes everything faster since only the newest journal + * list updates the header block + */ static int flush_used_journal_lists(struct super_block *s, struct reiserfs_journal_list *jl) { @@ -1805,21 +1819,27 @@ static int flush_used_journal_lists(struct super_block *s, break; tjl = JOURNAL_LIST_ENTRY(tjl->j_list.next); } - /* try to find a group of blocks we can flush across all the - ** transactions, but only bother if we've actually spanned - ** across multiple lists + get_journal_list(jl); + get_journal_list(flush_jl); + + /* + * try to find a group of blocks we can flush across all the + * transactions, but only bother if we've actually spanned + * across multiple lists */ if (flush_jl != jl) { ret = kupdate_transactions(s, jl, &tjl, &trans_id, len, i); } flush_journal_list(s, flush_jl, 1); + put_journal_list(s, flush_jl); + put_journal_list(s, jl); return 0; } /* -** removes any nodes in table with name block and dev as bh. -** only touchs the hnext and hprev pointers. -*/ + * removes any nodes in table with name block and dev as bh. + * only touchs the hnext and hprev pointers. + */ void remove_journal_hash(struct super_block *sb, struct reiserfs_journal_cnode **table, struct reiserfs_journal_list *jl, @@ -1848,8 +1868,12 @@ void remove_journal_hash(struct super_block *sb, cur->blocknr = 0; cur->sb = NULL; cur->state = 0; - if (cur->bh && cur->jlist) /* anybody who clears the cur->bh will also dec the nonzerolen */ - atomic_dec(&(cur->jlist->j_nonzerolen)); + /* + * anybody who clears the cur->bh will also + * dec the nonzerolen + */ + if (cur->bh && cur->jlist) + atomic_dec(&cur->jlist->j_nonzerolen); cur->bh = NULL; cur->jlist = NULL; } @@ -1869,17 +1893,18 @@ static void free_journal_ram(struct super_block *sb) if (journal->j_header_bh) { brelse(journal->j_header_bh); } - /* j_header_bh is on the journal dev, make sure not to release the journal - * dev until we brelse j_header_bh + /* + * j_header_bh is on the journal dev, make sure + * not to release the journal dev until we brelse j_header_bh */ release_journal_dev(sb, journal); vfree(journal); } /* -** call on unmount. Only set error to 1 if you haven't made your way out -** of read_super() yet. Any other caller must keep error at 0. -*/ + * call on unmount. Only set error to 1 if you haven't made your way out + * of read_super() yet. Any other caller must keep error at 0. + */ static int do_journal_release(struct reiserfs_transaction_handle *th, struct super_block *sb, int error) { @@ -1887,21 +1912,25 @@ static int do_journal_release(struct reiserfs_transaction_handle *th, int flushed = 0; struct reiserfs_journal *journal = SB_JOURNAL(sb); - /* we only want to flush out transactions if we were called with error == 0 + /* + * we only want to flush out transactions if we were + * called with error == 0 */ if (!error && !(sb->s_flags & MS_RDONLY)) { /* end the current trans */ BUG_ON(!th->t_trans_id); - do_journal_end(th, sb, 10, FLUSH_ALL); + do_journal_end(th, FLUSH_ALL); - /* make sure something gets logged to force our way into the flush code */ - if (!journal_join(&myth, sb, 1)) { + /* + * make sure something gets logged to force + * our way into the flush code + */ + if (!journal_join(&myth, sb)) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(&myth, sb, - SB_BUFFER_WITH_SB(sb)); - do_journal_end(&myth, sb, 1, FLUSH_ALL); + journal_mark_dirty(&myth, SB_BUFFER_WITH_SB(sb)); + do_journal_end(&myth, FLUSH_ALL); flushed = 1; } } @@ -1909,17 +1938,15 @@ static int do_journal_release(struct reiserfs_transaction_handle *th, /* this also catches errors during the do_journal_end above */ if (!error && reiserfs_is_journal_aborted(journal)) { memset(&myth, 0, sizeof(myth)); - if (!journal_join_abort(&myth, sb, 1)) { + if (!journal_join_abort(&myth, sb)) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(&myth, sb, - SB_BUFFER_WITH_SB(sb)); - do_journal_end(&myth, sb, 1, FLUSH_ALL); + journal_mark_dirty(&myth, SB_BUFFER_WITH_SB(sb)); + do_journal_end(&myth, FLUSH_ALL); } } - reiserfs_mounted_fs_count--; /* wait for all commits to finish */ cancel_delayed_work(&SB_JOURNAL(sb)->j_work); @@ -1930,12 +1957,7 @@ static int do_journal_release(struct reiserfs_transaction_handle *th, reiserfs_write_unlock(sb); cancel_delayed_work_sync(&REISERFS_SB(sb)->old_work); - flush_workqueue(commit_wq); - - if (!reiserfs_mounted_fs_count) { - destroy_workqueue(commit_wq); - commit_wq = NULL; - } + flush_workqueue(REISERFS_SB(sb)->commit_wq); free_journal_ram(sb); @@ -1944,25 +1966,24 @@ static int do_journal_release(struct reiserfs_transaction_handle *th, return 0; } -/* -** call on unmount. flush all journal trans, release all alloc'd ram -*/ +/* * call on unmount. flush all journal trans, release all alloc'd ram */ int journal_release(struct reiserfs_transaction_handle *th, struct super_block *sb) { return do_journal_release(th, sb, 0); } -/* -** only call from an error condition inside reiserfs_read_super! -*/ +/* only call from an error condition inside reiserfs_read_super! */ int journal_release_error(struct reiserfs_transaction_handle *th, struct super_block *sb) { return do_journal_release(th, sb, 1); } -/* compares description block with commit block. returns 1 if they differ, 0 if they are the same */ +/* + * compares description block with commit block. + * returns 1 if they differ, 0 if they are the same + */ static int journal_compare_desc_commit(struct super_block *sb, struct reiserfs_journal_desc *desc, struct reiserfs_journal_commit *commit) @@ -1976,11 +1997,12 @@ static int journal_compare_desc_commit(struct super_block *sb, return 0; } -/* returns 0 if it did not find a description block -** returns -1 if it found a corrupt commit block -** returns 1 if both desc and commit were valid -** NOTE: only called during fs mount -*/ +/* + * returns 0 if it did not find a description block + * returns -1 if it found a corrupt commit block + * returns 1 if both desc and commit were valid + * NOTE: only called during fs mount + */ static int journal_transaction_is_valid(struct super_block *sb, struct buffer_head *d_bh, unsigned int *oldest_invalid_trans_id, @@ -2026,7 +2048,10 @@ static int journal_transaction_is_valid(struct super_block *sb, } offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb); - /* ok, we have a journal description block, lets see if the transaction was valid */ + /* + * ok, we have a journal description block, + * let's see if the transaction was valid + */ c_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) + @@ -2078,11 +2103,11 @@ static void brelse_array(struct buffer_head **heads, int num) } /* -** given the start, and values for the oldest acceptable transactions, -** this either reads in a replays a transaction, or returns because the -** transaction is invalid, or too old. -** NOTE: only called during fs mount -*/ + * given the start, and values for the oldest acceptable transactions, + * this either reads in a replays a transaction, or returns because the + * transaction is invalid, or too old. + * NOTE: only called during fs mount + */ static int journal_read_transaction(struct super_block *sb, unsigned long cur_dblock, unsigned long oldest_start, @@ -2156,7 +2181,10 @@ static int journal_read_transaction(struct super_block *sb, } trans_id = get_desc_trans_id(desc); - /* now we know we've got a good transaction, and it was inside the valid time ranges */ + /* + * now we know we've got a good transaction, and it was + * inside the valid time ranges + */ log_blocks = kmalloc(get_desc_trans_len(desc) * sizeof(struct buffer_head *), GFP_NOFS); real_blocks = kmalloc(get_desc_trans_len(desc) * @@ -2201,7 +2229,7 @@ static int journal_read_transaction(struct super_block *sb, reiserfs_warning(sb, "journal-1204", "REPLAY FAILURE fsck required! " "Trying to replay onto a log block"); - abort_replay: +abort_replay: brelse_array(log_blocks, i); brelse_array(real_blocks, i); brelse(c_bh); @@ -2263,7 +2291,10 @@ static int journal_read_transaction(struct super_block *sb, "journal-1095: setting journal " "start to offset %ld", cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb)); - /* init starting values for the first transaction, in case this is the last transaction to be replayed. */ + /* + * init starting values for the first transaction, in case + * this is the last transaction to be replayed. + */ journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb); journal->j_last_flush_trans_id = trans_id; journal->j_trans_id = trans_id + 1; @@ -2277,12 +2308,14 @@ static int journal_read_transaction(struct super_block *sb, return 0; } -/* This function reads blocks starting from block and to max_block of bufsize - size (but no more than BUFNR blocks at a time). This proved to improve - mounting speed on self-rebuilding raid5 arrays at least. - Right now it is only used from journal code. But later we might use it - from other places. - Note: Do not use journal_getblk/sb_getblk functions here! */ +/* + * This function reads blocks starting from block and to max_block of bufsize + * size (but no more than BUFNR blocks at a time). This proved to improve + * mounting speed on self-rebuilding raid5 arrays at least. + * Right now it is only used from journal code. But later we might use it + * from other places. + * Note: Do not use journal_getblk/sb_getblk functions here! + */ static struct buffer_head *reiserfs_breada(struct block_device *dev, b_blocknr_t block, int bufsize, b_blocknr_t max_block) @@ -2321,15 +2354,17 @@ static struct buffer_head *reiserfs_breada(struct block_device *dev, } /* -** read and replay the log -** on a clean unmount, the journal header's next unflushed pointer will -** be to an invalid transaction. This tests that before finding all the -** transactions in the log, which makes normal mount times fast. -** After a crash, this starts with the next unflushed transaction, and -** replays until it finds one too old, or invalid. -** On exit, it sets things up so the first transaction will work correctly. -** NOTE: only called during fs mount -*/ + * read and replay the log + * on a clean unmount, the journal header's next unflushed pointer will be + * to an invalid transaction. This tests that before finding all the + * transactions in the log, which makes normal mount times fast. + * + * After a crash, this starts with the next unflushed transaction, and + * replays until it finds one too old, or invalid. + * + * On exit, it sets things up so the first transaction will work correctly. + * NOTE: only called during fs mount + */ static int journal_read(struct super_block *sb) { struct reiserfs_journal *journal = SB_JOURNAL(sb); @@ -2353,9 +2388,10 @@ static int journal_read(struct super_block *sb) bdevname(journal->j_dev_bd, b)); start = get_seconds(); - /* step 1, read in the journal header block. Check the transaction it says - ** is the first unflushed, and if that transaction is not valid, - ** replay is done + /* + * step 1, read in the journal header block. Check the transaction + * it says is the first unflushed, and if that transaction is not + * valid, replay is done */ journal->j_header_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) @@ -2379,9 +2415,10 @@ static int journal_read(struct super_block *sb) le32_to_cpu(jh->j_last_flush_trans_id)); valid_journal_header = 1; - /* now, we try to read the first unflushed offset. If it is not valid, - ** there is nothing more we can do, and it makes no sense to read - ** through the whole log. + /* + * now, we try to read the first unflushed offset. If it + * is not valid, there is nothing more we can do, and it + * makes no sense to read through the whole log. */ d_bh = journal_bread(sb, @@ -2395,15 +2432,19 @@ static int journal_read(struct super_block *sb) goto start_log_replay; } - /* ok, there are transactions that need to be replayed. start with the first log block, find - ** all the valid transactions, and pick out the oldest. + /* + * ok, there are transactions that need to be replayed. start + * with the first log block, find all the valid transactions, and + * pick out the oldest. */ while (continue_replay && cur_dblock < (SB_ONDISK_JOURNAL_1st_BLOCK(sb) + SB_ONDISK_JOURNAL_SIZE(sb))) { - /* Note that it is required for blocksize of primary fs device and journal - device to be the same */ + /* + * Note that it is required for blocksize of primary fs + * device and journal device to be the same + */ d_bh = reiserfs_breada(journal->j_dev_bd, cur_dblock, sb->s_blocksize, @@ -2450,7 +2491,7 @@ static int journal_read(struct super_block *sb) brelse(d_bh); } - start_log_replay: +start_log_replay: cur_dblock = oldest_start; if (oldest_trans_id) { reiserfs_debug(sb, REISERFS_DEBUG_CODE, @@ -2481,9 +2522,11 @@ static int journal_read(struct super_block *sb) reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1225: No valid " "transactions found"); } - /* j_start does not get set correctly if we don't replay any transactions. - ** if we had a valid journal_header, set j_start to the first unflushed transaction value, - ** copy the trans_id from the header + /* + * j_start does not get set correctly if we don't replay any + * transactions. if we had a valid journal_header, set j_start + * to the first unflushed transaction value, copy the trans_id + * from the header */ if (valid_journal_header && replay_count == 0) { journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset); @@ -2512,8 +2555,9 @@ static int journal_read(struct super_block *sb) _update_journal_header_block(sb, journal->j_start, journal->j_last_flush_trans_id)) { reiserfs_write_unlock(sb); - /* replay failed, caller must call free_journal_ram and abort - ** the mount + /* + * replay failed, caller must call free_journal_ram and abort + * the mount */ return -1; } @@ -2606,7 +2650,7 @@ static int journal_init_dev(struct super_block *super, return 0; } -/** +/* * When creating/tuning a file system user can assign some * journal params within boundaries which depend on the ratio * blocksize/standard_blocksize. @@ -2624,8 +2668,7 @@ static int check_advise_trans_params(struct super_block *sb, struct reiserfs_journal *journal) { if (journal->j_trans_max) { - /* Non-default journal params. - Do sanity check for them. */ + /* Non-default journal params. Do sanity check for them. */ int ratio = 1; if (sb->s_blocksize < REISERFS_STANDARD_BLKSIZE) ratio = REISERFS_STANDARD_BLKSIZE / sb->s_blocksize; @@ -2647,10 +2690,12 @@ static int check_advise_trans_params(struct super_block *sb, return 1; } } else { - /* Default journal params. - The file system was created by old version - of mkreiserfs, so some fields contain zeros, - and we need to advise proper values for them */ + /* + * Default journal params. + * The file system was created by old version + * of mkreiserfs, so some fields contain zeros, + * and we need to advise proper values for them + */ if (sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) { reiserfs_warning(sb, "sh-464", "bad blocksize (%u)", sb->s_blocksize); @@ -2663,9 +2708,7 @@ static int check_advise_trans_params(struct super_block *sb, return 0; } -/* -** must be called once on fs mount. calls journal_read for you -*/ +/* must be called once on fs mount. calls journal_read for you */ int journal_init(struct super_block *sb, const char *j_dev_name, int old_format, unsigned int commit_max_age) { @@ -2704,8 +2747,10 @@ int journal_init(struct super_block *sb, const char *j_dev_name, REISERFS_DISK_OFFSET_IN_BYTES / sb->s_blocksize + 2); - /* Sanity check to see is the standard journal fitting within first bitmap - (actual for small blocksizes) */ + /* + * Sanity check to see is the standard journal fitting + * within first bitmap (actual for small blocksizes) + */ if (!SB_ONDISK_JOURNAL_DEVICE(sb) && (SB_JOURNAL_1st_RESERVED_BLOCK(sb) + SB_ONDISK_JOURNAL_SIZE(sb) > sb->s_blocksize * 8)) { @@ -2791,20 +2836,20 @@ int journal_init(struct super_block *sb, const char *j_dev_name, journal->j_start = 0; journal->j_len = 0; journal->j_len_alloc = 0; - atomic_set(&(journal->j_wcount), 0); - atomic_set(&(journal->j_async_throttle), 0); + atomic_set(&journal->j_wcount, 0); + atomic_set(&journal->j_async_throttle, 0); journal->j_bcount = 0; journal->j_trans_start_time = 0; journal->j_last = NULL; journal->j_first = NULL; - init_waitqueue_head(&(journal->j_join_wait)); + init_waitqueue_head(&journal->j_join_wait); mutex_init(&journal->j_mutex); mutex_init(&journal->j_flush_mutex); journal->j_trans_id = 10; journal->j_mount_id = 10; journal->j_state = 0; - atomic_set(&(journal->j_jlock), 0); + atomic_set(&journal->j_jlock, 0); journal->j_cnode_free_list = allocate_cnodes(num_cnodes); journal->j_cnode_free_orig = journal->j_cnode_free_list; journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0; @@ -2844,23 +2889,19 @@ int journal_init(struct super_block *sb, const char *j_dev_name, goto free_and_return; } - reiserfs_mounted_fs_count++; - if (reiserfs_mounted_fs_count <= 1) - commit_wq = alloc_workqueue("reiserfs", WQ_MEM_RECLAIM, 0); - INIT_DELAYED_WORK(&journal->j_work, flush_async_commits); journal->j_work_sb = sb; return 0; - free_and_return: +free_and_return: free_journal_ram(sb); return 1; } /* -** test for a polite end of the current transaction. Used by file_write, and should -** be used by delete to make sure they don't write more than can fit inside a single -** transaction -*/ + * test for a polite end of the current transaction. Used by file_write, + * and should be used by delete to make sure they don't write more than + * can fit inside a single transaction + */ int journal_transaction_should_end(struct reiserfs_transaction_handle *th, int new_alloc) { @@ -2872,7 +2913,7 @@ int journal_transaction_should_end(struct reiserfs_transaction_handle *th, return 0; if (journal->j_must_wait > 0 || (journal->j_len_alloc + new_alloc) >= journal->j_max_batch || - atomic_read(&(journal->j_jlock)) || + atomic_read(&journal->j_jlock) || (now - journal->j_trans_start_time) > journal->j_max_trans_age || journal->j_cnode_free < (journal->j_trans_max * 3)) { return 1; @@ -2883,8 +2924,7 @@ int journal_transaction_should_end(struct reiserfs_transaction_handle *th, return 0; } -/* this must be called inside a transaction -*/ +/* this must be called inside a transaction */ void reiserfs_block_writes(struct reiserfs_transaction_handle *th) { struct reiserfs_journal *journal = SB_JOURNAL(th->t_super); @@ -2894,8 +2934,7 @@ void reiserfs_block_writes(struct reiserfs_transaction_handle *th) return; } -/* this must be called without a transaction started -*/ +/* this must be called without a transaction started */ void reiserfs_allow_writes(struct super_block *s) { struct reiserfs_journal *journal = SB_JOURNAL(s); @@ -2903,8 +2942,7 @@ void reiserfs_allow_writes(struct super_block *s) wake_up(&journal->j_join_wait); } -/* this must be called without a transaction started -*/ +/* this must be called without a transaction started */ void reiserfs_wait_on_write_block(struct super_block *s) { struct reiserfs_journal *journal = SB_JOURNAL(s); @@ -2966,11 +3004,12 @@ static void let_transaction_grow(struct super_block *sb, unsigned int trans_id) } } -/* join == true if you must join an existing transaction. -** join == false if you can deal with waiting for others to finish -** -** this will block until the transaction is joinable. send the number of blocks you -** expect to use in nblocks. +/* + * join == true if you must join an existing transaction. + * join == false if you can deal with waiting for others to finish + * + * this will block until the transaction is joinable. send the number of + * blocks you expect to use in nblocks. */ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, struct super_block *sb, unsigned long nblocks, @@ -2992,7 +3031,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, th->t_refcount = 1; th->t_super = sb; - relock: +relock: lock_journal(sb); if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) { unlock_journal(sb); @@ -3011,9 +3050,11 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, } now = get_seconds(); - /* if there is no room in the journal OR - ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning - ** we don't sleep if there aren't other writers + /* + * if there is no room in the journal OR + * if this transaction is too old, and we weren't called joinable, + * wait for it to finish before beginning we don't sleep if there + * aren't other writers */ if ((!join && journal->j_must_wait > 0) || @@ -3027,7 +3068,8 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) { old_trans_id = journal->j_trans_id; - unlock_journal(sb); /* allow others to finish this transaction */ + /* allow others to finish this transaction */ + unlock_journal(sb); if (!join && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch && @@ -3039,8 +3081,9 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, goto relock; } } - /* don't mess with joining the transaction if all we have to do is - * wait for someone else to do a commit + /* + * don't mess with joining the transaction if all we + * have to do is wait for someone else to do a commit */ if (atomic_read(&journal->j_jlock)) { while (journal->j_trans_id == old_trans_id && @@ -3049,15 +3092,15 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, } goto relock; } - retval = journal_join(&myth, sb, 1); + retval = journal_join(&myth, sb); if (retval) goto out_fail; /* someone might have ended the transaction while we joined */ if (old_trans_id != journal->j_trans_id) { - retval = do_journal_end(&myth, sb, 1, 0); + retval = do_journal_end(&myth, 0); } else { - retval = do_journal_end(&myth, sb, 1, COMMIT_NOW); + retval = do_journal_end(&myth, COMMIT_NOW); } if (retval) @@ -3070,7 +3113,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, if (journal->j_trans_start_time == 0) { journal->j_trans_start_time = get_seconds(); } - atomic_inc(&(journal->j_wcount)); + atomic_inc(&journal->j_wcount); journal->j_len_alloc += nblocks; th->t_blocks_logged = 0; th->t_blocks_allocated = nblocks; @@ -3079,11 +3122,13 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th, INIT_LIST_HEAD(&th->t_list); return 0; - out_fail: +out_fail: memset(th, 0, sizeof(*th)); - /* Re-set th->t_super, so we can properly keep track of how many + /* + * Re-set th->t_super, so we can properly keep track of how many * persistent transactions there are. We need to do this so if this - * call is part of a failed restart_transaction, we can free it later */ + * call is part of a failed restart_transaction, we can free it later + */ th->t_super = sb; return retval; } @@ -3096,14 +3141,15 @@ struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct int ret; struct reiserfs_transaction_handle *th; - /* if we're nesting into an existing transaction. It will be - ** persistent on its own + /* + * if we're nesting into an existing transaction. It will be + * persistent on its own */ if (reiserfs_transaction_running(s)) { th = current->journal_info; th->t_refcount++; BUG_ON(th->t_refcount < 2); - + return th; } th = kmalloc(sizeof(struct reiserfs_transaction_handle), GFP_NOFS); @@ -3124,7 +3170,7 @@ int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th) struct super_block *s = th->t_super; int ret = 0; if (th->t_trans_id) - ret = journal_end(th, th->t_super, th->t_blocks_allocated); + ret = journal_end(th); else ret = -EIO; if (th->t_refcount == 0) { @@ -3135,29 +3181,31 @@ int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th) } static int journal_join(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks) + struct super_block *sb) { struct reiserfs_transaction_handle *cur_th = current->journal_info; - /* this keeps do_journal_end from NULLing out the current->journal_info - ** pointer + /* + * this keeps do_journal_end from NULLing out the + * current->journal_info pointer */ th->t_handle_save = cur_th; BUG_ON(cur_th && cur_th->t_refcount > 1); - return do_journal_begin_r(th, sb, nblocks, JBEGIN_JOIN); + return do_journal_begin_r(th, sb, 1, JBEGIN_JOIN); } int journal_join_abort(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks) + struct super_block *sb) { struct reiserfs_transaction_handle *cur_th = current->journal_info; - /* this keeps do_journal_end from NULLing out the current->journal_info - ** pointer + /* + * this keeps do_journal_end from NULLing out the + * current->journal_info pointer */ th->t_handle_save = cur_th; BUG_ON(cur_th && cur_th->t_refcount > 1); - return do_journal_begin_r(th, sb, nblocks, JBEGIN_ABORT); + return do_journal_begin_r(th, sb, 1, JBEGIN_ABORT); } int journal_begin(struct reiserfs_transaction_handle *th, @@ -3179,9 +3227,10 @@ int journal_begin(struct reiserfs_transaction_handle *th, "journal_info != 0"); return 0; } else { - /* we've ended up with a handle from a different filesystem. - ** save it and restore on journal_end. This should never - ** really happen... + /* + * we've ended up with a handle from a different + * filesystem. save it and restore on journal_end. + * This should never really happen... */ reiserfs_warning(sb, "clm-2100", "nesting info a different FS"); @@ -3194,9 +3243,10 @@ int journal_begin(struct reiserfs_transaction_handle *th, ret = do_journal_begin_r(th, sb, nblocks, JBEGIN_REG); BUG_ON(current->journal_info != th); - /* I guess this boils down to being the reciprocal of clm-2100 above. - * If do_journal_begin_r fails, we need to put it back, since journal_end - * won't be called to do it. */ + /* + * I guess this boils down to being the reciprocal of clm-2100 above. + * If do_journal_begin_r fails, we need to put it back, since + * journal_end won't be called to do it. */ if (ret) current->journal_info = th->t_handle_save; else @@ -3206,17 +3256,19 @@ int journal_begin(struct reiserfs_transaction_handle *th, } /* -** puts bh into the current transaction. If it was already there, reorders removes the -** old pointers from the hash, and puts new ones in (to make sure replay happen in the right order). -** -** if it was dirty, cleans and files onto the clean list. I can't let it be dirty again until the -** transaction is committed. -** -** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len. -*/ + * puts bh into the current transaction. If it was already there, reorders + * removes the old pointers from the hash, and puts new ones in (to make + * sure replay happen in the right order). + * + * if it was dirty, cleans and files onto the clean list. I can't let it + * be dirty again until the transaction is committed. + * + * if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len. + */ int journal_mark_dirty(struct reiserfs_transaction_handle *th, - struct super_block *sb, struct buffer_head *bh) + struct buffer_head *bh) { + struct super_block *sb = th->t_super; struct reiserfs_journal *journal = SB_JOURNAL(sb); struct reiserfs_journal_cnode *cn = NULL; int count_already_incd = 0; @@ -3238,9 +3290,10 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th, return 0; } - /* this must be turned into a panic instead of a warning. We can't allow - ** a dirty or journal_dirty or locked buffer to be logged, as some changes - ** could get to disk too early. NOT GOOD. + /* + * this must be turned into a panic instead of a warning. We can't + * allow a dirty or journal_dirty or locked buffer to be logged, as + * some changes could get to disk too early. NOT GOOD. */ if (!prepared || buffer_dirty(bh)) { reiserfs_warning(sb, "journal-1777", @@ -3253,14 +3306,16 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th, buffer_journal_dirty(bh) ? ' ' : '!'); } - if (atomic_read(&(journal->j_wcount)) <= 0) { + if (atomic_read(&journal->j_wcount) <= 0) { reiserfs_warning(sb, "journal-1409", "returning because j_wcount was %d", - atomic_read(&(journal->j_wcount))); + atomic_read(&journal->j_wcount)); return 1; } - /* this error means I've screwed up, and we've overflowed the transaction. - ** Nothing can be done here, except make the FS readonly or panic. + /* + * this error means I've screwed up, and we've overflowed + * the transaction. Nothing can be done here, except make the + * FS readonly or panic. */ if (journal->j_len >= journal->j_trans_max) { reiserfs_panic(th->t_super, "journal-1413", @@ -3317,9 +3372,9 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th, return 0; } -int journal_end(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks) +int journal_end(struct reiserfs_transaction_handle *th) { + struct super_block *sb = th->t_super; if (!current->journal_info && th->t_refcount > 1) reiserfs_warning(sb, "REISER-NESTING", "th NULL, refcount %d", th->t_refcount); @@ -3334,8 +3389,9 @@ int journal_end(struct reiserfs_transaction_handle *th, struct reiserfs_transaction_handle *cur_th = current->journal_info; - /* we aren't allowed to close a nested transaction on a different - ** filesystem from the one in the task struct + /* + * we aren't allowed to close a nested transaction on a + * different filesystem from the one in the task struct */ BUG_ON(cur_th->t_super != th->t_super); @@ -3345,17 +3401,18 @@ int journal_end(struct reiserfs_transaction_handle *th, } return 0; } else { - return do_journal_end(th, sb, nblocks, 0); + return do_journal_end(th, 0); } } -/* removes from the current transaction, relsing and descrementing any counters. -** also files the removed buffer directly onto the clean list -** -** called by journal_mark_freed when a block has been deleted -** -** returns 1 if it cleaned and relsed the buffer. 0 otherwise -*/ +/* + * removes from the current transaction, relsing and descrementing any counters. + * also files the removed buffer directly onto the clean list + * + * called by journal_mark_freed when a block has been deleted + * + * returns 1 if it cleaned and relsed the buffer. 0 otherwise + */ static int remove_from_transaction(struct super_block *sb, b_blocknr_t blocknr, int already_cleaned) { @@ -3391,7 +3448,7 @@ static int remove_from_transaction(struct super_block *sb, clear_buffer_dirty(bh); clear_buffer_journal_test(bh); put_bh(bh); - if (atomic_read(&(bh->b_count)) < 0) { + if (atomic_read(&bh->b_count) < 0) { reiserfs_warning(sb, "journal-1752", "b_count < 0"); } @@ -3404,15 +3461,16 @@ static int remove_from_transaction(struct super_block *sb, } /* -** for any cnode in a journal list, it can only be dirtied of all the -** transactions that include it are committed to disk. -** this checks through each transaction, and returns 1 if you are allowed to dirty, -** and 0 if you aren't -** -** it is called by dirty_journal_list, which is called after flush_commit_list has gotten all the log -** blocks for a given transaction on disk -** -*/ + * for any cnode in a journal list, it can only be dirtied of all the + * transactions that include it are committed to disk. + * this checks through each transaction, and returns 1 if you are allowed + * to dirty, and 0 if you aren't + * + * it is called by dirty_journal_list, which is called after + * flush_commit_list has gotten all the log blocks for a given + * transaction on disk + * + */ static int can_dirty(struct reiserfs_journal_cnode *cn) { struct super_block *sb = cn->sb; @@ -3420,9 +3478,10 @@ static int can_dirty(struct reiserfs_journal_cnode *cn) struct reiserfs_journal_cnode *cur = cn->hprev; int can_dirty = 1; - /* first test hprev. These are all newer than cn, so any node here - ** with the same block number and dev means this node can't be sent - ** to disk right now. + /* + * first test hprev. These are all newer than cn, so any node here + * with the same block number and dev means this node can't be sent + * to disk right now. */ while (cur && can_dirty) { if (cur->jlist && cur->bh && cur->blocknr && cur->sb == sb && @@ -3431,13 +3490,14 @@ static int can_dirty(struct reiserfs_journal_cnode *cn) } cur = cur->hprev; } - /* then test hnext. These are all older than cn. As long as they - ** are committed to the log, it is safe to write cn to disk + /* + * then test hnext. These are all older than cn. As long as they + * are committed to the log, it is safe to write cn to disk */ cur = cn->hnext; while (cur && can_dirty) { if (cur->jlist && cur->jlist->j_len > 0 && - atomic_read(&(cur->jlist->j_commit_left)) > 0 && cur->bh && + atomic_read(&cur->jlist->j_commit_left) > 0 && cur->bh && cur->blocknr && cur->sb == sb && cur->blocknr == blocknr) { can_dirty = 0; } @@ -3446,12 +3506,13 @@ static int can_dirty(struct reiserfs_journal_cnode *cn) return can_dirty; } -/* syncs the commit blocks, but does not force the real buffers to disk -** will wait until the current transaction is done/committed before returning -*/ -int journal_end_sync(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks) +/* + * syncs the commit blocks, but does not force the real buffers to disk + * will wait until the current transaction is done/committed before returning + */ +int journal_end_sync(struct reiserfs_transaction_handle *th) { + struct super_block *sb = th->t_super; struct reiserfs_journal *journal = SB_JOURNAL(sb); BUG_ON(!th->t_trans_id); @@ -3460,14 +3521,12 @@ int journal_end_sync(struct reiserfs_transaction_handle *th, if (journal->j_len == 0) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb)); + journal_mark_dirty(th, SB_BUFFER_WITH_SB(sb)); } - return do_journal_end(th, sb, nblocks, COMMIT_NOW | WAIT); + return do_journal_end(th, COMMIT_NOW | WAIT); } -/* -** writeback the pending async commits to disk -*/ +/* writeback the pending async commits to disk */ static void flush_async_commits(struct work_struct *work) { struct reiserfs_journal *journal = @@ -3487,9 +3546,9 @@ static void flush_async_commits(struct work_struct *work) } /* -** flushes any old transactions to disk -** ends the current transaction if it is too old -*/ + * flushes any old transactions to disk + * ends the current transaction if it is too old + */ void reiserfs_flush_old_commits(struct super_block *sb) { time_t now; @@ -3497,48 +3556,53 @@ void reiserfs_flush_old_commits(struct super_block *sb) struct reiserfs_journal *journal = SB_JOURNAL(sb); now = get_seconds(); - /* safety check so we don't flush while we are replaying the log during + /* + * safety check so we don't flush while we are replaying the log during * mount */ if (list_empty(&journal->j_journal_list)) return; - /* check the current transaction. If there are no writers, and it is + /* + * check the current transaction. If there are no writers, and it is * too old, finish it, and force the commit blocks to disk */ if (atomic_read(&journal->j_wcount) <= 0 && journal->j_trans_start_time > 0 && journal->j_len > 0 && (now - journal->j_trans_start_time) > journal->j_max_trans_age) { - if (!journal_join(&th, sb, 1)) { + if (!journal_join(&th, sb)) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(&th, sb, - SB_BUFFER_WITH_SB(sb)); + journal_mark_dirty(&th, SB_BUFFER_WITH_SB(sb)); - /* we're only being called from kreiserfsd, it makes no sense to do - ** an async commit so that kreiserfsd can do it later + /* + * we're only being called from kreiserfsd, it makes + * no sense to do an async commit so that kreiserfsd + * can do it later */ - do_journal_end(&th, sb, 1, COMMIT_NOW | WAIT); + do_journal_end(&th, COMMIT_NOW | WAIT); } } } /* -** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit -** -** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all -** the writers are done. By the time it wakes up, the transaction it was called has already ended, so it just -** flushes the commit list and returns 0. -** -** Won't batch when flush or commit_now is set. Also won't batch when others are waiting on j_join_wait. -** -** Note, we can't allow the journal_end to proceed while there are still writers in the log. -*/ -static int check_journal_end(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks, - int flags) + * returns 0 if do_journal_end should return right away, returns 1 if + * do_journal_end should finish the commit + * + * if the current transaction is too old, but still has writers, this will + * wait on j_join_wait until all the writers are done. By the time it + * wakes up, the transaction it was called has already ended, so it just + * flushes the commit list and returns 0. + * + * Won't batch when flush or commit_now is set. Also won't batch when + * others are waiting on j_join_wait. + * + * Note, we can't allow the journal_end to proceed while there are still + * writers in the log. + */ +static int check_journal_end(struct reiserfs_transaction_handle *th, int flags) { time_t now; @@ -3546,6 +3610,7 @@ static int check_journal_end(struct reiserfs_transaction_handle *th, int commit_now = flags & COMMIT_NOW; int wait_on_commit = flags & WAIT; struct reiserfs_journal_list *jl; + struct super_block *sb = th->t_super; struct reiserfs_journal *journal = SB_JOURNAL(sb); BUG_ON(!th->t_trans_id); @@ -3557,23 +3622,27 @@ static int check_journal_end(struct reiserfs_transaction_handle *th, } journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged); - if (atomic_read(&(journal->j_wcount)) > 0) { /* <= 0 is allowed. unmounting might not call begin */ - atomic_dec(&(journal->j_wcount)); - } + /* <= 0 is allowed. unmounting might not call begin */ + if (atomic_read(&journal->j_wcount) > 0) + atomic_dec(&journal->j_wcount); - /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released - ** will be dealt with by next transaction that actually writes something, but should be taken - ** care of in this trans + /* + * BUG, deal with case where j_len is 0, but people previously + * freed blocks need to be released will be dealt with by next + * transaction that actually writes something, but should be taken + * care of in this trans */ BUG_ON(journal->j_len == 0); - /* if wcount > 0, and we are called to with flush or commit_now, - ** we wait on j_join_wait. We will wake up when the last writer has - ** finished the transaction, and started it on its way to the disk. - ** Then, we flush the commit or journal list, and just return 0 - ** because the rest of journal end was already done for this transaction. + /* + * if wcount > 0, and we are called to with flush or commit_now, + * we wait on j_join_wait. We will wake up when the last writer has + * finished the transaction, and started it on its way to the disk. + * Then, we flush the commit or journal list, and just return 0 + * because the rest of journal end was already done for this + * transaction. */ - if (atomic_read(&(journal->j_wcount)) > 0) { + if (atomic_read(&journal->j_wcount) > 0) { if (flush || commit_now) { unsigned trans_id; @@ -3581,27 +3650,30 @@ static int check_journal_end(struct reiserfs_transaction_handle *th, trans_id = jl->j_trans_id; if (wait_on_commit) jl->j_state |= LIST_COMMIT_PENDING; - atomic_set(&(journal->j_jlock), 1); + atomic_set(&journal->j_jlock, 1); if (flush) { journal->j_next_full_flush = 1; } unlock_journal(sb); - /* sleep while the current transaction is still j_jlocked */ + /* + * sleep while the current transaction is + * still j_jlocked + */ while (journal->j_trans_id == trans_id) { if (atomic_read(&journal->j_jlock)) { queue_log_writer(sb); } else { lock_journal(sb); if (journal->j_trans_id == trans_id) { - atomic_set(&(journal->j_jlock), + atomic_set(&journal->j_jlock, 1); } unlock_journal(sb); } } BUG_ON(journal->j_trans_id == trans_id); - + if (commit_now && journal_list_still_alive(sb, trans_id) && wait_on_commit) { @@ -3621,7 +3693,7 @@ static int check_journal_end(struct reiserfs_transaction_handle *th, } /* don't batch when someone is waiting on j_join_wait */ /* don't batch when syncing the commit or flushing the whole trans */ - if (!(journal->j_must_wait > 0) && !(atomic_read(&(journal->j_jlock))) + if (!(journal->j_must_wait > 0) && !(atomic_read(&journal->j_jlock)) && !flush && !commit_now && (journal->j_len < journal->j_max_batch) && journal->j_len_alloc < journal->j_max_batch && journal->j_cnode_free > (journal->j_trans_max * 3)) { @@ -3639,19 +3711,22 @@ static int check_journal_end(struct reiserfs_transaction_handle *th, } /* -** Does all the work that makes deleting blocks safe. -** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on. -** -** otherwise: -** set a bit for the block in the journal bitmap. That will prevent it from being allocated for unformatted nodes -** before this transaction has finished. -** -** mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers. That will prevent any old transactions with -** this block from trying to flush to the real location. Since we aren't removing the cnode from the journal_list_hash, -** the block can't be reallocated yet. -** -** Then remove it from the current transaction, decrementing any counters and filing it on the clean list. -*/ + * Does all the work that makes deleting blocks safe. + * when deleting a block mark BH_JNew, just remove it from the current + * transaction, clean it's buffer_head and move on. + * + * otherwise: + * set a bit for the block in the journal bitmap. That will prevent it from + * being allocated for unformatted nodes before this transaction has finished. + * + * mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers. + * That will prevent any old transactions with this block from trying to flush + * to the real location. Since we aren't removing the cnode from the + * journal_list_hash, *the block can't be reallocated yet. + * + * Then remove it from the current transaction, decrementing any counters and + * filing it on the clean list. + */ int journal_mark_freed(struct reiserfs_transaction_handle *th, struct super_block *sb, b_blocknr_t blocknr) { @@ -3674,7 +3749,10 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th, reiserfs_clean_and_file_buffer(bh); cleaned = remove_from_transaction(sb, blocknr, cleaned); } else { - /* set the bit for this block in the journal bitmap for this transaction */ + /* + * set the bit for this block in the journal bitmap + * for this transaction + */ jb = journal->j_current_jl->j_list_bitmap; if (!jb) { reiserfs_panic(sb, "journal-1702", @@ -3690,17 +3768,22 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th, } cleaned = remove_from_transaction(sb, blocknr, cleaned); - /* find all older transactions with this block, make sure they don't try to write it out */ + /* + * find all older transactions with this block, + * make sure they don't try to write it out + */ cn = get_journal_hash_dev(sb, journal->j_list_hash_table, blocknr); while (cn) { if (sb == cn->sb && blocknr == cn->blocknr) { set_bit(BLOCK_FREED, &cn->state); if (cn->bh) { + /* + * remove_from_transaction will brelse + * the buffer if it was in the current + * trans + */ if (!cleaned) { - /* remove_from_transaction will brelse the buffer if it was - ** in the current trans - */ clear_buffer_journal_dirty(cn-> bh); clear_buffer_dirty(cn->bh); @@ -3709,16 +3792,19 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th, cleaned = 1; put_bh(cn->bh); if (atomic_read - (&(cn->bh->b_count)) < 0) { + (&cn->bh->b_count) < 0) { reiserfs_warning(sb, "journal-2138", "cn->bh->b_count < 0"); } } - if (cn->jlist) { /* since we are clearing the bh, we MUST dec nonzerolen */ - atomic_dec(& - (cn->jlist-> - j_nonzerolen)); + /* + * since we are clearing the bh, + * we MUST dec nonzerolen + */ + if (cn->jlist) { + atomic_dec(&cn->jlist-> + j_nonzerolen); } cn->bh = NULL; } @@ -3751,10 +3837,16 @@ static int __commit_trans_jl(struct inode *inode, unsigned long id, struct reiserfs_journal *journal = SB_JOURNAL(sb); int ret = 0; - /* is it from the current transaction, or from an unknown transaction? */ + /* + * is it from the current transaction, + * or from an unknown transaction? + */ if (id == journal->j_trans_id) { jl = journal->j_current_jl; - /* try to let other writers come in and grow this transaction */ + /* + * try to let other writers come in and + * grow this transaction + */ let_transaction_grow(sb, id); if (journal->j_trans_id != id) { goto flush_commit_only; @@ -3768,21 +3860,22 @@ static int __commit_trans_jl(struct inode *inode, unsigned long id, if (journal->j_trans_id != id) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(&th, sb, SB_BUFFER_WITH_SB(sb)); - ret = journal_end(&th, sb, 1); + journal_mark_dirty(&th, SB_BUFFER_WITH_SB(sb)); + ret = journal_end(&th); goto flush_commit_only; } - ret = journal_end_sync(&th, sb, 1); + ret = journal_end_sync(&th); if (!ret) ret = 1; } else { - /* this gets tricky, we have to make sure the journal list in + /* + * this gets tricky, we have to make sure the journal list in * the inode still exists. We know the list is still around * if we've got a larger transaction id than the oldest list */ - flush_commit_only: +flush_commit_only: if (journal_list_still_alive(inode->i_sb, id)) { /* * we only set ret to 1 when we know for sure @@ -3805,7 +3898,8 @@ int reiserfs_commit_for_inode(struct inode *inode) unsigned int id = REISERFS_I(inode)->i_trans_id; struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl; - /* for the whole inode, assume unset id means it was + /* + * for the whole inode, assume unset id means it was * changed in the current transaction. More conservative */ if (!id || !jl) { @@ -3843,12 +3937,11 @@ void reiserfs_restore_prepared_buffer(struct super_block *sb, extern struct tree_balance *cur_tb; /* -** before we can change a metadata block, we have to make sure it won't -** be written to disk while we are altering it. So, we must: -** clean it -** wait on it. -** -*/ + * before we can change a metadata block, we have to make sure it won't + * be written to disk while we are altering it. So, we must: + * clean it + * wait on it. + */ int reiserfs_prepare_for_journal(struct super_block *sb, struct buffer_head *bh, int wait) { @@ -3868,41 +3961,19 @@ int reiserfs_prepare_for_journal(struct super_block *sb, return 1; } -static void flush_old_journal_lists(struct super_block *s) -{ - struct reiserfs_journal *journal = SB_JOURNAL(s); - struct reiserfs_journal_list *jl; - struct list_head *entry; - time_t now = get_seconds(); - - while (!list_empty(&journal->j_journal_list)) { - entry = journal->j_journal_list.next; - jl = JOURNAL_LIST_ENTRY(entry); - /* this check should always be run, to send old lists to disk */ - if (jl->j_timestamp < (now - (JOURNAL_MAX_TRANS_AGE * 4)) && - atomic_read(&jl->j_commit_left) == 0 && - test_transaction(s, jl)) { - flush_used_journal_lists(s, jl); - } else { - break; - } - } -} - /* -** long and ugly. If flush, will not return until all commit -** blocks and all real buffers in the trans are on disk. -** If no_async, won't return until all commit blocks are on disk. -** -** keep reading, there are comments as you go along -** -** If the journal is aborted, we just clean up. Things like flushing -** journal lists, etc just won't happen. -*/ -static int do_journal_end(struct reiserfs_transaction_handle *th, - struct super_block *sb, unsigned long nblocks, - int flags) + * long and ugly. If flush, will not return until all commit + * blocks and all real buffers in the trans are on disk. + * If no_async, won't return until all commit blocks are on disk. + * + * keep reading, there are comments as you go along + * + * If the journal is aborted, we just clean up. Things like flushing + * journal lists, etc just won't happen. + */ +static int do_journal_end(struct reiserfs_transaction_handle *th, int flags) { + struct super_block *sb = th->t_super; struct reiserfs_journal *journal = SB_JOURNAL(sb); struct reiserfs_journal_cnode *cn, *next, *jl_cn; struct reiserfs_journal_cnode *last_cn = NULL; @@ -3924,9 +3995,12 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, BUG_ON(th->t_refcount > 1); BUG_ON(!th->t_trans_id); + BUG_ON(!th->t_super); - /* protect flush_older_commits from doing mistakes if the - transaction ID counter gets overflowed. */ + /* + * protect flush_older_commits from doing mistakes if the + * transaction ID counter gets overflowed. + */ if (th->t_trans_id == ~0U) flags |= FLUSH_ALL | COMMIT_NOW | WAIT; flush = flags & FLUSH_ALL; @@ -3937,7 +4011,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, if (journal->j_len == 0) { reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 1); - journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb)); + journal_mark_dirty(th, SB_BUFFER_WITH_SB(sb)); } lock_journal(sb); @@ -3950,10 +4024,12 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, wait_on_commit = 1; } - /* check_journal_end locks the journal, and unlocks if it does not return 1 - ** it tells us if we should continue with the journal_end, or just return + /* + * check_journal_end locks the journal, and unlocks if it does + * not return 1 it tells us if we should continue with the + * journal_end, or just return */ - if (!check_journal_end(th, sb, nblocks, flags)) { + if (!check_journal_end(th, flags)) { reiserfs_schedule_old_flush(sb); wake_queued_writers(sb); reiserfs_async_progress_wait(sb); @@ -3966,19 +4042,23 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, } /* - ** j must wait means we have to flush the log blocks, and the real blocks for - ** this transaction + * j must wait means we have to flush the log blocks, and the + * real blocks for this transaction */ if (journal->j_must_wait > 0) { flush = 1; } #ifdef REISERFS_PREALLOCATE - /* quota ops might need to nest, setup the journal_info pointer for them - * and raise the refcount so that it is > 0. */ + /* + * quota ops might need to nest, setup the journal_info pointer + * for them and raise the refcount so that it is > 0. + */ current->journal_info = th; th->t_refcount++; - reiserfs_discard_all_prealloc(th); /* it should not involve new blocks into - * the transaction */ + + /* it should not involve new blocks into the transaction */ + reiserfs_discard_all_prealloc(th); + th->t_refcount--; current->journal_info = th->t_handle_save; #endif @@ -3994,7 +4074,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, memcpy(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8); set_desc_trans_id(desc, journal->j_trans_id); - /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */ + /* + * setup commit block. Don't write (keep it clean too) this one + * until after everyone else is written + */ c_bh = journal_getblk(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) + ((journal->j_start + journal->j_len + 1) % SB_ONDISK_JOURNAL_SIZE(sb))); @@ -4006,7 +4089,8 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, /* init this journal list */ jl = journal->j_current_jl; - /* we lock the commit before doing anything because + /* + * we lock the commit before doing anything because * we want to make sure nobody tries to run flush_commit_list until * the new transaction is fully setup, and we've already flushed the * ordered bh list @@ -4026,9 +4110,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, atomic_set(&jl->j_commit_left, journal->j_len + 2); jl->j_realblock = NULL; - /* The ENTIRE FOR LOOP MUST not cause schedule to occur. - ** for each real block, add it to the journal list hash, - ** copy into real block index array in the commit or desc block + /* + * The ENTIRE FOR LOOP MUST not cause schedule to occur. + * for each real block, add it to the journal list hash, + * copy into real block index array in the commit or desc block */ trans_half = journal_trans_half(sb->s_blocksize); for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) { @@ -4047,9 +4132,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, last_cn->next = jl_cn; } last_cn = jl_cn; - /* make sure the block we are trying to log is not a block - of journal or reserved area */ - + /* + * make sure the block we are trying to log + * is not a block of journal or reserved area + */ if (is_block_in_log_or_reserved_area (sb, cn->bh->b_blocknr)) { reiserfs_panic(sb, "journal-2332", @@ -4079,19 +4165,26 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, set_desc_trans_id(desc, journal->j_trans_id); set_commit_trans_len(commit, journal->j_len); - /* special check in case all buffers in the journal were marked for not logging */ + /* + * special check in case all buffers in the journal + * were marked for not logging + */ BUG_ON(journal->j_len == 0); - /* we're about to dirty all the log blocks, mark the description block + /* + * we're about to dirty all the log blocks, mark the description block * dirty now too. Don't mark the commit block dirty until all the * others are on disk */ mark_buffer_dirty(d_bh); - /* first data block is j_start + 1, so add one to cur_write_start wherever you use it */ + /* + * first data block is j_start + 1, so add one to + * cur_write_start wherever you use it + */ cur_write_start = journal->j_start; cn = journal->j_first; - jindex = 1; /* start at one so we don't get the desc again */ + jindex = 1; /* start at one so we don't get the desc again */ while (cn) { clear_buffer_journal_new(cn->bh); /* copy all the real blocks into log area. dirty log blocks */ @@ -4117,7 +4210,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, set_buffer_journal_dirty(cn->bh); clear_buffer_journaled(cn->bh); } else { - /* JDirty cleared sometime during transaction. don't log this one */ + /* + * JDirty cleared sometime during transaction. + * don't log this one + */ reiserfs_warning(sb, "journal-2048", "BAD, buffer in journal hash, " "but not JDirty!"); @@ -4129,9 +4225,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, reiserfs_cond_resched(sb); } - /* we are done with both the c_bh and d_bh, but - ** c_bh must be written after all other commit blocks, - ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1. + /* + * we are done with both the c_bh and d_bh, but + * c_bh must be written after all other commit blocks, + * so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1. */ journal->j_current_jl = alloc_journal_list(sb); @@ -4146,7 +4243,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, journal->j_start = (journal->j_start + journal->j_len + 2) % SB_ONDISK_JOURNAL_SIZE(sb); - atomic_set(&(journal->j_wcount), 0); + atomic_set(&journal->j_wcount, 0); journal->j_bcount = 0; journal->j_last = NULL; journal->j_first = NULL; @@ -4162,15 +4259,18 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, journal->j_next_async_flush = 0; init_journal_hash(sb); - // make sure reiserfs_add_jh sees the new current_jl before we - // write out the tails + /* + * make sure reiserfs_add_jh sees the new current_jl before we + * write out the tails + */ smp_mb(); - /* tail conversion targets have to hit the disk before we end the + /* + * tail conversion targets have to hit the disk before we end the * transaction. Otherwise a later transaction might repack the tail - * before this transaction commits, leaving the data block unflushed and - * clean, if we crash before the later transaction commits, the data block - * is lost. + * before this transaction commits, leaving the data block unflushed + * and clean, if we crash before the later transaction commits, the + * data block is lost. */ if (!list_empty(&jl->j_tail_bh_list)) { depth = reiserfs_write_unlock_nested(sb); @@ -4181,24 +4281,27 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, BUG_ON(!list_empty(&jl->j_tail_bh_list)); mutex_unlock(&jl->j_commit_mutex); - /* honor the flush wishes from the caller, simple commits can - ** be done outside the journal lock, they are done below - ** - ** if we don't flush the commit list right now, we put it into - ** the work queue so the people waiting on the async progress work - ** queue don't wait for this proc to flush journal lists and such. + /* + * honor the flush wishes from the caller, simple commits can + * be done outside the journal lock, they are done below + * + * if we don't flush the commit list right now, we put it into + * the work queue so the people waiting on the async progress work + * queue don't wait for this proc to flush journal lists and such. */ if (flush) { flush_commit_list(sb, jl, 1); flush_journal_list(sb, jl, 1); } else if (!(jl->j_state & LIST_COMMIT_PENDING)) - queue_delayed_work(commit_wq, &journal->j_work, HZ / 10); + queue_delayed_work(REISERFS_SB(sb)->commit_wq, + &journal->j_work, HZ / 10); - /* if the next transaction has any chance of wrapping, flush - ** transactions that might get overwritten. If any journal lists are very - ** old flush them as well. + /* + * if the next transaction has any chance of wrapping, flush + * transactions that might get overwritten. If any journal lists + * are very old flush them as well. */ - first_jl: +first_jl: list_for_each_safe(entry, safe, &journal->j_journal_list) { temp_jl = JOURNAL_LIST_ENTRY(entry); if (journal->j_start <= temp_jl->j_start) { @@ -4209,8 +4312,10 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, } else if ((journal->j_start + journal->j_trans_max + 1) < SB_ONDISK_JOURNAL_SIZE(sb)) { - /* if we don't cross into the next transaction and we don't - * wrap, there is no way we can overlap any later transactions + /* + * if we don't cross into the next + * transaction and we don't wrap, there is + * no way we can overlap any later transactions * break now */ break; @@ -4224,15 +4329,16 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, flush_used_journal_lists(sb, temp_jl); goto first_jl; } else { - /* we don't overlap anything from out start to the end of the - * log, and our wrapped portion doesn't overlap anything at - * the start of the log. We can break - */ + /* + * we don't overlap anything from out start + * to the end of the log, and our wrapped + * portion doesn't overlap anything at + * the start of the log. We can break + */ break; } } } - flush_old_journal_lists(sb); journal->j_current_jl->j_list_bitmap = get_list_bitmap(sb, journal->j_current_jl); @@ -4242,23 +4348,25 @@ static int do_journal_end(struct reiserfs_transaction_handle *th, "could not get a list bitmap"); } - atomic_set(&(journal->j_jlock), 0); + atomic_set(&journal->j_jlock, 0); unlock_journal(sb); /* wake up any body waiting to join. */ clear_bit(J_WRITERS_QUEUED, &journal->j_state); - wake_up(&(journal->j_join_wait)); + wake_up(&journal->j_join_wait); if (!flush && wait_on_commit && journal_list_still_alive(sb, commit_trans_id)) { flush_commit_list(sb, jl, 1); } - out: +out: reiserfs_check_lock_depth(sb, "journal end2"); memset(th, 0, sizeof(*th)); - /* Re-set th->t_super, so we can properly keep track of how many + /* + * Re-set th->t_super, so we can properly keep track of how many * persistent transactions there are. We need to do this so if this - * call is part of a failed restart_transaction, we can free it later */ + * call is part of a failed restart_transaction, we can free it later + */ th->t_super = sb; return journal->j_errno; |