11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds ** Write ahead logging implementation copyright Chris Mason 2000 31da177e4SLinus Torvalds ** 41da177e4SLinus Torvalds ** The background commits make this code very interelated, and 51da177e4SLinus Torvalds ** overly complex. I need to rethink things a bit....The major players: 61da177e4SLinus Torvalds ** 71da177e4SLinus Torvalds ** journal_begin -- call with the number of blocks you expect to log. 81da177e4SLinus Torvalds ** If the current transaction is too 91da177e4SLinus Torvalds ** old, it will block until the current transaction is 101da177e4SLinus Torvalds ** finished, and then start a new one. 111da177e4SLinus Torvalds ** Usually, your transaction will get joined in with 121da177e4SLinus Torvalds ** previous ones for speed. 131da177e4SLinus Torvalds ** 141da177e4SLinus Torvalds ** journal_join -- same as journal_begin, but won't block on the current 151da177e4SLinus Torvalds ** transaction regardless of age. Don't ever call 161da177e4SLinus Torvalds ** this. Ever. There are only two places it should be 171da177e4SLinus Torvalds ** called from, and they are both inside this file. 181da177e4SLinus Torvalds ** 191da177e4SLinus Torvalds ** journal_mark_dirty -- adds blocks into this transaction. clears any flags 201da177e4SLinus Torvalds ** that might make them get sent to disk 211da177e4SLinus Torvalds ** and then marks them BH_JDirty. Puts the buffer head 221da177e4SLinus Torvalds ** into the current transaction hash. 231da177e4SLinus Torvalds ** 241da177e4SLinus Torvalds ** journal_end -- if the current transaction is batchable, it does nothing 251da177e4SLinus Torvalds ** otherwise, it could do an async/synchronous commit, or 261da177e4SLinus Torvalds ** a full flush of all log and real blocks in the 271da177e4SLinus Torvalds ** transaction. 281da177e4SLinus Torvalds ** 291da177e4SLinus Torvalds ** flush_old_commits -- if the current transaction is too old, it is ended and 301da177e4SLinus Torvalds ** commit blocks are sent to disk. Forces commit blocks 311da177e4SLinus Torvalds ** to disk for all backgrounded commits that have been 321da177e4SLinus Torvalds ** around too long. 331da177e4SLinus Torvalds ** -- Note, if you call this as an immediate flush from 341da177e4SLinus Torvalds ** from within kupdate, it will ignore the immediate flag 351da177e4SLinus Torvalds */ 361da177e4SLinus Torvalds 371da177e4SLinus Torvalds #include <linux/time.h> 386188e10dSMatthew Wilcox #include <linux/semaphore.h> 391da177e4SLinus Torvalds #include <linux/vmalloc.h> 401da177e4SLinus Torvalds #include <linux/reiserfs_fs.h> 411da177e4SLinus Torvalds #include <linux/kernel.h> 421da177e4SLinus Torvalds #include <linux/errno.h> 431da177e4SLinus Torvalds #include <linux/fcntl.h> 441da177e4SLinus Torvalds #include <linux/stat.h> 451da177e4SLinus Torvalds #include <linux/string.h> 461da177e4SLinus Torvalds #include <linux/smp_lock.h> 471da177e4SLinus Torvalds #include <linux/buffer_head.h> 481da177e4SLinus Torvalds #include <linux/workqueue.h> 491da177e4SLinus Torvalds #include <linux/writeback.h> 501da177e4SLinus Torvalds #include <linux/blkdev.h> 513fcfab16SAndrew Morton #include <linux/backing-dev.h> 5290415deaSJeff Mahoney #include <linux/uaccess.h> 5390415deaSJeff Mahoney 5490415deaSJeff Mahoney #include <asm/system.h> 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds /* gets a struct reiserfs_journal_list * from a list head */ 571da177e4SLinus Torvalds #define JOURNAL_LIST_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \ 581da177e4SLinus Torvalds j_list)) 591da177e4SLinus Torvalds #define JOURNAL_WORK_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \ 601da177e4SLinus Torvalds j_working_list)) 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds /* the number of mounted filesystems. This is used to decide when to 631da177e4SLinus Torvalds ** start and kill the commit workqueue 641da177e4SLinus Torvalds */ 651da177e4SLinus Torvalds static int reiserfs_mounted_fs_count; 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds static struct workqueue_struct *commit_wq; 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds #define JOURNAL_TRANS_HALF 1018 /* must be correct to keep the desc and commit 701da177e4SLinus Torvalds structs at 4k */ 711da177e4SLinus Torvalds #define BUFNR 64 /*read ahead */ 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds /* cnode stat bits. Move these into reiserfs_fs.h */ 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds #define BLOCK_FREED 2 /* this block was freed, and can't be written. */ 761da177e4SLinus Torvalds #define BLOCK_FREED_HOLDER 3 /* this block was freed during this transaction, and can't be written */ 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds #define BLOCK_NEEDS_FLUSH 4 /* used in flush_journal_list */ 791da177e4SLinus Torvalds #define BLOCK_DIRTIED 5 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds /* journal list state bits */ 821da177e4SLinus Torvalds #define LIST_TOUCHED 1 831da177e4SLinus Torvalds #define LIST_DIRTY 2 841da177e4SLinus Torvalds #define LIST_COMMIT_PENDING 4 /* someone will commit this list */ 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds /* flags for do_journal_end */ 871da177e4SLinus Torvalds #define FLUSH_ALL 1 /* flush commit and real blocks */ 881da177e4SLinus Torvalds #define COMMIT_NOW 2 /* end and commit this transaction */ 891da177e4SLinus Torvalds #define WAIT 4 /* wait for the log blocks to hit the disk */ 901da177e4SLinus Torvalds 91bd4c625cSLinus Torvalds static int do_journal_end(struct reiserfs_transaction_handle *, 92bd4c625cSLinus Torvalds struct super_block *, unsigned long nblocks, 93bd4c625cSLinus Torvalds int flags); 94bd4c625cSLinus Torvalds static int flush_journal_list(struct super_block *s, 95bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl, int flushall); 96bd4c625cSLinus Torvalds static int flush_commit_list(struct super_block *s, 97bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl, int flushall); 981da177e4SLinus Torvalds static int can_dirty(struct reiserfs_journal_cnode *cn); 99bd4c625cSLinus Torvalds static int journal_join(struct reiserfs_transaction_handle *th, 100a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks); 1011da177e4SLinus Torvalds static int release_journal_dev(struct super_block *super, 1021da177e4SLinus Torvalds struct reiserfs_journal *journal); 1031da177e4SLinus Torvalds static int dirty_one_transaction(struct super_block *s, 1041da177e4SLinus Torvalds struct reiserfs_journal_list *jl); 105c4028958SDavid Howells static void flush_async_commits(struct work_struct *work); 1061da177e4SLinus Torvalds static void queue_log_writer(struct super_block *s); 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds /* values for join in do_journal_begin_r */ 1091da177e4SLinus Torvalds enum { 1101da177e4SLinus Torvalds JBEGIN_REG = 0, /* regular journal begin */ 1111da177e4SLinus Torvalds JBEGIN_JOIN = 1, /* join the running transaction if at all possible */ 1121da177e4SLinus Torvalds JBEGIN_ABORT = 2, /* called from cleanup code, ignores aborted flag */ 1131da177e4SLinus Torvalds }; 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds static int do_journal_begin_r(struct reiserfs_transaction_handle *th, 116a9dd3643SJeff Mahoney struct super_block *sb, 1171da177e4SLinus Torvalds unsigned long nblocks, int join); 1181da177e4SLinus Torvalds 119a9dd3643SJeff Mahoney static void init_journal_hash(struct super_block *sb) 120bd4c625cSLinus Torvalds { 121a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 122bd4c625cSLinus Torvalds memset(journal->j_hash_table, 0, 123bd4c625cSLinus Torvalds JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *)); 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds /* 1271da177e4SLinus Torvalds ** clears BH_Dirty and sticks the buffer on the clean list. Called because I can't allow refile_buffer to 1281da177e4SLinus Torvalds ** make schedule happen after I've freed a block. Look at remove_from_transaction and journal_mark_freed for 1291da177e4SLinus Torvalds ** more details. 1301da177e4SLinus Torvalds */ 131bd4c625cSLinus Torvalds static int reiserfs_clean_and_file_buffer(struct buffer_head *bh) 132bd4c625cSLinus Torvalds { 1331da177e4SLinus Torvalds if (bh) { 1341da177e4SLinus Torvalds clear_buffer_dirty(bh); 1351da177e4SLinus Torvalds clear_buffer_journal_test(bh); 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds return 0; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds static void disable_barrier(struct super_block *s) 1411da177e4SLinus Torvalds { 1421da177e4SLinus Torvalds REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_BARRIER_FLUSH); 143bd4c625cSLinus Torvalds printk("reiserfs: disabling flush barriers on %s\n", 144bd4c625cSLinus Torvalds reiserfs_bdevname(s)); 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 147bd4c625cSLinus Torvalds static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block 148a9dd3643SJeff Mahoney *sb) 149bd4c625cSLinus Torvalds { 1501da177e4SLinus Torvalds struct reiserfs_bitmap_node *bn; 1511da177e4SLinus Torvalds static int id; 1521da177e4SLinus Torvalds 153d739b42bSPekka Enberg bn = kmalloc(sizeof(struct reiserfs_bitmap_node), GFP_NOFS); 1541da177e4SLinus Torvalds if (!bn) { 1551da177e4SLinus Torvalds return NULL; 1561da177e4SLinus Torvalds } 157a9dd3643SJeff Mahoney bn->data = kzalloc(sb->s_blocksize, GFP_NOFS); 1581da177e4SLinus Torvalds if (!bn->data) { 159d739b42bSPekka Enberg kfree(bn); 1601da177e4SLinus Torvalds return NULL; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds bn->id = id++; 1631da177e4SLinus Torvalds INIT_LIST_HEAD(&bn->list); 1641da177e4SLinus Torvalds return bn; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds 167a9dd3643SJeff Mahoney static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *sb) 168bd4c625cSLinus Torvalds { 169a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 1701da177e4SLinus Torvalds struct reiserfs_bitmap_node *bn = NULL; 1711da177e4SLinus Torvalds struct list_head *entry = journal->j_bitmap_nodes.next; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds journal->j_used_bitmap_nodes++; 1741da177e4SLinus Torvalds repeat: 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds if (entry != &journal->j_bitmap_nodes) { 1771da177e4SLinus Torvalds bn = list_entry(entry, struct reiserfs_bitmap_node, list); 1781da177e4SLinus Torvalds list_del(entry); 179a9dd3643SJeff Mahoney memset(bn->data, 0, sb->s_blocksize); 1801da177e4SLinus Torvalds journal->j_free_bitmap_nodes--; 1811da177e4SLinus Torvalds return bn; 1821da177e4SLinus Torvalds } 183a9dd3643SJeff Mahoney bn = allocate_bitmap_node(sb); 1841da177e4SLinus Torvalds if (!bn) { 1851da177e4SLinus Torvalds yield(); 1861da177e4SLinus Torvalds goto repeat; 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds return bn; 1891da177e4SLinus Torvalds } 190a9dd3643SJeff Mahoney static inline void free_bitmap_node(struct super_block *sb, 191bd4c625cSLinus Torvalds struct reiserfs_bitmap_node *bn) 192bd4c625cSLinus Torvalds { 193a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 1941da177e4SLinus Torvalds journal->j_used_bitmap_nodes--; 1951da177e4SLinus Torvalds if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) { 196d739b42bSPekka Enberg kfree(bn->data); 197d739b42bSPekka Enberg kfree(bn); 1981da177e4SLinus Torvalds } else { 1991da177e4SLinus Torvalds list_add(&bn->list, &journal->j_bitmap_nodes); 2001da177e4SLinus Torvalds journal->j_free_bitmap_nodes++; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds } 2031da177e4SLinus Torvalds 204a9dd3643SJeff Mahoney static void allocate_bitmap_nodes(struct super_block *sb) 205bd4c625cSLinus Torvalds { 2061da177e4SLinus Torvalds int i; 207a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 2081da177e4SLinus Torvalds struct reiserfs_bitmap_node *bn = NULL; 2091da177e4SLinus Torvalds for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) { 210a9dd3643SJeff Mahoney bn = allocate_bitmap_node(sb); 2111da177e4SLinus Torvalds if (bn) { 2121da177e4SLinus Torvalds list_add(&bn->list, &journal->j_bitmap_nodes); 2131da177e4SLinus Torvalds journal->j_free_bitmap_nodes++; 2141da177e4SLinus Torvalds } else { 2150222e657SJeff Mahoney break; /* this is ok, we'll try again when more are needed */ 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 220a9dd3643SJeff Mahoney static int set_bit_in_list_bitmap(struct super_block *sb, 2213ee16670SJeff Mahoney b_blocknr_t block, 222bd4c625cSLinus Torvalds struct reiserfs_list_bitmap *jb) 223bd4c625cSLinus Torvalds { 224a9dd3643SJeff Mahoney unsigned int bmap_nr = block / (sb->s_blocksize << 3); 225a9dd3643SJeff Mahoney unsigned int bit_nr = block % (sb->s_blocksize << 3); 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds if (!jb->bitmaps[bmap_nr]) { 228a9dd3643SJeff Mahoney jb->bitmaps[bmap_nr] = get_bitmap_node(sb); 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data); 2311da177e4SLinus Torvalds return 0; 2321da177e4SLinus Torvalds } 2331da177e4SLinus Torvalds 234a9dd3643SJeff Mahoney static void cleanup_bitmap_list(struct super_block *sb, 235bd4c625cSLinus Torvalds struct reiserfs_list_bitmap *jb) 236bd4c625cSLinus Torvalds { 2371da177e4SLinus Torvalds int i; 2381da177e4SLinus Torvalds if (jb->bitmaps == NULL) 2391da177e4SLinus Torvalds return; 2401da177e4SLinus Torvalds 241a9dd3643SJeff Mahoney for (i = 0; i < reiserfs_bmap_count(sb); i++) { 2421da177e4SLinus Torvalds if (jb->bitmaps[i]) { 243a9dd3643SJeff Mahoney free_bitmap_node(sb, jb->bitmaps[i]); 2441da177e4SLinus Torvalds jb->bitmaps[i] = NULL; 2451da177e4SLinus Torvalds } 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds /* 2501da177e4SLinus Torvalds ** only call this on FS unmount. 2511da177e4SLinus Torvalds */ 252a9dd3643SJeff Mahoney static int free_list_bitmaps(struct super_block *sb, 253bd4c625cSLinus Torvalds struct reiserfs_list_bitmap *jb_array) 254bd4c625cSLinus Torvalds { 2551da177e4SLinus Torvalds int i; 2561da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb; 2571da177e4SLinus Torvalds for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 2581da177e4SLinus Torvalds jb = jb_array + i; 2591da177e4SLinus Torvalds jb->journal_list = NULL; 260a9dd3643SJeff Mahoney cleanup_bitmap_list(sb, jb); 2611da177e4SLinus Torvalds vfree(jb->bitmaps); 2621da177e4SLinus Torvalds jb->bitmaps = NULL; 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds return 0; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 267a9dd3643SJeff Mahoney static int free_bitmap_nodes(struct super_block *sb) 268bd4c625cSLinus Torvalds { 269a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 2701da177e4SLinus Torvalds struct list_head *next = journal->j_bitmap_nodes.next; 2711da177e4SLinus Torvalds struct reiserfs_bitmap_node *bn; 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds while (next != &journal->j_bitmap_nodes) { 2741da177e4SLinus Torvalds bn = list_entry(next, struct reiserfs_bitmap_node, list); 2751da177e4SLinus Torvalds list_del(next); 276d739b42bSPekka Enberg kfree(bn->data); 277d739b42bSPekka Enberg kfree(bn); 2781da177e4SLinus Torvalds next = journal->j_bitmap_nodes.next; 2791da177e4SLinus Torvalds journal->j_free_bitmap_nodes--; 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds return 0; 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds 2851da177e4SLinus Torvalds /* 2861da177e4SLinus Torvalds ** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps. 2871da177e4SLinus Torvalds ** jb_array is the array to be filled in. 2881da177e4SLinus Torvalds */ 289a9dd3643SJeff Mahoney int reiserfs_allocate_list_bitmaps(struct super_block *sb, 2901da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb_array, 2913ee16670SJeff Mahoney unsigned int bmap_nr) 292bd4c625cSLinus Torvalds { 2931da177e4SLinus Torvalds int i; 2941da177e4SLinus Torvalds int failed = 0; 2951da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb; 2961da177e4SLinus Torvalds int mem = bmap_nr * sizeof(struct reiserfs_bitmap_node *); 2971da177e4SLinus Torvalds 2981da177e4SLinus Torvalds for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 2991da177e4SLinus Torvalds jb = jb_array + i; 3001da177e4SLinus Torvalds jb->journal_list = NULL; 3011da177e4SLinus Torvalds jb->bitmaps = vmalloc(mem); 3021da177e4SLinus Torvalds if (!jb->bitmaps) { 303a9dd3643SJeff Mahoney reiserfs_warning(sb, "clm-2000", "unable to " 30445b03d5eSJeff Mahoney "allocate bitmaps for journal lists"); 3051da177e4SLinus Torvalds failed = 1; 3061da177e4SLinus Torvalds break; 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds memset(jb->bitmaps, 0, mem); 3091da177e4SLinus Torvalds } 3101da177e4SLinus Torvalds if (failed) { 311a9dd3643SJeff Mahoney free_list_bitmaps(sb, jb_array); 3121da177e4SLinus Torvalds return -1; 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds return 0; 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds /* 3181da177e4SLinus Torvalds ** find an available list bitmap. If you can't find one, flush a commit list 3191da177e4SLinus Torvalds ** and try again 3201da177e4SLinus Torvalds */ 321a9dd3643SJeff Mahoney static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb, 322bd4c625cSLinus Torvalds struct reiserfs_journal_list 323bd4c625cSLinus Torvalds *jl) 324bd4c625cSLinus Torvalds { 3251da177e4SLinus Torvalds int i, j; 326a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 3271da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb = NULL; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) { 3301da177e4SLinus Torvalds i = journal->j_list_bitmap_index; 3311da177e4SLinus Torvalds journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS; 3321da177e4SLinus Torvalds jb = journal->j_list_bitmap + i; 3331da177e4SLinus Torvalds if (journal->j_list_bitmap[i].journal_list) { 334a9dd3643SJeff Mahoney flush_commit_list(sb, 335bd4c625cSLinus Torvalds journal->j_list_bitmap[i]. 336bd4c625cSLinus Torvalds journal_list, 1); 3371da177e4SLinus Torvalds if (!journal->j_list_bitmap[i].journal_list) { 3381da177e4SLinus Torvalds break; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds } else { 3411da177e4SLinus Torvalds break; 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds } 3441da177e4SLinus Torvalds if (jb->journal_list) { /* double check to make sure if flushed correctly */ 3451da177e4SLinus Torvalds return NULL; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds jb->journal_list = jl; 3481da177e4SLinus Torvalds return jb; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds /* 3521da177e4SLinus Torvalds ** allocates a new chunk of X nodes, and links them all together as a list. 3531da177e4SLinus Torvalds ** Uses the cnode->next and cnode->prev pointers 3541da177e4SLinus Torvalds ** returns NULL on failure 3551da177e4SLinus Torvalds */ 356bd4c625cSLinus Torvalds static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes) 357bd4c625cSLinus Torvalds { 3581da177e4SLinus Torvalds struct reiserfs_journal_cnode *head; 3591da177e4SLinus Torvalds int i; 3601da177e4SLinus Torvalds if (num_cnodes <= 0) { 3611da177e4SLinus Torvalds return NULL; 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds head = vmalloc(num_cnodes * sizeof(struct reiserfs_journal_cnode)); 3641da177e4SLinus Torvalds if (!head) { 3651da177e4SLinus Torvalds return NULL; 3661da177e4SLinus Torvalds } 3671da177e4SLinus Torvalds memset(head, 0, num_cnodes * sizeof(struct reiserfs_journal_cnode)); 3681da177e4SLinus Torvalds head[0].prev = NULL; 3691da177e4SLinus Torvalds head[0].next = head + 1; 3701da177e4SLinus Torvalds for (i = 1; i < num_cnodes; i++) { 3711da177e4SLinus Torvalds head[i].prev = head + (i - 1); 3721da177e4SLinus Torvalds head[i].next = head + (i + 1); /* if last one, overwrite it after the if */ 3731da177e4SLinus Torvalds } 3741da177e4SLinus Torvalds head[num_cnodes - 1].next = NULL; 3751da177e4SLinus Torvalds return head; 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds /* 3791da177e4SLinus Torvalds ** pulls a cnode off the free list, or returns NULL on failure 3801da177e4SLinus Torvalds */ 381a9dd3643SJeff Mahoney static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb) 382bd4c625cSLinus Torvalds { 3831da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 384a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 3851da177e4SLinus Torvalds 386a9dd3643SJeff Mahoney reiserfs_check_lock_depth(sb, "get_cnode"); 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds if (journal->j_cnode_free <= 0) { 3891da177e4SLinus Torvalds return NULL; 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds journal->j_cnode_used++; 3921da177e4SLinus Torvalds journal->j_cnode_free--; 3931da177e4SLinus Torvalds cn = journal->j_cnode_free_list; 3941da177e4SLinus Torvalds if (!cn) { 3951da177e4SLinus Torvalds return cn; 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds if (cn->next) { 3981da177e4SLinus Torvalds cn->next->prev = NULL; 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds journal->j_cnode_free_list = cn->next; 4011da177e4SLinus Torvalds memset(cn, 0, sizeof(struct reiserfs_journal_cnode)); 4021da177e4SLinus Torvalds return cn; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds /* 4061da177e4SLinus Torvalds ** returns a cnode to the free list 4071da177e4SLinus Torvalds */ 408a9dd3643SJeff Mahoney static void free_cnode(struct super_block *sb, 409bd4c625cSLinus Torvalds struct reiserfs_journal_cnode *cn) 410bd4c625cSLinus Torvalds { 411a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 4121da177e4SLinus Torvalds 413a9dd3643SJeff Mahoney reiserfs_check_lock_depth(sb, "free_cnode"); 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds journal->j_cnode_used--; 4161da177e4SLinus Torvalds journal->j_cnode_free++; 4171da177e4SLinus Torvalds /* memset(cn, 0, sizeof(struct reiserfs_journal_cnode)) ; */ 4181da177e4SLinus Torvalds cn->next = journal->j_cnode_free_list; 4191da177e4SLinus Torvalds if (journal->j_cnode_free_list) { 4201da177e4SLinus Torvalds journal->j_cnode_free_list->prev = cn; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds cn->prev = NULL; /* not needed with the memset, but I might kill the memset, and forget to do this */ 4231da177e4SLinus Torvalds journal->j_cnode_free_list = cn; 4241da177e4SLinus Torvalds } 4251da177e4SLinus Torvalds 426bd4c625cSLinus Torvalds static void clear_prepared_bits(struct buffer_head *bh) 427bd4c625cSLinus Torvalds { 4281da177e4SLinus Torvalds clear_buffer_journal_prepared(bh); 4291da177e4SLinus Torvalds clear_buffer_journal_restore_dirty(bh); 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds 4321da177e4SLinus Torvalds /* return a cnode with same dev, block number and size in table, or null if not found */ 433bd4c625cSLinus Torvalds static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct 434bd4c625cSLinus Torvalds super_block 435bd4c625cSLinus Torvalds *sb, 436bd4c625cSLinus Torvalds struct 437bd4c625cSLinus Torvalds reiserfs_journal_cnode 438bd4c625cSLinus Torvalds **table, 4391da177e4SLinus Torvalds long bl) 4401da177e4SLinus Torvalds { 4411da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 4421da177e4SLinus Torvalds cn = journal_hash(table, sb, bl); 4431da177e4SLinus Torvalds while (cn) { 4441da177e4SLinus Torvalds if (cn->blocknr == bl && cn->sb == sb) 4451da177e4SLinus Torvalds return cn; 4461da177e4SLinus Torvalds cn = cn->hnext; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds return (struct reiserfs_journal_cnode *)0; 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds /* 4521da177e4SLinus Torvalds ** this actually means 'can this block be reallocated yet?'. If you set search_all, a block can only be allocated 4531da177e4SLinus Torvalds ** if it is not in the current transaction, was not freed by the current transaction, and has no chance of ever 4541da177e4SLinus Torvalds ** being overwritten by a replay after crashing. 4551da177e4SLinus Torvalds ** 4561da177e4SLinus Torvalds ** If you don't set search_all, a block can only be allocated if it is not in the current transaction. Since deleting 4571da177e4SLinus Torvalds ** a block removes it from the current transaction, this case should never happen. If you don't set search_all, make 4581da177e4SLinus Torvalds ** sure you never write the block without logging it. 4591da177e4SLinus Torvalds ** 4601da177e4SLinus Torvalds ** next_zero_bit is a suggestion about the next block to try for find_forward. 4611da177e4SLinus Torvalds ** when bl is rejected because it is set in a journal list bitmap, we search 4621da177e4SLinus Torvalds ** for the next zero bit in the bitmap that rejected bl. Then, we return that 4631da177e4SLinus Torvalds ** through next_zero_bit for find_forward to try. 4641da177e4SLinus Torvalds ** 4651da177e4SLinus Torvalds ** Just because we return something in next_zero_bit does not mean we won't 4661da177e4SLinus Torvalds ** reject it on the next call to reiserfs_in_journal 4671da177e4SLinus Torvalds ** 4681da177e4SLinus Torvalds */ 469a9dd3643SJeff Mahoney int reiserfs_in_journal(struct super_block *sb, 4703ee16670SJeff Mahoney unsigned int bmap_nr, int bit_nr, int search_all, 471bd4c625cSLinus Torvalds b_blocknr_t * next_zero_bit) 472bd4c625cSLinus Torvalds { 473a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 4741da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 4751da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb; 4761da177e4SLinus Torvalds int i; 4771da177e4SLinus Torvalds unsigned long bl; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds *next_zero_bit = 0; /* always start this at zero. */ 4801da177e4SLinus Torvalds 481a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.in_journal); 4821da177e4SLinus Torvalds /* If we aren't doing a search_all, this is a metablock, and it will be logged before use. 4831da177e4SLinus Torvalds ** if we crash before the transaction that freed it commits, this transaction won't 4841da177e4SLinus Torvalds ** have committed either, and the block will never be written 4851da177e4SLinus Torvalds */ 4861da177e4SLinus Torvalds if (search_all) { 4871da177e4SLinus Torvalds for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 488a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.in_journal_bitmap); 4891da177e4SLinus Torvalds jb = journal->j_list_bitmap + i; 4901da177e4SLinus Torvalds if (jb->journal_list && jb->bitmaps[bmap_nr] && 491bd4c625cSLinus Torvalds test_bit(bit_nr, 492bd4c625cSLinus Torvalds (unsigned long *)jb->bitmaps[bmap_nr]-> 493bd4c625cSLinus Torvalds data)) { 494bd4c625cSLinus Torvalds *next_zero_bit = 495bd4c625cSLinus Torvalds find_next_zero_bit((unsigned long *) 496bd4c625cSLinus Torvalds (jb->bitmaps[bmap_nr]-> 497bd4c625cSLinus Torvalds data), 498a9dd3643SJeff Mahoney sb->s_blocksize << 3, 499bd4c625cSLinus Torvalds bit_nr + 1); 5001da177e4SLinus Torvalds return 1; 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 505a9dd3643SJeff Mahoney bl = bmap_nr * (sb->s_blocksize << 3) + bit_nr; 5061da177e4SLinus Torvalds /* is it in any old transactions? */ 507bd4c625cSLinus Torvalds if (search_all 508bd4c625cSLinus Torvalds && (cn = 509a9dd3643SJeff Mahoney get_journal_hash_dev(sb, journal->j_list_hash_table, bl))) { 5101da177e4SLinus Torvalds return 1; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds /* is it in the current transaction. This should never happen */ 514a9dd3643SJeff Mahoney if ((cn = get_journal_hash_dev(sb, journal->j_hash_table, bl))) { 5151da177e4SLinus Torvalds BUG(); 5161da177e4SLinus Torvalds return 1; 5171da177e4SLinus Torvalds } 5181da177e4SLinus Torvalds 519a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.in_journal_reusable); 5201da177e4SLinus Torvalds /* safe for reuse */ 5211da177e4SLinus Torvalds return 0; 5221da177e4SLinus Torvalds } 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds /* insert cn into table 5251da177e4SLinus Torvalds */ 526bd4c625cSLinus Torvalds static inline void insert_journal_hash(struct reiserfs_journal_cnode **table, 527bd4c625cSLinus Torvalds struct reiserfs_journal_cnode *cn) 528bd4c625cSLinus Torvalds { 5291da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn_orig; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds cn_orig = journal_hash(table, cn->sb, cn->blocknr); 5321da177e4SLinus Torvalds cn->hnext = cn_orig; 5331da177e4SLinus Torvalds cn->hprev = NULL; 5341da177e4SLinus Torvalds if (cn_orig) { 5351da177e4SLinus Torvalds cn_orig->hprev = cn; 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds journal_hash(table, cn->sb, cn->blocknr) = cn; 5381da177e4SLinus Torvalds } 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds /* lock the current transaction */ 541a9dd3643SJeff Mahoney static inline void lock_journal(struct super_block *sb) 542bd4c625cSLinus Torvalds { 543a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.lock_journal); 5448ebc4232SFrederic Weisbecker 5458ebc4232SFrederic Weisbecker reiserfs_mutex_lock_safe(&SB_JOURNAL(sb)->j_mutex, sb); 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds /* unlock the current transaction */ 549a9dd3643SJeff Mahoney static inline void unlock_journal(struct super_block *sb) 550bd4c625cSLinus Torvalds { 551a9dd3643SJeff Mahoney mutex_unlock(&SB_JOURNAL(sb)->j_mutex); 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds static inline void get_journal_list(struct reiserfs_journal_list *jl) 5551da177e4SLinus Torvalds { 5561da177e4SLinus Torvalds jl->j_refcount++; 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds static inline void put_journal_list(struct super_block *s, 5601da177e4SLinus Torvalds struct reiserfs_journal_list *jl) 5611da177e4SLinus Torvalds { 5621da177e4SLinus Torvalds if (jl->j_refcount < 1) { 563c3a9c210SJeff Mahoney reiserfs_panic(s, "journal-2", "trans id %u, refcount at %d", 564bd4c625cSLinus Torvalds jl->j_trans_id, jl->j_refcount); 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds if (--jl->j_refcount == 0) 567d739b42bSPekka Enberg kfree(jl); 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds /* 5711da177e4SLinus Torvalds ** this used to be much more involved, and I'm keeping it just in case things get ugly again. 5721da177e4SLinus Torvalds ** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a 5731da177e4SLinus Torvalds ** transaction. 5741da177e4SLinus Torvalds */ 575a9dd3643SJeff Mahoney static void cleanup_freed_for_journal_list(struct super_block *sb, 576bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl) 577bd4c625cSLinus Torvalds { 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb = jl->j_list_bitmap; 5801da177e4SLinus Torvalds if (jb) { 581a9dd3643SJeff Mahoney cleanup_bitmap_list(sb, jb); 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds jl->j_list_bitmap->journal_list = NULL; 5841da177e4SLinus Torvalds jl->j_list_bitmap = NULL; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds static int journal_list_still_alive(struct super_block *s, 588600ed416SJeff Mahoney unsigned int trans_id) 5891da177e4SLinus Torvalds { 5901da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 5911da177e4SLinus Torvalds struct list_head *entry = &journal->j_journal_list; 5921da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds if (!list_empty(entry)) { 5951da177e4SLinus Torvalds jl = JOURNAL_LIST_ENTRY(entry->next); 5961da177e4SLinus Torvalds if (jl->j_trans_id <= trans_id) { 5971da177e4SLinus Torvalds return 1; 5981da177e4SLinus Torvalds } 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds return 0; 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 603398c95bdSChris Mason /* 604398c95bdSChris Mason * If page->mapping was null, we failed to truncate this page for 605398c95bdSChris Mason * some reason. Most likely because it was truncated after being 606398c95bdSChris Mason * logged via data=journal. 607398c95bdSChris Mason * 608398c95bdSChris Mason * This does a check to see if the buffer belongs to one of these 609398c95bdSChris Mason * lost pages before doing the final put_bh. If page->mapping was 610398c95bdSChris Mason * null, it tries to free buffers on the page, which should make the 611398c95bdSChris Mason * final page_cache_release drop the page from the lru. 612398c95bdSChris Mason */ 613398c95bdSChris Mason static void release_buffer_page(struct buffer_head *bh) 614398c95bdSChris Mason { 615398c95bdSChris Mason struct page *page = bh->b_page; 616529ae9aaSNick Piggin if (!page->mapping && trylock_page(page)) { 617398c95bdSChris Mason page_cache_get(page); 618398c95bdSChris Mason put_bh(bh); 619398c95bdSChris Mason if (!page->mapping) 620398c95bdSChris Mason try_to_free_buffers(page); 621398c95bdSChris Mason unlock_page(page); 622398c95bdSChris Mason page_cache_release(page); 623398c95bdSChris Mason } else { 624398c95bdSChris Mason put_bh(bh); 625398c95bdSChris Mason } 626398c95bdSChris Mason } 627398c95bdSChris Mason 628bd4c625cSLinus Torvalds static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate) 629bd4c625cSLinus Torvalds { 6301da177e4SLinus Torvalds char b[BDEVNAME_SIZE]; 6311da177e4SLinus Torvalds 6321da177e4SLinus Torvalds if (buffer_journaled(bh)) { 63345b03d5eSJeff Mahoney reiserfs_warning(NULL, "clm-2084", 63445b03d5eSJeff Mahoney "pinned buffer %lu:%s sent to disk", 6351da177e4SLinus Torvalds bh->b_blocknr, bdevname(bh->b_bdev, b)); 6361da177e4SLinus Torvalds } 6371da177e4SLinus Torvalds if (uptodate) 6381da177e4SLinus Torvalds set_buffer_uptodate(bh); 6391da177e4SLinus Torvalds else 6401da177e4SLinus Torvalds clear_buffer_uptodate(bh); 641398c95bdSChris Mason 6421da177e4SLinus Torvalds unlock_buffer(bh); 643398c95bdSChris Mason release_buffer_page(bh); 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds 646bd4c625cSLinus Torvalds static void reiserfs_end_ordered_io(struct buffer_head *bh, int uptodate) 647bd4c625cSLinus Torvalds { 6481da177e4SLinus Torvalds if (uptodate) 6491da177e4SLinus Torvalds set_buffer_uptodate(bh); 6501da177e4SLinus Torvalds else 6511da177e4SLinus Torvalds clear_buffer_uptodate(bh); 6521da177e4SLinus Torvalds unlock_buffer(bh); 6531da177e4SLinus Torvalds put_bh(bh); 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds 656bd4c625cSLinus Torvalds static void submit_logged_buffer(struct buffer_head *bh) 657bd4c625cSLinus Torvalds { 6581da177e4SLinus Torvalds get_bh(bh); 6591da177e4SLinus Torvalds bh->b_end_io = reiserfs_end_buffer_io_sync; 6601da177e4SLinus Torvalds clear_buffer_journal_new(bh); 6611da177e4SLinus Torvalds clear_buffer_dirty(bh); 6621da177e4SLinus Torvalds if (!test_clear_buffer_journal_test(bh)) 6631da177e4SLinus Torvalds BUG(); 6641da177e4SLinus Torvalds if (!buffer_uptodate(bh)) 6651da177e4SLinus Torvalds BUG(); 6661da177e4SLinus Torvalds submit_bh(WRITE, bh); 6671da177e4SLinus Torvalds } 6681da177e4SLinus Torvalds 669bd4c625cSLinus Torvalds static void submit_ordered_buffer(struct buffer_head *bh) 670bd4c625cSLinus Torvalds { 6711da177e4SLinus Torvalds get_bh(bh); 6721da177e4SLinus Torvalds bh->b_end_io = reiserfs_end_ordered_io; 6731da177e4SLinus Torvalds clear_buffer_dirty(bh); 6741da177e4SLinus Torvalds if (!buffer_uptodate(bh)) 6751da177e4SLinus Torvalds BUG(); 6761da177e4SLinus Torvalds submit_bh(WRITE, bh); 6771da177e4SLinus Torvalds } 6781da177e4SLinus Torvalds 679bd4c625cSLinus Torvalds static int submit_barrier_buffer(struct buffer_head *bh) 680bd4c625cSLinus Torvalds { 6811da177e4SLinus Torvalds get_bh(bh); 6821da177e4SLinus Torvalds bh->b_end_io = reiserfs_end_ordered_io; 6831da177e4SLinus Torvalds clear_buffer_dirty(bh); 6841da177e4SLinus Torvalds if (!buffer_uptodate(bh)) 6851da177e4SLinus Torvalds BUG(); 6861da177e4SLinus Torvalds return submit_bh(WRITE_BARRIER, bh); 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds static void check_barrier_completion(struct super_block *s, 690bd4c625cSLinus Torvalds struct buffer_head *bh) 691bd4c625cSLinus Torvalds { 6921da177e4SLinus Torvalds if (buffer_eopnotsupp(bh)) { 6931da177e4SLinus Torvalds clear_buffer_eopnotsupp(bh); 6941da177e4SLinus Torvalds disable_barrier(s); 6951da177e4SLinus Torvalds set_buffer_uptodate(bh); 6961da177e4SLinus Torvalds set_buffer_dirty(bh); 6978ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 6981da177e4SLinus Torvalds sync_dirty_buffer(bh); 6998ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 7001da177e4SLinus Torvalds } 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds #define CHUNK_SIZE 32 7041da177e4SLinus Torvalds struct buffer_chunk { 7051da177e4SLinus Torvalds struct buffer_head *bh[CHUNK_SIZE]; 7061da177e4SLinus Torvalds int nr; 7071da177e4SLinus Torvalds }; 7081da177e4SLinus Torvalds 709bd4c625cSLinus Torvalds static void write_chunk(struct buffer_chunk *chunk) 710bd4c625cSLinus Torvalds { 7111da177e4SLinus Torvalds int i; 71222e2c507SJens Axboe get_fs_excl(); 7131da177e4SLinus Torvalds for (i = 0; i < chunk->nr; i++) { 7141da177e4SLinus Torvalds submit_logged_buffer(chunk->bh[i]); 7151da177e4SLinus Torvalds } 7161da177e4SLinus Torvalds chunk->nr = 0; 71722e2c507SJens Axboe put_fs_excl(); 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds 720bd4c625cSLinus Torvalds static void write_ordered_chunk(struct buffer_chunk *chunk) 721bd4c625cSLinus Torvalds { 7221da177e4SLinus Torvalds int i; 72322e2c507SJens Axboe get_fs_excl(); 7241da177e4SLinus Torvalds for (i = 0; i < chunk->nr; i++) { 7251da177e4SLinus Torvalds submit_ordered_buffer(chunk->bh[i]); 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds chunk->nr = 0; 72822e2c507SJens Axboe put_fs_excl(); 7291da177e4SLinus Torvalds } 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh, 732bd4c625cSLinus Torvalds spinlock_t * lock, void (fn) (struct buffer_chunk *)) 7331da177e4SLinus Torvalds { 7341da177e4SLinus Torvalds int ret = 0; 73514a61442SEric Sesterhenn BUG_ON(chunk->nr >= CHUNK_SIZE); 7361da177e4SLinus Torvalds chunk->bh[chunk->nr++] = bh; 7371da177e4SLinus Torvalds if (chunk->nr >= CHUNK_SIZE) { 7381da177e4SLinus Torvalds ret = 1; 7391da177e4SLinus Torvalds if (lock) 7401da177e4SLinus Torvalds spin_unlock(lock); 7411da177e4SLinus Torvalds fn(chunk); 7421da177e4SLinus Torvalds if (lock) 7431da177e4SLinus Torvalds spin_lock(lock); 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds return ret; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds static atomic_t nr_reiserfs_jh = ATOMIC_INIT(0); 749bd4c625cSLinus Torvalds static struct reiserfs_jh *alloc_jh(void) 750bd4c625cSLinus Torvalds { 7511da177e4SLinus Torvalds struct reiserfs_jh *jh; 7521da177e4SLinus Torvalds while (1) { 7531da177e4SLinus Torvalds jh = kmalloc(sizeof(*jh), GFP_NOFS); 7541da177e4SLinus Torvalds if (jh) { 7551da177e4SLinus Torvalds atomic_inc(&nr_reiserfs_jh); 7561da177e4SLinus Torvalds return jh; 7571da177e4SLinus Torvalds } 7581da177e4SLinus Torvalds yield(); 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds /* 7631da177e4SLinus Torvalds * we want to free the jh when the buffer has been written 7641da177e4SLinus Torvalds * and waited on 7651da177e4SLinus Torvalds */ 766bd4c625cSLinus Torvalds void reiserfs_free_jh(struct buffer_head *bh) 767bd4c625cSLinus Torvalds { 7681da177e4SLinus Torvalds struct reiserfs_jh *jh; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds jh = bh->b_private; 7711da177e4SLinus Torvalds if (jh) { 7721da177e4SLinus Torvalds bh->b_private = NULL; 7731da177e4SLinus Torvalds jh->bh = NULL; 7741da177e4SLinus Torvalds list_del_init(&jh->list); 7751da177e4SLinus Torvalds kfree(jh); 7761da177e4SLinus Torvalds if (atomic_read(&nr_reiserfs_jh) <= 0) 7771da177e4SLinus Torvalds BUG(); 7781da177e4SLinus Torvalds atomic_dec(&nr_reiserfs_jh); 7791da177e4SLinus Torvalds put_bh(bh); 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh, 7841da177e4SLinus Torvalds int tail) 7851da177e4SLinus Torvalds { 7861da177e4SLinus Torvalds struct reiserfs_jh *jh; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds if (bh->b_private) { 7891da177e4SLinus Torvalds spin_lock(&j->j_dirty_buffers_lock); 7901da177e4SLinus Torvalds if (!bh->b_private) { 7911da177e4SLinus Torvalds spin_unlock(&j->j_dirty_buffers_lock); 7921da177e4SLinus Torvalds goto no_jh; 7931da177e4SLinus Torvalds } 7941da177e4SLinus Torvalds jh = bh->b_private; 7951da177e4SLinus Torvalds list_del_init(&jh->list); 7961da177e4SLinus Torvalds } else { 7971da177e4SLinus Torvalds no_jh: 7981da177e4SLinus Torvalds get_bh(bh); 7991da177e4SLinus Torvalds jh = alloc_jh(); 8001da177e4SLinus Torvalds spin_lock(&j->j_dirty_buffers_lock); 8011da177e4SLinus Torvalds /* buffer must be locked for __add_jh, should be able to have 8021da177e4SLinus Torvalds * two adds at the same time 8031da177e4SLinus Torvalds */ 80414a61442SEric Sesterhenn BUG_ON(bh->b_private); 8051da177e4SLinus Torvalds jh->bh = bh; 8061da177e4SLinus Torvalds bh->b_private = jh; 8071da177e4SLinus Torvalds } 8081da177e4SLinus Torvalds jh->jl = j->j_current_jl; 8091da177e4SLinus Torvalds if (tail) 8101da177e4SLinus Torvalds list_add_tail(&jh->list, &jh->jl->j_tail_bh_list); 8111da177e4SLinus Torvalds else { 8121da177e4SLinus Torvalds list_add_tail(&jh->list, &jh->jl->j_bh_list); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds spin_unlock(&j->j_dirty_buffers_lock); 8151da177e4SLinus Torvalds return 0; 8161da177e4SLinus Torvalds } 8171da177e4SLinus Torvalds 818bd4c625cSLinus Torvalds int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh) 819bd4c625cSLinus Torvalds { 8201da177e4SLinus Torvalds return __add_jh(SB_JOURNAL(inode->i_sb), bh, 1); 8211da177e4SLinus Torvalds } 822bd4c625cSLinus Torvalds int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh) 823bd4c625cSLinus Torvalds { 8241da177e4SLinus Torvalds return __add_jh(SB_JOURNAL(inode->i_sb), bh, 0); 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds #define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list) 8281da177e4SLinus Torvalds static int write_ordered_buffers(spinlock_t * lock, 8291da177e4SLinus Torvalds struct reiserfs_journal *j, 8301da177e4SLinus Torvalds struct reiserfs_journal_list *jl, 8311da177e4SLinus Torvalds struct list_head *list) 8321da177e4SLinus Torvalds { 8331da177e4SLinus Torvalds struct buffer_head *bh; 8341da177e4SLinus Torvalds struct reiserfs_jh *jh; 8351da177e4SLinus Torvalds int ret = j->j_errno; 8361da177e4SLinus Torvalds struct buffer_chunk chunk; 8371da177e4SLinus Torvalds struct list_head tmp; 8381da177e4SLinus Torvalds INIT_LIST_HEAD(&tmp); 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds chunk.nr = 0; 8411da177e4SLinus Torvalds spin_lock(lock); 8421da177e4SLinus Torvalds while (!list_empty(list)) { 8431da177e4SLinus Torvalds jh = JH_ENTRY(list->next); 8441da177e4SLinus Torvalds bh = jh->bh; 8451da177e4SLinus Torvalds get_bh(bh); 846ca5de404SNick Piggin if (!trylock_buffer(bh)) { 8471da177e4SLinus Torvalds if (!buffer_dirty(bh)) { 848f116629dSAkinobu Mita list_move(&jh->list, &tmp); 8491da177e4SLinus Torvalds goto loop_next; 8501da177e4SLinus Torvalds } 8511da177e4SLinus Torvalds spin_unlock(lock); 8521da177e4SLinus Torvalds if (chunk.nr) 8531da177e4SLinus Torvalds write_ordered_chunk(&chunk); 8541da177e4SLinus Torvalds wait_on_buffer(bh); 8551da177e4SLinus Torvalds cond_resched(); 8561da177e4SLinus Torvalds spin_lock(lock); 8571da177e4SLinus Torvalds goto loop_next; 8581da177e4SLinus Torvalds } 8593d4492f8SChris Mason /* in theory, dirty non-uptodate buffers should never get here, 8603d4492f8SChris Mason * but the upper layer io error paths still have a few quirks. 8613d4492f8SChris Mason * Handle them here as gracefully as we can 8623d4492f8SChris Mason */ 8633d4492f8SChris Mason if (!buffer_uptodate(bh) && buffer_dirty(bh)) { 8643d4492f8SChris Mason clear_buffer_dirty(bh); 8653d4492f8SChris Mason ret = -EIO; 8663d4492f8SChris Mason } 8671da177e4SLinus Torvalds if (buffer_dirty(bh)) { 868f116629dSAkinobu Mita list_move(&jh->list, &tmp); 8691da177e4SLinus Torvalds add_to_chunk(&chunk, bh, lock, write_ordered_chunk); 8701da177e4SLinus Torvalds } else { 8711da177e4SLinus Torvalds reiserfs_free_jh(bh); 8721da177e4SLinus Torvalds unlock_buffer(bh); 8731da177e4SLinus Torvalds } 8741da177e4SLinus Torvalds loop_next: 8751da177e4SLinus Torvalds put_bh(bh); 8761da177e4SLinus Torvalds cond_resched_lock(lock); 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds if (chunk.nr) { 8791da177e4SLinus Torvalds spin_unlock(lock); 8801da177e4SLinus Torvalds write_ordered_chunk(&chunk); 8811da177e4SLinus Torvalds spin_lock(lock); 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds while (!list_empty(&tmp)) { 8841da177e4SLinus Torvalds jh = JH_ENTRY(tmp.prev); 8851da177e4SLinus Torvalds bh = jh->bh; 8861da177e4SLinus Torvalds get_bh(bh); 8871da177e4SLinus Torvalds reiserfs_free_jh(bh); 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds if (buffer_locked(bh)) { 8901da177e4SLinus Torvalds spin_unlock(lock); 8911da177e4SLinus Torvalds wait_on_buffer(bh); 8921da177e4SLinus Torvalds spin_lock(lock); 8931da177e4SLinus Torvalds } 8941da177e4SLinus Torvalds if (!buffer_uptodate(bh)) { 8951da177e4SLinus Torvalds ret = -EIO; 8961da177e4SLinus Torvalds } 897d62b1b87SChris Mason /* ugly interaction with invalidatepage here. 898d62b1b87SChris Mason * reiserfs_invalidate_page will pin any buffer that has a valid 899d62b1b87SChris Mason * journal head from an older transaction. If someone else sets 900d62b1b87SChris Mason * our buffer dirty after we write it in the first loop, and 901d62b1b87SChris Mason * then someone truncates the page away, nobody will ever write 902d62b1b87SChris Mason * the buffer. We're safe if we write the page one last time 903d62b1b87SChris Mason * after freeing the journal header. 904d62b1b87SChris Mason */ 905d62b1b87SChris Mason if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) { 906d62b1b87SChris Mason spin_unlock(lock); 907d62b1b87SChris Mason ll_rw_block(WRITE, 1, &bh); 908d62b1b87SChris Mason spin_lock(lock); 909d62b1b87SChris Mason } 9101da177e4SLinus Torvalds put_bh(bh); 9111da177e4SLinus Torvalds cond_resched_lock(lock); 9121da177e4SLinus Torvalds } 9131da177e4SLinus Torvalds spin_unlock(lock); 9141da177e4SLinus Torvalds return ret; 9151da177e4SLinus Torvalds } 9161da177e4SLinus Torvalds 917bd4c625cSLinus Torvalds static int flush_older_commits(struct super_block *s, 918bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl) 919bd4c625cSLinus Torvalds { 9201da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 9211da177e4SLinus Torvalds struct reiserfs_journal_list *other_jl; 9221da177e4SLinus Torvalds struct reiserfs_journal_list *first_jl; 9231da177e4SLinus Torvalds struct list_head *entry; 924600ed416SJeff Mahoney unsigned int trans_id = jl->j_trans_id; 925600ed416SJeff Mahoney unsigned int other_trans_id; 926600ed416SJeff Mahoney unsigned int first_trans_id; 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds find_first: 9291da177e4SLinus Torvalds /* 9301da177e4SLinus Torvalds * first we walk backwards to find the oldest uncommitted transation 9311da177e4SLinus Torvalds */ 9321da177e4SLinus Torvalds first_jl = jl; 9331da177e4SLinus Torvalds entry = jl->j_list.prev; 9341da177e4SLinus Torvalds while (1) { 9351da177e4SLinus Torvalds other_jl = JOURNAL_LIST_ENTRY(entry); 9361da177e4SLinus Torvalds if (entry == &journal->j_journal_list || 9371da177e4SLinus Torvalds atomic_read(&other_jl->j_older_commits_done)) 9381da177e4SLinus Torvalds break; 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds first_jl = other_jl; 9411da177e4SLinus Torvalds entry = other_jl->j_list.prev; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds /* if we didn't find any older uncommitted transactions, return now */ 9451da177e4SLinus Torvalds if (first_jl == jl) { 9461da177e4SLinus Torvalds return 0; 9471da177e4SLinus Torvalds } 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds first_trans_id = first_jl->j_trans_id; 9501da177e4SLinus Torvalds 9511da177e4SLinus Torvalds entry = &first_jl->j_list; 9521da177e4SLinus Torvalds while (1) { 9531da177e4SLinus Torvalds other_jl = JOURNAL_LIST_ENTRY(entry); 9541da177e4SLinus Torvalds other_trans_id = other_jl->j_trans_id; 9551da177e4SLinus Torvalds 9561da177e4SLinus Torvalds if (other_trans_id < trans_id) { 9571da177e4SLinus Torvalds if (atomic_read(&other_jl->j_commit_left) != 0) { 9581da177e4SLinus Torvalds flush_commit_list(s, other_jl, 0); 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds /* list we were called with is gone, return */ 9611da177e4SLinus Torvalds if (!journal_list_still_alive(s, trans_id)) 9621da177e4SLinus Torvalds return 1; 9631da177e4SLinus Torvalds 9641da177e4SLinus Torvalds /* the one we just flushed is gone, this means all 9651da177e4SLinus Torvalds * older lists are also gone, so first_jl is no longer 9661da177e4SLinus Torvalds * valid either. Go back to the beginning. 9671da177e4SLinus Torvalds */ 968bd4c625cSLinus Torvalds if (!journal_list_still_alive 969bd4c625cSLinus Torvalds (s, other_trans_id)) { 9701da177e4SLinus Torvalds goto find_first; 9711da177e4SLinus Torvalds } 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds entry = entry->next; 9741da177e4SLinus Torvalds if (entry == &journal->j_journal_list) 9751da177e4SLinus Torvalds return 0; 9761da177e4SLinus Torvalds } else { 9771da177e4SLinus Torvalds return 0; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds } 9801da177e4SLinus Torvalds return 0; 9811da177e4SLinus Torvalds } 982deba0f49SAdrian Bunk 983deba0f49SAdrian Bunk static int reiserfs_async_progress_wait(struct super_block *s) 984bd4c625cSLinus Torvalds { 9851da177e4SLinus Torvalds DEFINE_WAIT(wait); 9861da177e4SLinus Torvalds struct reiserfs_journal *j = SB_JOURNAL(s); 9878ebc4232SFrederic Weisbecker 9888ebc4232SFrederic Weisbecker if (atomic_read(&j->j_async_throttle)) { 9898ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 9908aa7e847SJens Axboe congestion_wait(BLK_RW_ASYNC, HZ / 10); 9918ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 9928ebc4232SFrederic Weisbecker } 9938ebc4232SFrederic Weisbecker 9941da177e4SLinus Torvalds return 0; 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds /* 9981da177e4SLinus Torvalds ** if this journal list still has commit blocks unflushed, send them to disk. 9991da177e4SLinus Torvalds ** 10001da177e4SLinus Torvalds ** log areas must be flushed in order (transaction 2 can't commit before transaction 1) 10011da177e4SLinus Torvalds ** Before the commit block can by written, every other log block must be safely on disk 10021da177e4SLinus Torvalds ** 10031da177e4SLinus Torvalds */ 1004bd4c625cSLinus Torvalds static int flush_commit_list(struct super_block *s, 1005bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl, int flushall) 1006bd4c625cSLinus Torvalds { 10071da177e4SLinus Torvalds int i; 10083ee16670SJeff Mahoney b_blocknr_t bn; 10091da177e4SLinus Torvalds struct buffer_head *tbh = NULL; 1010600ed416SJeff Mahoney unsigned int trans_id = jl->j_trans_id; 10111da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 10121da177e4SLinus Torvalds int barrier = 0; 10131da177e4SLinus Torvalds int retval = 0; 1014e0e851cfSChris Mason int write_len; 10151da177e4SLinus Torvalds 10161da177e4SLinus Torvalds reiserfs_check_lock_depth(s, "flush_commit_list"); 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds if (atomic_read(&jl->j_older_commits_done)) { 10191da177e4SLinus Torvalds return 0; 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds 102222e2c507SJens Axboe get_fs_excl(); 102322e2c507SJens Axboe 10241da177e4SLinus Torvalds /* before we can put our commit blocks on disk, we have to make sure everyone older than 10251da177e4SLinus Torvalds ** us is on disk too 10261da177e4SLinus Torvalds */ 10271da177e4SLinus Torvalds BUG_ON(jl->j_len <= 0); 10281da177e4SLinus Torvalds BUG_ON(trans_id == journal->j_trans_id); 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds get_journal_list(jl); 10311da177e4SLinus Torvalds if (flushall) { 10321da177e4SLinus Torvalds if (flush_older_commits(s, jl) == 1) { 10331da177e4SLinus Torvalds /* list disappeared during flush_older_commits. return */ 10341da177e4SLinus Torvalds goto put_jl; 10351da177e4SLinus Torvalds } 10361da177e4SLinus Torvalds } 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds /* make sure nobody is trying to flush this one at the same time */ 10398ebc4232SFrederic Weisbecker reiserfs_mutex_lock_safe(&jl->j_commit_mutex, s); 10408ebc4232SFrederic Weisbecker 10411da177e4SLinus Torvalds if (!journal_list_still_alive(s, trans_id)) { 104290415deaSJeff Mahoney mutex_unlock(&jl->j_commit_mutex); 10431da177e4SLinus Torvalds goto put_jl; 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds BUG_ON(jl->j_trans_id == 0); 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds /* this commit is done, exit */ 10481da177e4SLinus Torvalds if (atomic_read(&(jl->j_commit_left)) <= 0) { 10491da177e4SLinus Torvalds if (flushall) { 10501da177e4SLinus Torvalds atomic_set(&(jl->j_older_commits_done), 1); 10511da177e4SLinus Torvalds } 105290415deaSJeff Mahoney mutex_unlock(&jl->j_commit_mutex); 10531da177e4SLinus Torvalds goto put_jl; 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds if (!list_empty(&jl->j_bh_list)) { 10573d4492f8SChris Mason int ret; 10588ebc4232SFrederic Weisbecker 10598ebc4232SFrederic Weisbecker /* 10608ebc4232SFrederic Weisbecker * We might sleep in numerous places inside 10618ebc4232SFrederic Weisbecker * write_ordered_buffers. Relax the write lock. 10628ebc4232SFrederic Weisbecker */ 10638ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 10643d4492f8SChris Mason ret = write_ordered_buffers(&journal->j_dirty_buffers_lock, 10651da177e4SLinus Torvalds journal, jl, &jl->j_bh_list); 10663d4492f8SChris Mason if (ret < 0 && retval == 0) 10673d4492f8SChris Mason retval = ret; 10688ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 10691da177e4SLinus Torvalds } 10701da177e4SLinus Torvalds BUG_ON(!list_empty(&jl->j_bh_list)); 10711da177e4SLinus Torvalds /* 10721da177e4SLinus Torvalds * for the description block and all the log blocks, submit any buffers 1073e0e851cfSChris Mason * that haven't already reached the disk. Try to write at least 256 1074e0e851cfSChris Mason * log blocks. later on, we will only wait on blocks that correspond 1075e0e851cfSChris Mason * to this transaction, but while we're unplugging we might as well 1076e0e851cfSChris Mason * get a chunk of data on there. 10771da177e4SLinus Torvalds */ 10781da177e4SLinus Torvalds atomic_inc(&journal->j_async_throttle); 1079e0e851cfSChris Mason write_len = jl->j_len + 1; 1080e0e851cfSChris Mason if (write_len < 256) 1081e0e851cfSChris Mason write_len = 256; 1082e0e851cfSChris Mason for (i = 0 ; i < write_len ; i++) { 10831da177e4SLinus Torvalds bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) + (jl->j_start + i) % 10841da177e4SLinus Torvalds SB_ONDISK_JOURNAL_SIZE(s); 10851da177e4SLinus Torvalds tbh = journal_find_get_block(s, bn); 1086e0e851cfSChris Mason if (tbh) { 10876e3647acSFrederic Weisbecker if (buffer_dirty(tbh)) { 10886e3647acSFrederic Weisbecker reiserfs_write_unlock(s); 1089e0e851cfSChris Mason ll_rw_block(WRITE, 1, &tbh); 10906e3647acSFrederic Weisbecker reiserfs_write_lock(s); 10916e3647acSFrederic Weisbecker } 10921da177e4SLinus Torvalds put_bh(tbh) ; 10931da177e4SLinus Torvalds } 1094e0e851cfSChris Mason } 10951da177e4SLinus Torvalds atomic_dec(&journal->j_async_throttle); 10961da177e4SLinus Torvalds 10975d5e8156SJeff Mahoney /* We're skipping the commit if there's an error */ 10985d5e8156SJeff Mahoney if (retval || reiserfs_is_journal_aborted(journal)) 10995d5e8156SJeff Mahoney barrier = 0; 11005d5e8156SJeff Mahoney 11011da177e4SLinus Torvalds /* wait on everything written so far before writing the commit 11021da177e4SLinus Torvalds * if we are in barrier mode, send the commit down now 11031da177e4SLinus Torvalds */ 11041da177e4SLinus Torvalds barrier = reiserfs_barrier_flush(s); 11051da177e4SLinus Torvalds if (barrier) { 11061da177e4SLinus Torvalds int ret; 11071da177e4SLinus Torvalds lock_buffer(jl->j_commit_bh); 11081da177e4SLinus Torvalds ret = submit_barrier_buffer(jl->j_commit_bh); 11091da177e4SLinus Torvalds if (ret == -EOPNOTSUPP) { 11101da177e4SLinus Torvalds set_buffer_uptodate(jl->j_commit_bh); 11111da177e4SLinus Torvalds disable_barrier(s); 11121da177e4SLinus Torvalds barrier = 0; 11131da177e4SLinus Torvalds } 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds for (i = 0; i < (jl->j_len + 1); i++) { 11161da177e4SLinus Torvalds bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) + 11171da177e4SLinus Torvalds (jl->j_start + i) % SB_ONDISK_JOURNAL_SIZE(s); 11181da177e4SLinus Torvalds tbh = journal_find_get_block(s, bn); 11198ebc4232SFrederic Weisbecker 11208ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 11211da177e4SLinus Torvalds wait_on_buffer(tbh); 11228ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 11231da177e4SLinus Torvalds // since we're using ll_rw_blk above, it might have skipped over 11241da177e4SLinus Torvalds // a locked buffer. Double check here 11251da177e4SLinus Torvalds // 11268ebc4232SFrederic Weisbecker /* redundant, sync_dirty_buffer() checks */ 11278ebc4232SFrederic Weisbecker if (buffer_dirty(tbh)) { 11288ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 11291da177e4SLinus Torvalds sync_dirty_buffer(tbh); 11308ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 11318ebc4232SFrederic Weisbecker } 11321da177e4SLinus Torvalds if (unlikely(!buffer_uptodate(tbh))) { 11331da177e4SLinus Torvalds #ifdef CONFIG_REISERFS_CHECK 113445b03d5eSJeff Mahoney reiserfs_warning(s, "journal-601", 113545b03d5eSJeff Mahoney "buffer write failed"); 11361da177e4SLinus Torvalds #endif 11371da177e4SLinus Torvalds retval = -EIO; 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds put_bh(tbh); /* once for journal_find_get_block */ 11401da177e4SLinus Torvalds put_bh(tbh); /* once due to original getblk in do_journal_end */ 11411da177e4SLinus Torvalds atomic_dec(&(jl->j_commit_left)); 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds 11441da177e4SLinus Torvalds BUG_ON(atomic_read(&(jl->j_commit_left)) != 1); 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds if (!barrier) { 11475d5e8156SJeff Mahoney /* If there was a write error in the journal - we can't commit 11485d5e8156SJeff Mahoney * this transaction - it will be invalid and, if successful, 1149beb7dd86SRobert P. J. Day * will just end up propagating the write error out to 11505d5e8156SJeff Mahoney * the file system. */ 11515d5e8156SJeff Mahoney if (likely(!retval && !reiserfs_is_journal_aborted (journal))) { 11521da177e4SLinus Torvalds if (buffer_dirty(jl->j_commit_bh)) 11531da177e4SLinus Torvalds BUG(); 11541da177e4SLinus Torvalds mark_buffer_dirty(jl->j_commit_bh) ; 11558ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 11561da177e4SLinus Torvalds sync_dirty_buffer(jl->j_commit_bh) ; 11578ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 11585d5e8156SJeff Mahoney } 11598ebc4232SFrederic Weisbecker } else { 11608ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 11611da177e4SLinus Torvalds wait_on_buffer(jl->j_commit_bh); 11628ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 11638ebc4232SFrederic Weisbecker } 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds check_barrier_completion(s, jl->j_commit_bh); 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds /* If there was a write error in the journal - we can't commit this 11681da177e4SLinus Torvalds * transaction - it will be invalid and, if successful, will just end 1169beb7dd86SRobert P. J. Day * up propagating the write error out to the filesystem. */ 11701da177e4SLinus Torvalds if (unlikely(!buffer_uptodate(jl->j_commit_bh))) { 11711da177e4SLinus Torvalds #ifdef CONFIG_REISERFS_CHECK 117245b03d5eSJeff Mahoney reiserfs_warning(s, "journal-615", "buffer write failed"); 11731da177e4SLinus Torvalds #endif 11741da177e4SLinus Torvalds retval = -EIO; 11751da177e4SLinus Torvalds } 11761da177e4SLinus Torvalds bforget(jl->j_commit_bh); 11771da177e4SLinus Torvalds if (journal->j_last_commit_id != 0 && 11781da177e4SLinus Torvalds (jl->j_trans_id - journal->j_last_commit_id) != 1) { 117945b03d5eSJeff Mahoney reiserfs_warning(s, "clm-2200", "last commit %lu, current %lu", 1180bd4c625cSLinus Torvalds journal->j_last_commit_id, jl->j_trans_id); 11811da177e4SLinus Torvalds } 11821da177e4SLinus Torvalds journal->j_last_commit_id = jl->j_trans_id; 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds /* now, every commit block is on the disk. It is safe to allow blocks freed during this transaction to be reallocated */ 11851da177e4SLinus Torvalds cleanup_freed_for_journal_list(s, jl); 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds retval = retval ? retval : journal->j_errno; 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /* mark the metadata dirty */ 11901da177e4SLinus Torvalds if (!retval) 11911da177e4SLinus Torvalds dirty_one_transaction(s, jl); 11921da177e4SLinus Torvalds atomic_dec(&(jl->j_commit_left)); 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds if (flushall) { 11951da177e4SLinus Torvalds atomic_set(&(jl->j_older_commits_done), 1); 11961da177e4SLinus Torvalds } 119790415deaSJeff Mahoney mutex_unlock(&jl->j_commit_mutex); 11981da177e4SLinus Torvalds put_jl: 11991da177e4SLinus Torvalds put_journal_list(s, jl); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds if (retval) 1202bd4c625cSLinus Torvalds reiserfs_abort(s, retval, "Journal write error in %s", 1203fbe5498bSHarvey Harrison __func__); 120422e2c507SJens Axboe put_fs_excl(); 12051da177e4SLinus Torvalds return retval; 12061da177e4SLinus Torvalds } 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds /* 12091da177e4SLinus Torvalds ** flush_journal_list frequently needs to find a newer transaction for a given block. This does that, or 12101da177e4SLinus Torvalds ** returns NULL if it can't find anything 12111da177e4SLinus Torvalds */ 1212bd4c625cSLinus Torvalds static struct reiserfs_journal_list *find_newer_jl_for_cn(struct 1213bd4c625cSLinus Torvalds reiserfs_journal_cnode 1214bd4c625cSLinus Torvalds *cn) 1215bd4c625cSLinus Torvalds { 12161da177e4SLinus Torvalds struct super_block *sb = cn->sb; 12171da177e4SLinus Torvalds b_blocknr_t blocknr = cn->blocknr; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds cn = cn->hprev; 12201da177e4SLinus Torvalds while (cn) { 12211da177e4SLinus Torvalds if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist) { 12221da177e4SLinus Torvalds return cn->jlist; 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds cn = cn->hprev; 12251da177e4SLinus Torvalds } 12261da177e4SLinus Torvalds return NULL; 12271da177e4SLinus Torvalds } 12281da177e4SLinus Torvalds 1229a3172027SChris Mason static int newer_jl_done(struct reiserfs_journal_cnode *cn) 1230a3172027SChris Mason { 1231a3172027SChris Mason struct super_block *sb = cn->sb; 1232a3172027SChris Mason b_blocknr_t blocknr = cn->blocknr; 1233a3172027SChris Mason 1234a3172027SChris Mason cn = cn->hprev; 1235a3172027SChris Mason while (cn) { 1236a3172027SChris Mason if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist && 1237a3172027SChris Mason atomic_read(&cn->jlist->j_commit_left) != 0) 1238a3172027SChris Mason return 0; 1239a3172027SChris Mason cn = cn->hprev; 1240a3172027SChris Mason } 1241a3172027SChris Mason return 1; 1242a3172027SChris Mason } 1243a3172027SChris Mason 1244bd4c625cSLinus Torvalds static void remove_journal_hash(struct super_block *, 1245bd4c625cSLinus Torvalds struct reiserfs_journal_cnode **, 1246bd4c625cSLinus Torvalds struct reiserfs_journal_list *, unsigned long, 1247bd4c625cSLinus Torvalds int); 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds /* 12501da177e4SLinus Torvalds ** once all the real blocks have been flushed, it is safe to remove them from the 12511da177e4SLinus Torvalds ** journal list for this transaction. Aside from freeing the cnode, this also allows the 12521da177e4SLinus Torvalds ** block to be reallocated for data blocks if it had been deleted. 12531da177e4SLinus Torvalds */ 1254a9dd3643SJeff Mahoney static void remove_all_from_journal_list(struct super_block *sb, 1255bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl, 1256bd4c625cSLinus Torvalds int debug) 1257bd4c625cSLinus Torvalds { 1258a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 12591da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn, *last; 12601da177e4SLinus Torvalds cn = jl->j_realblock; 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds /* which is better, to lock once around the whole loop, or 12631da177e4SLinus Torvalds ** to lock for each call to remove_journal_hash? 12641da177e4SLinus Torvalds */ 12651da177e4SLinus Torvalds while (cn) { 12661da177e4SLinus Torvalds if (cn->blocknr != 0) { 12671da177e4SLinus Torvalds if (debug) { 1268a9dd3643SJeff Mahoney reiserfs_warning(sb, "reiserfs-2201", 1269bd4c625cSLinus Torvalds "block %u, bh is %d, state %ld", 1270bd4c625cSLinus Torvalds cn->blocknr, cn->bh ? 1 : 0, 1271bd4c625cSLinus Torvalds cn->state); 12721da177e4SLinus Torvalds } 12731da177e4SLinus Torvalds cn->state = 0; 1274a9dd3643SJeff Mahoney remove_journal_hash(sb, journal->j_list_hash_table, 1275bd4c625cSLinus Torvalds jl, cn->blocknr, 1); 12761da177e4SLinus Torvalds } 12771da177e4SLinus Torvalds last = cn; 12781da177e4SLinus Torvalds cn = cn->next; 1279a9dd3643SJeff Mahoney free_cnode(sb, last); 12801da177e4SLinus Torvalds } 12811da177e4SLinus Torvalds jl->j_realblock = NULL; 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds /* 12851da177e4SLinus Torvalds ** if this timestamp is greater than the timestamp we wrote last to the header block, write it to the header block. 12861da177e4SLinus Torvalds ** once this is done, I can safely say the log area for this transaction won't ever be replayed, and I can start 12871da177e4SLinus Torvalds ** releasing blocks in this transaction for reuse as data blocks. 12881da177e4SLinus Torvalds ** called by flush_journal_list, before it calls remove_all_from_journal_list 12891da177e4SLinus Torvalds ** 12901da177e4SLinus Torvalds */ 1291a9dd3643SJeff Mahoney static int _update_journal_header_block(struct super_block *sb, 1292bd4c625cSLinus Torvalds unsigned long offset, 1293600ed416SJeff Mahoney unsigned int trans_id) 1294bd4c625cSLinus Torvalds { 12951da177e4SLinus Torvalds struct reiserfs_journal_header *jh; 1296a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds if (reiserfs_is_journal_aborted(journal)) 12991da177e4SLinus Torvalds return -EIO; 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds if (trans_id >= journal->j_last_flush_trans_id) { 13021da177e4SLinus Torvalds if (buffer_locked((journal->j_header_bh))) { 13038ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 13041da177e4SLinus Torvalds wait_on_buffer((journal->j_header_bh)); 13058ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 13061da177e4SLinus Torvalds if (unlikely(!buffer_uptodate(journal->j_header_bh))) { 13071da177e4SLinus Torvalds #ifdef CONFIG_REISERFS_CHECK 1308a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-699", 130945b03d5eSJeff Mahoney "buffer write failed"); 13101da177e4SLinus Torvalds #endif 13111da177e4SLinus Torvalds return -EIO; 13121da177e4SLinus Torvalds } 13131da177e4SLinus Torvalds } 13141da177e4SLinus Torvalds journal->j_last_flush_trans_id = trans_id; 13151da177e4SLinus Torvalds journal->j_first_unflushed_offset = offset; 1316bd4c625cSLinus Torvalds jh = (struct reiserfs_journal_header *)(journal->j_header_bh-> 1317bd4c625cSLinus Torvalds b_data); 13181da177e4SLinus Torvalds jh->j_last_flush_trans_id = cpu_to_le32(trans_id); 13191da177e4SLinus Torvalds jh->j_first_unflushed_offset = cpu_to_le32(offset); 13201da177e4SLinus Torvalds jh->j_mount_id = cpu_to_le32(journal->j_mount_id); 13211da177e4SLinus Torvalds 1322a9dd3643SJeff Mahoney if (reiserfs_barrier_flush(sb)) { 13231da177e4SLinus Torvalds int ret; 13241da177e4SLinus Torvalds lock_buffer(journal->j_header_bh); 13251da177e4SLinus Torvalds ret = submit_barrier_buffer(journal->j_header_bh); 13261da177e4SLinus Torvalds if (ret == -EOPNOTSUPP) { 13271da177e4SLinus Torvalds set_buffer_uptodate(journal->j_header_bh); 1328a9dd3643SJeff Mahoney disable_barrier(sb); 13291da177e4SLinus Torvalds goto sync; 13301da177e4SLinus Torvalds } 13318ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 13321da177e4SLinus Torvalds wait_on_buffer(journal->j_header_bh); 13338ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 1334a9dd3643SJeff Mahoney check_barrier_completion(sb, journal->j_header_bh); 13351da177e4SLinus Torvalds } else { 13361da177e4SLinus Torvalds sync: 13371da177e4SLinus Torvalds set_buffer_dirty(journal->j_header_bh); 13388ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 13391da177e4SLinus Torvalds sync_dirty_buffer(journal->j_header_bh); 13408ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 13411da177e4SLinus Torvalds } 13421da177e4SLinus Torvalds if (!buffer_uptodate(journal->j_header_bh)) { 1343a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-837", 134445b03d5eSJeff Mahoney "IO error during journal replay"); 13451da177e4SLinus Torvalds return -EIO; 13461da177e4SLinus Torvalds } 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds return 0; 13491da177e4SLinus Torvalds } 13501da177e4SLinus Torvalds 1351a9dd3643SJeff Mahoney static int update_journal_header_block(struct super_block *sb, 13521da177e4SLinus Torvalds unsigned long offset, 1353600ed416SJeff Mahoney unsigned int trans_id) 1354bd4c625cSLinus Torvalds { 1355a9dd3643SJeff Mahoney return _update_journal_header_block(sb, offset, trans_id); 13561da177e4SLinus Torvalds } 1357bd4c625cSLinus Torvalds 13581da177e4SLinus Torvalds /* 13591da177e4SLinus Torvalds ** flush any and all journal lists older than you are 13601da177e4SLinus Torvalds ** can only be called from flush_journal_list 13611da177e4SLinus Torvalds */ 1362a9dd3643SJeff Mahoney static int flush_older_journal_lists(struct super_block *sb, 13631da177e4SLinus Torvalds struct reiserfs_journal_list *jl) 13641da177e4SLinus Torvalds { 13651da177e4SLinus Torvalds struct list_head *entry; 13661da177e4SLinus Torvalds struct reiserfs_journal_list *other_jl; 1367a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 1368600ed416SJeff Mahoney unsigned int trans_id = jl->j_trans_id; 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds /* we know we are the only ones flushing things, no extra race 13711da177e4SLinus Torvalds * protection is required. 13721da177e4SLinus Torvalds */ 13731da177e4SLinus Torvalds restart: 13741da177e4SLinus Torvalds entry = journal->j_journal_list.next; 13751da177e4SLinus Torvalds /* Did we wrap? */ 13761da177e4SLinus Torvalds if (entry == &journal->j_journal_list) 13771da177e4SLinus Torvalds return 0; 13781da177e4SLinus Torvalds other_jl = JOURNAL_LIST_ENTRY(entry); 13791da177e4SLinus Torvalds if (other_jl->j_trans_id < trans_id) { 13801da177e4SLinus Torvalds BUG_ON(other_jl->j_refcount <= 0); 13811da177e4SLinus Torvalds /* do not flush all */ 1382a9dd3643SJeff Mahoney flush_journal_list(sb, other_jl, 0); 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds /* other_jl is now deleted from the list */ 13851da177e4SLinus Torvalds goto restart; 13861da177e4SLinus Torvalds } 13871da177e4SLinus Torvalds return 0; 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds static void del_from_work_list(struct super_block *s, 1391bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl) 1392bd4c625cSLinus Torvalds { 13931da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 13941da177e4SLinus Torvalds if (!list_empty(&jl->j_working_list)) { 13951da177e4SLinus Torvalds list_del_init(&jl->j_working_list); 13961da177e4SLinus Torvalds journal->j_num_work_lists--; 13971da177e4SLinus Torvalds } 13981da177e4SLinus Torvalds } 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds /* flush a journal list, both commit and real blocks 14011da177e4SLinus Torvalds ** 14021da177e4SLinus Torvalds ** always set flushall to 1, unless you are calling from inside 14031da177e4SLinus Torvalds ** flush_journal_list 14041da177e4SLinus Torvalds ** 14051da177e4SLinus Torvalds ** IMPORTANT. This can only be called while there are no journal writers, 14061da177e4SLinus Torvalds ** and the journal is locked. That means it can only be called from 14071da177e4SLinus Torvalds ** do_journal_end, or by journal_release 14081da177e4SLinus Torvalds */ 14091da177e4SLinus Torvalds static int flush_journal_list(struct super_block *s, 1410bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl, int flushall) 1411bd4c625cSLinus Torvalds { 14121da177e4SLinus Torvalds struct reiserfs_journal_list *pjl; 14131da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn, *last; 14141da177e4SLinus Torvalds int count; 14151da177e4SLinus Torvalds int was_jwait = 0; 14161da177e4SLinus Torvalds int was_dirty = 0; 14171da177e4SLinus Torvalds struct buffer_head *saved_bh; 14181da177e4SLinus Torvalds unsigned long j_len_saved = jl->j_len; 14191da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 14201da177e4SLinus Torvalds int err = 0; 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds BUG_ON(j_len_saved <= 0); 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds if (atomic_read(&journal->j_wcount) != 0) { 142545b03d5eSJeff Mahoney reiserfs_warning(s, "clm-2048", "called with wcount %d", 14261da177e4SLinus Torvalds atomic_read(&journal->j_wcount)); 14271da177e4SLinus Torvalds } 14281da177e4SLinus Torvalds BUG_ON(jl->j_trans_id == 0); 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds /* if flushall == 0, the lock is already held */ 14311da177e4SLinus Torvalds if (flushall) { 14328ebc4232SFrederic Weisbecker reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s); 1433afe70259SJeff Mahoney } else if (mutex_trylock(&journal->j_flush_mutex)) { 14341da177e4SLinus Torvalds BUG(); 14351da177e4SLinus Torvalds } 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds count = 0; 14381da177e4SLinus Torvalds if (j_len_saved > journal->j_trans_max) { 1439c3a9c210SJeff Mahoney reiserfs_panic(s, "journal-715", "length is %lu, trans id %lu", 1440bd4c625cSLinus Torvalds j_len_saved, jl->j_trans_id); 14411da177e4SLinus Torvalds return 0; 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds 144422e2c507SJens Axboe get_fs_excl(); 144522e2c507SJens Axboe 14461da177e4SLinus Torvalds /* if all the work is already done, get out of here */ 14471da177e4SLinus Torvalds if (atomic_read(&(jl->j_nonzerolen)) <= 0 && 14481da177e4SLinus Torvalds atomic_read(&(jl->j_commit_left)) <= 0) { 14491da177e4SLinus Torvalds goto flush_older_and_return; 14501da177e4SLinus Torvalds } 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds /* start by putting the commit list on disk. This will also flush 14531da177e4SLinus Torvalds ** the commit lists of any olders transactions 14541da177e4SLinus Torvalds */ 14551da177e4SLinus Torvalds flush_commit_list(s, jl, 1); 14561da177e4SLinus Torvalds 1457bd4c625cSLinus Torvalds if (!(jl->j_state & LIST_DIRTY) 1458bd4c625cSLinus Torvalds && !reiserfs_is_journal_aborted(journal)) 14591da177e4SLinus Torvalds BUG(); 14601da177e4SLinus Torvalds 14611da177e4SLinus Torvalds /* are we done now? */ 14621da177e4SLinus Torvalds if (atomic_read(&(jl->j_nonzerolen)) <= 0 && 14631da177e4SLinus Torvalds atomic_read(&(jl->j_commit_left)) <= 0) { 14641da177e4SLinus Torvalds goto flush_older_and_return; 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds 14671da177e4SLinus Torvalds /* loop through each cnode, see if we need to write it, 14681da177e4SLinus Torvalds ** or wait on a more recent transaction, or just ignore it 14691da177e4SLinus Torvalds */ 14701da177e4SLinus Torvalds if (atomic_read(&(journal->j_wcount)) != 0) { 1471c3a9c210SJeff Mahoney reiserfs_panic(s, "journal-844", "journal list is flushing, " 1472c3a9c210SJeff Mahoney "wcount is not 0"); 14731da177e4SLinus Torvalds } 14741da177e4SLinus Torvalds cn = jl->j_realblock; 14751da177e4SLinus Torvalds while (cn) { 14761da177e4SLinus Torvalds was_jwait = 0; 14771da177e4SLinus Torvalds was_dirty = 0; 14781da177e4SLinus Torvalds saved_bh = NULL; 14791da177e4SLinus Torvalds /* blocknr of 0 is no longer in the hash, ignore it */ 14801da177e4SLinus Torvalds if (cn->blocknr == 0) { 14811da177e4SLinus Torvalds goto free_cnode; 14821da177e4SLinus Torvalds } 14831da177e4SLinus Torvalds 14841da177e4SLinus Torvalds /* This transaction failed commit. Don't write out to the disk */ 14851da177e4SLinus Torvalds if (!(jl->j_state & LIST_DIRTY)) 14861da177e4SLinus Torvalds goto free_cnode; 14871da177e4SLinus Torvalds 14881da177e4SLinus Torvalds pjl = find_newer_jl_for_cn(cn); 14891da177e4SLinus Torvalds /* the order is important here. We check pjl to make sure we 14901da177e4SLinus Torvalds ** don't clear BH_JDirty_wait if we aren't the one writing this 14911da177e4SLinus Torvalds ** block to disk 14921da177e4SLinus Torvalds */ 14931da177e4SLinus Torvalds if (!pjl && cn->bh) { 14941da177e4SLinus Torvalds saved_bh = cn->bh; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds /* we do this to make sure nobody releases the buffer while 14971da177e4SLinus Torvalds ** we are working with it 14981da177e4SLinus Torvalds */ 14991da177e4SLinus Torvalds get_bh(saved_bh); 15001da177e4SLinus Torvalds 15011da177e4SLinus Torvalds if (buffer_journal_dirty(saved_bh)) { 15021da177e4SLinus Torvalds BUG_ON(!can_dirty(cn)); 15031da177e4SLinus Torvalds was_jwait = 1; 15041da177e4SLinus Torvalds was_dirty = 1; 15051da177e4SLinus Torvalds } else if (can_dirty(cn)) { 15061da177e4SLinus Torvalds /* everything with !pjl && jwait should be writable */ 15071da177e4SLinus Torvalds BUG(); 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds /* if someone has this block in a newer transaction, just make 15120779bf2dSMatt LaPlante ** sure they are committed, and don't try writing it to disk 15131da177e4SLinus Torvalds */ 15141da177e4SLinus Torvalds if (pjl) { 15151da177e4SLinus Torvalds if (atomic_read(&pjl->j_commit_left)) 15161da177e4SLinus Torvalds flush_commit_list(s, pjl, 1); 15171da177e4SLinus Torvalds goto free_cnode; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds /* bh == NULL when the block got to disk on its own, OR, 15211da177e4SLinus Torvalds ** the block got freed in a future transaction 15221da177e4SLinus Torvalds */ 15231da177e4SLinus Torvalds if (saved_bh == NULL) { 15241da177e4SLinus Torvalds goto free_cnode; 15251da177e4SLinus Torvalds } 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds /* this should never happen. kupdate_one_transaction has this list 15281da177e4SLinus Torvalds ** locked while it works, so we should never see a buffer here that 15291da177e4SLinus Torvalds ** is not marked JDirty_wait 15301da177e4SLinus Torvalds */ 15311da177e4SLinus Torvalds if ((!was_jwait) && !buffer_locked(saved_bh)) { 153245b03d5eSJeff Mahoney reiserfs_warning(s, "journal-813", 153345b03d5eSJeff Mahoney "BAD! buffer %llu %cdirty %cjwait, " 15341da177e4SLinus Torvalds "not in a newer tranasction", 1535bd4c625cSLinus Torvalds (unsigned long long)saved_bh-> 1536bd4c625cSLinus Torvalds b_blocknr, was_dirty ? ' ' : '!', 1537bd4c625cSLinus Torvalds was_jwait ? ' ' : '!'); 15381da177e4SLinus Torvalds } 15391da177e4SLinus Torvalds if (was_dirty) { 15401da177e4SLinus Torvalds /* we inc again because saved_bh gets decremented at free_cnode */ 15411da177e4SLinus Torvalds get_bh(saved_bh); 15421da177e4SLinus Torvalds set_bit(BLOCK_NEEDS_FLUSH, &cn->state); 15431da177e4SLinus Torvalds lock_buffer(saved_bh); 15441da177e4SLinus Torvalds BUG_ON(cn->blocknr != saved_bh->b_blocknr); 15451da177e4SLinus Torvalds if (buffer_dirty(saved_bh)) 15461da177e4SLinus Torvalds submit_logged_buffer(saved_bh); 15471da177e4SLinus Torvalds else 15481da177e4SLinus Torvalds unlock_buffer(saved_bh); 15491da177e4SLinus Torvalds count++; 15501da177e4SLinus Torvalds } else { 155145b03d5eSJeff Mahoney reiserfs_warning(s, "clm-2082", 155245b03d5eSJeff Mahoney "Unable to flush buffer %llu in %s", 1553bd4c625cSLinus Torvalds (unsigned long long)saved_bh-> 1554fbe5498bSHarvey Harrison b_blocknr, __func__); 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds free_cnode: 15571da177e4SLinus Torvalds last = cn; 15581da177e4SLinus Torvalds cn = cn->next; 15591da177e4SLinus Torvalds if (saved_bh) { 15601da177e4SLinus Torvalds /* we incremented this to keep others from taking the buffer head away */ 15611da177e4SLinus Torvalds put_bh(saved_bh); 15621da177e4SLinus Torvalds if (atomic_read(&(saved_bh->b_count)) < 0) { 156345b03d5eSJeff Mahoney reiserfs_warning(s, "journal-945", 156445b03d5eSJeff Mahoney "saved_bh->b_count < 0"); 15651da177e4SLinus Torvalds } 15661da177e4SLinus Torvalds } 15671da177e4SLinus Torvalds } 15681da177e4SLinus Torvalds if (count > 0) { 15691da177e4SLinus Torvalds cn = jl->j_realblock; 15701da177e4SLinus Torvalds while (cn) { 15711da177e4SLinus Torvalds if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) { 15721da177e4SLinus Torvalds if (!cn->bh) { 1573c3a9c210SJeff Mahoney reiserfs_panic(s, "journal-1011", 1574c3a9c210SJeff Mahoney "cn->bh is NULL"); 15751da177e4SLinus Torvalds } 15768ebc4232SFrederic Weisbecker 15778ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 15781da177e4SLinus Torvalds wait_on_buffer(cn->bh); 15798ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 15808ebc4232SFrederic Weisbecker 15811da177e4SLinus Torvalds if (!cn->bh) { 1582c3a9c210SJeff Mahoney reiserfs_panic(s, "journal-1012", 1583c3a9c210SJeff Mahoney "cn->bh is NULL"); 15841da177e4SLinus Torvalds } 15851da177e4SLinus Torvalds if (unlikely(!buffer_uptodate(cn->bh))) { 15861da177e4SLinus Torvalds #ifdef CONFIG_REISERFS_CHECK 158745b03d5eSJeff Mahoney reiserfs_warning(s, "journal-949", 158845b03d5eSJeff Mahoney "buffer write failed"); 15891da177e4SLinus Torvalds #endif 15901da177e4SLinus Torvalds err = -EIO; 15911da177e4SLinus Torvalds } 15921da177e4SLinus Torvalds /* note, we must clear the JDirty_wait bit after the up to date 15931da177e4SLinus Torvalds ** check, otherwise we race against our flushpage routine 15941da177e4SLinus Torvalds */ 1595bd4c625cSLinus Torvalds BUG_ON(!test_clear_buffer_journal_dirty 1596bd4c625cSLinus Torvalds (cn->bh)); 15971da177e4SLinus Torvalds 1598398c95bdSChris Mason /* drop one ref for us */ 15991da177e4SLinus Torvalds put_bh(cn->bh); 1600398c95bdSChris Mason /* drop one ref for journal_mark_dirty */ 1601398c95bdSChris Mason release_buffer_page(cn->bh); 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds cn = cn->next; 16041da177e4SLinus Torvalds } 16051da177e4SLinus Torvalds } 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds if (err) 1608bd4c625cSLinus Torvalds reiserfs_abort(s, -EIO, 1609bd4c625cSLinus Torvalds "Write error while pushing transaction to disk in %s", 1610fbe5498bSHarvey Harrison __func__); 16111da177e4SLinus Torvalds flush_older_and_return: 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds /* before we can update the journal header block, we _must_ flush all 16141da177e4SLinus Torvalds ** real blocks from all older transactions to disk. This is because 16151da177e4SLinus Torvalds ** once the header block is updated, this transaction will not be 16161da177e4SLinus Torvalds ** replayed after a crash 16171da177e4SLinus Torvalds */ 16181da177e4SLinus Torvalds if (flushall) { 16191da177e4SLinus Torvalds flush_older_journal_lists(s, jl); 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds err = journal->j_errno; 16231da177e4SLinus Torvalds /* before we can remove everything from the hash tables for this 16241da177e4SLinus Torvalds ** transaction, we must make sure it can never be replayed 16251da177e4SLinus Torvalds ** 16261da177e4SLinus Torvalds ** since we are only called from do_journal_end, we know for sure there 16271da177e4SLinus Torvalds ** are no allocations going on while we are flushing journal lists. So, 16281da177e4SLinus Torvalds ** we only need to update the journal header block for the last list 16291da177e4SLinus Torvalds ** being flushed 16301da177e4SLinus Torvalds */ 16311da177e4SLinus Torvalds if (!err && flushall) { 1632bd4c625cSLinus Torvalds err = 1633bd4c625cSLinus Torvalds update_journal_header_block(s, 1634bd4c625cSLinus Torvalds (jl->j_start + jl->j_len + 1635bd4c625cSLinus Torvalds 2) % SB_ONDISK_JOURNAL_SIZE(s), 1636bd4c625cSLinus Torvalds jl->j_trans_id); 16371da177e4SLinus Torvalds if (err) 1638bd4c625cSLinus Torvalds reiserfs_abort(s, -EIO, 1639bd4c625cSLinus Torvalds "Write error while updating journal header in %s", 1640fbe5498bSHarvey Harrison __func__); 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds remove_all_from_journal_list(s, jl, 0); 16431da177e4SLinus Torvalds list_del_init(&jl->j_list); 16441da177e4SLinus Torvalds journal->j_num_lists--; 16451da177e4SLinus Torvalds del_from_work_list(s, jl); 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds if (journal->j_last_flush_id != 0 && 16481da177e4SLinus Torvalds (jl->j_trans_id - journal->j_last_flush_id) != 1) { 164945b03d5eSJeff Mahoney reiserfs_warning(s, "clm-2201", "last flush %lu, current %lu", 1650bd4c625cSLinus Torvalds journal->j_last_flush_id, jl->j_trans_id); 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds journal->j_last_flush_id = jl->j_trans_id; 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds /* not strictly required since we are freeing the list, but it should 16551da177e4SLinus Torvalds * help find code using dead lists later on 16561da177e4SLinus Torvalds */ 16571da177e4SLinus Torvalds jl->j_len = 0; 16581da177e4SLinus Torvalds atomic_set(&(jl->j_nonzerolen), 0); 16591da177e4SLinus Torvalds jl->j_start = 0; 16601da177e4SLinus Torvalds jl->j_realblock = NULL; 16611da177e4SLinus Torvalds jl->j_commit_bh = NULL; 16621da177e4SLinus Torvalds jl->j_trans_id = 0; 16631da177e4SLinus Torvalds jl->j_state = 0; 16641da177e4SLinus Torvalds put_journal_list(s, jl); 16651da177e4SLinus Torvalds if (flushall) 1666afe70259SJeff Mahoney mutex_unlock(&journal->j_flush_mutex); 166722e2c507SJens Axboe put_fs_excl(); 16681da177e4SLinus Torvalds return err; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 1671a3172027SChris Mason static int test_transaction(struct super_block *s, 1672a3172027SChris Mason struct reiserfs_journal_list *jl) 1673a3172027SChris Mason { 1674a3172027SChris Mason struct reiserfs_journal_cnode *cn; 1675a3172027SChris Mason 1676a3172027SChris Mason if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) 1677a3172027SChris Mason return 1; 1678a3172027SChris Mason 1679a3172027SChris Mason cn = jl->j_realblock; 1680a3172027SChris Mason while (cn) { 1681a3172027SChris Mason /* if the blocknr == 0, this has been cleared from the hash, 1682a3172027SChris Mason ** skip it 1683a3172027SChris Mason */ 1684a3172027SChris Mason if (cn->blocknr == 0) { 1685a3172027SChris Mason goto next; 1686a3172027SChris Mason } 1687a3172027SChris Mason if (cn->bh && !newer_jl_done(cn)) 1688a3172027SChris Mason return 0; 1689a3172027SChris Mason next: 1690a3172027SChris Mason cn = cn->next; 1691a3172027SChris Mason cond_resched(); 1692a3172027SChris Mason } 1693a3172027SChris Mason return 0; 1694a3172027SChris Mason } 1695a3172027SChris Mason 16961da177e4SLinus Torvalds static int write_one_transaction(struct super_block *s, 16971da177e4SLinus Torvalds struct reiserfs_journal_list *jl, 16981da177e4SLinus Torvalds struct buffer_chunk *chunk) 16991da177e4SLinus Torvalds { 17001da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 17011da177e4SLinus Torvalds int ret = 0; 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds jl->j_state |= LIST_TOUCHED; 17041da177e4SLinus Torvalds del_from_work_list(s, jl); 17051da177e4SLinus Torvalds if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) { 17061da177e4SLinus Torvalds return 0; 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds cn = jl->j_realblock; 17101da177e4SLinus Torvalds while (cn) { 17111da177e4SLinus Torvalds /* if the blocknr == 0, this has been cleared from the hash, 17121da177e4SLinus Torvalds ** skip it 17131da177e4SLinus Torvalds */ 17141da177e4SLinus Torvalds if (cn->blocknr == 0) { 17151da177e4SLinus Torvalds goto next; 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds if (cn->bh && can_dirty(cn) && buffer_dirty(cn->bh)) { 17181da177e4SLinus Torvalds struct buffer_head *tmp_bh; 17191da177e4SLinus Torvalds /* we can race against journal_mark_freed when we try 17201da177e4SLinus Torvalds * to lock_buffer(cn->bh), so we have to inc the buffer 17211da177e4SLinus Torvalds * count, and recheck things after locking 17221da177e4SLinus Torvalds */ 17231da177e4SLinus Torvalds tmp_bh = cn->bh; 17241da177e4SLinus Torvalds get_bh(tmp_bh); 17251da177e4SLinus Torvalds lock_buffer(tmp_bh); 17261da177e4SLinus Torvalds if (cn->bh && can_dirty(cn) && buffer_dirty(tmp_bh)) { 17271da177e4SLinus Torvalds if (!buffer_journal_dirty(tmp_bh) || 17281da177e4SLinus Torvalds buffer_journal_prepared(tmp_bh)) 17291da177e4SLinus Torvalds BUG(); 17301da177e4SLinus Torvalds add_to_chunk(chunk, tmp_bh, NULL, write_chunk); 17311da177e4SLinus Torvalds ret++; 17321da177e4SLinus Torvalds } else { 17331da177e4SLinus Torvalds /* note, cn->bh might be null now */ 17341da177e4SLinus Torvalds unlock_buffer(tmp_bh); 17351da177e4SLinus Torvalds } 17361da177e4SLinus Torvalds put_bh(tmp_bh); 17371da177e4SLinus Torvalds } 17381da177e4SLinus Torvalds next: 17391da177e4SLinus Torvalds cn = cn->next; 17401da177e4SLinus Torvalds cond_resched(); 17411da177e4SLinus Torvalds } 17421da177e4SLinus Torvalds return ret; 17431da177e4SLinus Torvalds } 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvalds /* used by flush_commit_list */ 17461da177e4SLinus Torvalds static int dirty_one_transaction(struct super_block *s, 17471da177e4SLinus Torvalds struct reiserfs_journal_list *jl) 17481da177e4SLinus Torvalds { 17491da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 17501da177e4SLinus Torvalds struct reiserfs_journal_list *pjl; 17511da177e4SLinus Torvalds int ret = 0; 17521da177e4SLinus Torvalds 17531da177e4SLinus Torvalds jl->j_state |= LIST_DIRTY; 17541da177e4SLinus Torvalds cn = jl->j_realblock; 17551da177e4SLinus Torvalds while (cn) { 17561da177e4SLinus Torvalds /* look for a more recent transaction that logged this 17571da177e4SLinus Torvalds ** buffer. Only the most recent transaction with a buffer in 17581da177e4SLinus Torvalds ** it is allowed to send that buffer to disk 17591da177e4SLinus Torvalds */ 17601da177e4SLinus Torvalds pjl = find_newer_jl_for_cn(cn); 1761bd4c625cSLinus Torvalds if (!pjl && cn->blocknr && cn->bh 1762bd4c625cSLinus Torvalds && buffer_journal_dirty(cn->bh)) { 17631da177e4SLinus Torvalds BUG_ON(!can_dirty(cn)); 17641da177e4SLinus Torvalds /* if the buffer is prepared, it will either be logged 17651da177e4SLinus Torvalds * or restored. If restored, we need to make sure 17661da177e4SLinus Torvalds * it actually gets marked dirty 17671da177e4SLinus Torvalds */ 17681da177e4SLinus Torvalds clear_buffer_journal_new(cn->bh); 17691da177e4SLinus Torvalds if (buffer_journal_prepared(cn->bh)) { 17701da177e4SLinus Torvalds set_buffer_journal_restore_dirty(cn->bh); 17711da177e4SLinus Torvalds } else { 17721da177e4SLinus Torvalds set_buffer_journal_test(cn->bh); 17731da177e4SLinus Torvalds mark_buffer_dirty(cn->bh); 17741da177e4SLinus Torvalds } 17751da177e4SLinus Torvalds } 17761da177e4SLinus Torvalds cn = cn->next; 17771da177e4SLinus Torvalds } 17781da177e4SLinus Torvalds return ret; 17791da177e4SLinus Torvalds } 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds static int kupdate_transactions(struct super_block *s, 17821da177e4SLinus Torvalds struct reiserfs_journal_list *jl, 17831da177e4SLinus Torvalds struct reiserfs_journal_list **next_jl, 1784600ed416SJeff Mahoney unsigned int *next_trans_id, 1785bd4c625cSLinus Torvalds int num_blocks, int num_trans) 1786bd4c625cSLinus Torvalds { 17871da177e4SLinus Torvalds int ret = 0; 17881da177e4SLinus Torvalds int written = 0; 17891da177e4SLinus Torvalds int transactions_flushed = 0; 1790600ed416SJeff Mahoney unsigned int orig_trans_id = jl->j_trans_id; 17911da177e4SLinus Torvalds struct buffer_chunk chunk; 17921da177e4SLinus Torvalds struct list_head *entry; 17931da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 17941da177e4SLinus Torvalds chunk.nr = 0; 17951da177e4SLinus Torvalds 1796a412f9efSFrederic Weisbecker reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s); 17971da177e4SLinus Torvalds if (!journal_list_still_alive(s, orig_trans_id)) { 17981da177e4SLinus Torvalds goto done; 17991da177e4SLinus Torvalds } 18001da177e4SLinus Torvalds 1801afe70259SJeff Mahoney /* we've got j_flush_mutex held, nobody is going to delete any 18021da177e4SLinus Torvalds * of these lists out from underneath us 18031da177e4SLinus Torvalds */ 18041da177e4SLinus Torvalds while ((num_trans && transactions_flushed < num_trans) || 18051da177e4SLinus Torvalds (!num_trans && written < num_blocks)) { 18061da177e4SLinus Torvalds 18071da177e4SLinus Torvalds if (jl->j_len == 0 || (jl->j_state & LIST_TOUCHED) || 1808bd4c625cSLinus Torvalds atomic_read(&jl->j_commit_left) 1809bd4c625cSLinus Torvalds || !(jl->j_state & LIST_DIRTY)) { 18101da177e4SLinus Torvalds del_from_work_list(s, jl); 18111da177e4SLinus Torvalds break; 18121da177e4SLinus Torvalds } 18131da177e4SLinus Torvalds ret = write_one_transaction(s, jl, &chunk); 18141da177e4SLinus Torvalds 18151da177e4SLinus Torvalds if (ret < 0) 18161da177e4SLinus Torvalds goto done; 18171da177e4SLinus Torvalds transactions_flushed++; 18181da177e4SLinus Torvalds written += ret; 18191da177e4SLinus Torvalds entry = jl->j_list.next; 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds /* did we wrap? */ 18221da177e4SLinus Torvalds if (entry == &journal->j_journal_list) { 18231da177e4SLinus Torvalds break; 18241da177e4SLinus Torvalds } 18251da177e4SLinus Torvalds jl = JOURNAL_LIST_ENTRY(entry); 18261da177e4SLinus Torvalds 18271da177e4SLinus Torvalds /* don't bother with older transactions */ 18281da177e4SLinus Torvalds if (jl->j_trans_id <= orig_trans_id) 18291da177e4SLinus Torvalds break; 18301da177e4SLinus Torvalds } 18311da177e4SLinus Torvalds if (chunk.nr) { 18321da177e4SLinus Torvalds write_chunk(&chunk); 18331da177e4SLinus Torvalds } 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds done: 1836afe70259SJeff Mahoney mutex_unlock(&journal->j_flush_mutex); 18371da177e4SLinus Torvalds return ret; 18381da177e4SLinus Torvalds } 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds /* for o_sync and fsync heavy applications, they tend to use 18411da177e4SLinus Torvalds ** all the journa list slots with tiny transactions. These 18421da177e4SLinus Torvalds ** trigger lots and lots of calls to update the header block, which 18431da177e4SLinus Torvalds ** adds seeks and slows things down. 18441da177e4SLinus Torvalds ** 18451da177e4SLinus Torvalds ** This function tries to clear out a large chunk of the journal lists 18461da177e4SLinus Torvalds ** at once, which makes everything faster since only the newest journal 18471da177e4SLinus Torvalds ** list updates the header block 18481da177e4SLinus Torvalds */ 18491da177e4SLinus Torvalds static int flush_used_journal_lists(struct super_block *s, 1850bd4c625cSLinus Torvalds struct reiserfs_journal_list *jl) 1851bd4c625cSLinus Torvalds { 18521da177e4SLinus Torvalds unsigned long len = 0; 18531da177e4SLinus Torvalds unsigned long cur_len; 18541da177e4SLinus Torvalds int ret; 18551da177e4SLinus Torvalds int i; 18561da177e4SLinus Torvalds int limit = 256; 18571da177e4SLinus Torvalds struct reiserfs_journal_list *tjl; 18581da177e4SLinus Torvalds struct reiserfs_journal_list *flush_jl; 1859600ed416SJeff Mahoney unsigned int trans_id; 18601da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds flush_jl = tjl = jl; 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds /* in data logging mode, try harder to flush a lot of blocks */ 18651da177e4SLinus Torvalds if (reiserfs_data_log(s)) 18661da177e4SLinus Torvalds limit = 1024; 18671da177e4SLinus Torvalds /* flush for 256 transactions or limit blocks, whichever comes first */ 18681da177e4SLinus Torvalds for (i = 0; i < 256 && len < limit; i++) { 18691da177e4SLinus Torvalds if (atomic_read(&tjl->j_commit_left) || 18701da177e4SLinus Torvalds tjl->j_trans_id < jl->j_trans_id) { 18711da177e4SLinus Torvalds break; 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds cur_len = atomic_read(&tjl->j_nonzerolen); 18741da177e4SLinus Torvalds if (cur_len > 0) { 18751da177e4SLinus Torvalds tjl->j_state &= ~LIST_TOUCHED; 18761da177e4SLinus Torvalds } 18771da177e4SLinus Torvalds len += cur_len; 18781da177e4SLinus Torvalds flush_jl = tjl; 18791da177e4SLinus Torvalds if (tjl->j_list.next == &journal->j_journal_list) 18801da177e4SLinus Torvalds break; 18811da177e4SLinus Torvalds tjl = JOURNAL_LIST_ENTRY(tjl->j_list.next); 18821da177e4SLinus Torvalds } 18831da177e4SLinus Torvalds /* try to find a group of blocks we can flush across all the 18841da177e4SLinus Torvalds ** transactions, but only bother if we've actually spanned 18851da177e4SLinus Torvalds ** across multiple lists 18861da177e4SLinus Torvalds */ 18871da177e4SLinus Torvalds if (flush_jl != jl) { 18881da177e4SLinus Torvalds ret = kupdate_transactions(s, jl, &tjl, &trans_id, len, i); 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds flush_journal_list(s, flush_jl, 1); 18911da177e4SLinus Torvalds return 0; 18921da177e4SLinus Torvalds } 18931da177e4SLinus Torvalds 18941da177e4SLinus Torvalds /* 18951da177e4SLinus Torvalds ** removes any nodes in table with name block and dev as bh. 18961da177e4SLinus Torvalds ** only touchs the hnext and hprev pointers. 18971da177e4SLinus Torvalds */ 18981da177e4SLinus Torvalds void remove_journal_hash(struct super_block *sb, 18991da177e4SLinus Torvalds struct reiserfs_journal_cnode **table, 19001da177e4SLinus Torvalds struct reiserfs_journal_list *jl, 19011da177e4SLinus Torvalds unsigned long block, int remove_freed) 19021da177e4SLinus Torvalds { 19031da177e4SLinus Torvalds struct reiserfs_journal_cnode *cur; 19041da177e4SLinus Torvalds struct reiserfs_journal_cnode **head; 19051da177e4SLinus Torvalds 19061da177e4SLinus Torvalds head = &(journal_hash(table, sb, block)); 19071da177e4SLinus Torvalds if (!head) { 19081da177e4SLinus Torvalds return; 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds cur = *head; 19111da177e4SLinus Torvalds while (cur) { 1912bd4c625cSLinus Torvalds if (cur->blocknr == block && cur->sb == sb 1913bd4c625cSLinus Torvalds && (jl == NULL || jl == cur->jlist) 1914bd4c625cSLinus Torvalds && (!test_bit(BLOCK_FREED, &cur->state) || remove_freed)) { 19151da177e4SLinus Torvalds if (cur->hnext) { 19161da177e4SLinus Torvalds cur->hnext->hprev = cur->hprev; 19171da177e4SLinus Torvalds } 19181da177e4SLinus Torvalds if (cur->hprev) { 19191da177e4SLinus Torvalds cur->hprev->hnext = cur->hnext; 19201da177e4SLinus Torvalds } else { 19211da177e4SLinus Torvalds *head = cur->hnext; 19221da177e4SLinus Torvalds } 19231da177e4SLinus Torvalds cur->blocknr = 0; 19241da177e4SLinus Torvalds cur->sb = NULL; 19251da177e4SLinus Torvalds cur->state = 0; 19261da177e4SLinus Torvalds if (cur->bh && cur->jlist) /* anybody who clears the cur->bh will also dec the nonzerolen */ 19271da177e4SLinus Torvalds atomic_dec(&(cur->jlist->j_nonzerolen)); 19281da177e4SLinus Torvalds cur->bh = NULL; 19291da177e4SLinus Torvalds cur->jlist = NULL; 19301da177e4SLinus Torvalds } 19311da177e4SLinus Torvalds cur = cur->hnext; 19321da177e4SLinus Torvalds } 19331da177e4SLinus Torvalds } 19341da177e4SLinus Torvalds 1935a9dd3643SJeff Mahoney static void free_journal_ram(struct super_block *sb) 1936bd4c625cSLinus Torvalds { 1937a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 1938d739b42bSPekka Enberg kfree(journal->j_current_jl); 19391da177e4SLinus Torvalds journal->j_num_lists--; 19401da177e4SLinus Torvalds 19411da177e4SLinus Torvalds vfree(journal->j_cnode_free_orig); 1942a9dd3643SJeff Mahoney free_list_bitmaps(sb, journal->j_list_bitmap); 1943a9dd3643SJeff Mahoney free_bitmap_nodes(sb); /* must be after free_list_bitmaps */ 19441da177e4SLinus Torvalds if (journal->j_header_bh) { 19451da177e4SLinus Torvalds brelse(journal->j_header_bh); 19461da177e4SLinus Torvalds } 19471da177e4SLinus Torvalds /* j_header_bh is on the journal dev, make sure not to release the journal 19481da177e4SLinus Torvalds * dev until we brelse j_header_bh 19491da177e4SLinus Torvalds */ 1950a9dd3643SJeff Mahoney release_journal_dev(sb, journal); 19511da177e4SLinus Torvalds vfree(journal); 19521da177e4SLinus Torvalds } 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* 19551da177e4SLinus Torvalds ** call on unmount. Only set error to 1 if you haven't made your way out 19561da177e4SLinus Torvalds ** of read_super() yet. Any other caller must keep error at 0. 19571da177e4SLinus Torvalds */ 1958bd4c625cSLinus Torvalds static int do_journal_release(struct reiserfs_transaction_handle *th, 1959a9dd3643SJeff Mahoney struct super_block *sb, int error) 1960bd4c625cSLinus Torvalds { 19611da177e4SLinus Torvalds struct reiserfs_transaction_handle myth; 19621da177e4SLinus Torvalds int flushed = 0; 1963a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 19641da177e4SLinus Torvalds 19651da177e4SLinus Torvalds /* we only want to flush out transactions if we were called with error == 0 19661da177e4SLinus Torvalds */ 1967a9dd3643SJeff Mahoney if (!error && !(sb->s_flags & MS_RDONLY)) { 19681da177e4SLinus Torvalds /* end the current trans */ 19691da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 1970a9dd3643SJeff Mahoney do_journal_end(th, sb, 10, FLUSH_ALL); 19711da177e4SLinus Torvalds 19721da177e4SLinus Torvalds /* make sure something gets logged to force our way into the flush code */ 1973a9dd3643SJeff Mahoney if (!journal_join(&myth, sb, 1)) { 1974a9dd3643SJeff Mahoney reiserfs_prepare_for_journal(sb, 1975a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb), 1976bd4c625cSLinus Torvalds 1); 1977a9dd3643SJeff Mahoney journal_mark_dirty(&myth, sb, 1978a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb)); 1979a9dd3643SJeff Mahoney do_journal_end(&myth, sb, 1, FLUSH_ALL); 19801da177e4SLinus Torvalds flushed = 1; 19811da177e4SLinus Torvalds } 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds /* this also catches errors during the do_journal_end above */ 19851da177e4SLinus Torvalds if (!error && reiserfs_is_journal_aborted(journal)) { 19861da177e4SLinus Torvalds memset(&myth, 0, sizeof(myth)); 1987a9dd3643SJeff Mahoney if (!journal_join_abort(&myth, sb, 1)) { 1988a9dd3643SJeff Mahoney reiserfs_prepare_for_journal(sb, 1989a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb), 1990bd4c625cSLinus Torvalds 1); 1991a9dd3643SJeff Mahoney journal_mark_dirty(&myth, sb, 1992a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb)); 1993a9dd3643SJeff Mahoney do_journal_end(&myth, sb, 1, FLUSH_ALL); 19941da177e4SLinus Torvalds } 19951da177e4SLinus Torvalds } 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds reiserfs_mounted_fs_count--; 19981da177e4SLinus Torvalds /* wait for all commits to finish */ 1999a9dd3643SJeff Mahoney cancel_delayed_work(&SB_JOURNAL(sb)->j_work); 20008ebc4232SFrederic Weisbecker 20018ebc4232SFrederic Weisbecker /* 20028ebc4232SFrederic Weisbecker * We must release the write lock here because 20038ebc4232SFrederic Weisbecker * the workqueue job (flush_async_commit) needs this lock 20048ebc4232SFrederic Weisbecker */ 20058ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 20061da177e4SLinus Torvalds flush_workqueue(commit_wq); 20078ebc4232SFrederic Weisbecker 20081da177e4SLinus Torvalds if (!reiserfs_mounted_fs_count) { 20091da177e4SLinus Torvalds destroy_workqueue(commit_wq); 20101da177e4SLinus Torvalds commit_wq = NULL; 20111da177e4SLinus Torvalds } 20128ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 20131da177e4SLinus Torvalds 2014a9dd3643SJeff Mahoney free_journal_ram(sb); 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds return 0; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds 20191da177e4SLinus Torvalds /* 20201da177e4SLinus Torvalds ** call on unmount. flush all journal trans, release all alloc'd ram 20211da177e4SLinus Torvalds */ 2022bd4c625cSLinus Torvalds int journal_release(struct reiserfs_transaction_handle *th, 2023a9dd3643SJeff Mahoney struct super_block *sb) 2024bd4c625cSLinus Torvalds { 2025a9dd3643SJeff Mahoney return do_journal_release(th, sb, 0); 20261da177e4SLinus Torvalds } 2027bd4c625cSLinus Torvalds 20281da177e4SLinus Torvalds /* 20291da177e4SLinus Torvalds ** only call from an error condition inside reiserfs_read_super! 20301da177e4SLinus Torvalds */ 2031bd4c625cSLinus Torvalds int journal_release_error(struct reiserfs_transaction_handle *th, 2032a9dd3643SJeff Mahoney struct super_block *sb) 2033bd4c625cSLinus Torvalds { 2034a9dd3643SJeff Mahoney return do_journal_release(th, sb, 1); 20351da177e4SLinus Torvalds } 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds /* compares description block with commit block. returns 1 if they differ, 0 if they are the same */ 2038a9dd3643SJeff Mahoney static int journal_compare_desc_commit(struct super_block *sb, 2039bd4c625cSLinus Torvalds struct reiserfs_journal_desc *desc, 2040bd4c625cSLinus Torvalds struct reiserfs_journal_commit *commit) 2041bd4c625cSLinus Torvalds { 20421da177e4SLinus Torvalds if (get_commit_trans_id(commit) != get_desc_trans_id(desc) || 20431da177e4SLinus Torvalds get_commit_trans_len(commit) != get_desc_trans_len(desc) || 2044a9dd3643SJeff Mahoney get_commit_trans_len(commit) > SB_JOURNAL(sb)->j_trans_max || 2045bd4c625cSLinus Torvalds get_commit_trans_len(commit) <= 0) { 20461da177e4SLinus Torvalds return 1; 20471da177e4SLinus Torvalds } 20481da177e4SLinus Torvalds return 0; 20491da177e4SLinus Torvalds } 2050bd4c625cSLinus Torvalds 20511da177e4SLinus Torvalds /* returns 0 if it did not find a description block 20521da177e4SLinus Torvalds ** returns -1 if it found a corrupt commit block 20531da177e4SLinus Torvalds ** returns 1 if both desc and commit were valid 20541da177e4SLinus Torvalds */ 2055a9dd3643SJeff Mahoney static int journal_transaction_is_valid(struct super_block *sb, 2056bd4c625cSLinus Torvalds struct buffer_head *d_bh, 2057600ed416SJeff Mahoney unsigned int *oldest_invalid_trans_id, 2058bd4c625cSLinus Torvalds unsigned long *newest_mount_id) 2059bd4c625cSLinus Torvalds { 20601da177e4SLinus Torvalds struct reiserfs_journal_desc *desc; 20611da177e4SLinus Torvalds struct reiserfs_journal_commit *commit; 20621da177e4SLinus Torvalds struct buffer_head *c_bh; 20631da177e4SLinus Torvalds unsigned long offset; 20641da177e4SLinus Torvalds 20651da177e4SLinus Torvalds if (!d_bh) 20661da177e4SLinus Torvalds return 0; 20671da177e4SLinus Torvalds 20681da177e4SLinus Torvalds desc = (struct reiserfs_journal_desc *)d_bh->b_data; 2069bd4c625cSLinus Torvalds if (get_desc_trans_len(desc) > 0 2070bd4c625cSLinus Torvalds && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) { 2071bd4c625cSLinus Torvalds if (oldest_invalid_trans_id && *oldest_invalid_trans_id 2072bd4c625cSLinus Torvalds && get_desc_trans_id(desc) > *oldest_invalid_trans_id) { 2073a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2074bd4c625cSLinus Torvalds "journal-986: transaction " 20751da177e4SLinus Torvalds "is valid returning because trans_id %d is greater than " 2076bd4c625cSLinus Torvalds "oldest_invalid %lu", 2077bd4c625cSLinus Torvalds get_desc_trans_id(desc), 20781da177e4SLinus Torvalds *oldest_invalid_trans_id); 20791da177e4SLinus Torvalds return 0; 20801da177e4SLinus Torvalds } 2081bd4c625cSLinus Torvalds if (newest_mount_id 2082bd4c625cSLinus Torvalds && *newest_mount_id > get_desc_mount_id(desc)) { 2083a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2084bd4c625cSLinus Torvalds "journal-1087: transaction " 20851da177e4SLinus Torvalds "is valid returning because mount_id %d is less than " 2086bd4c625cSLinus Torvalds "newest_mount_id %lu", 2087bd4c625cSLinus Torvalds get_desc_mount_id(desc), 20881da177e4SLinus Torvalds *newest_mount_id); 20891da177e4SLinus Torvalds return -1; 20901da177e4SLinus Torvalds } 2091a9dd3643SJeff Mahoney if (get_desc_trans_len(desc) > SB_JOURNAL(sb)->j_trans_max) { 2092a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-2018", 209345b03d5eSJeff Mahoney "Bad transaction length %d " 209445b03d5eSJeff Mahoney "encountered, ignoring transaction", 2095bd4c625cSLinus Torvalds get_desc_trans_len(desc)); 20961da177e4SLinus Torvalds return -1; 20971da177e4SLinus Torvalds } 2098a9dd3643SJeff Mahoney offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb); 20991da177e4SLinus Torvalds 21001da177e4SLinus Torvalds /* ok, we have a journal description block, lets see if the transaction was valid */ 2101bd4c625cSLinus Torvalds c_bh = 2102a9dd3643SJeff Mahoney journal_bread(sb, 2103a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2104bd4c625cSLinus Torvalds ((offset + get_desc_trans_len(desc) + 2105a9dd3643SJeff Mahoney 1) % SB_ONDISK_JOURNAL_SIZE(sb))); 21061da177e4SLinus Torvalds if (!c_bh) 21071da177e4SLinus Torvalds return 0; 21081da177e4SLinus Torvalds commit = (struct reiserfs_journal_commit *)c_bh->b_data; 2109a9dd3643SJeff Mahoney if (journal_compare_desc_commit(sb, desc, commit)) { 2110a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 21111da177e4SLinus Torvalds "journal_transaction_is_valid, commit offset %ld had bad " 21121da177e4SLinus Torvalds "time %d or length %d", 2113bd4c625cSLinus Torvalds c_bh->b_blocknr - 2114a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb), 21151da177e4SLinus Torvalds get_commit_trans_id(commit), 21161da177e4SLinus Torvalds get_commit_trans_len(commit)); 21171da177e4SLinus Torvalds brelse(c_bh); 21181da177e4SLinus Torvalds if (oldest_invalid_trans_id) { 2119bd4c625cSLinus Torvalds *oldest_invalid_trans_id = 2120bd4c625cSLinus Torvalds get_desc_trans_id(desc); 2121a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2122bd4c625cSLinus Torvalds "journal-1004: " 21231da177e4SLinus Torvalds "transaction_is_valid setting oldest invalid trans_id " 2124bd4c625cSLinus Torvalds "to %d", 2125bd4c625cSLinus Torvalds get_desc_trans_id(desc)); 21261da177e4SLinus Torvalds } 21271da177e4SLinus Torvalds return -1; 21281da177e4SLinus Torvalds } 21291da177e4SLinus Torvalds brelse(c_bh); 2130a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2131bd4c625cSLinus Torvalds "journal-1006: found valid " 21321da177e4SLinus Torvalds "transaction start offset %llu, len %d id %d", 2133bd4c625cSLinus Torvalds d_bh->b_blocknr - 2134a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb), 2135bd4c625cSLinus Torvalds get_desc_trans_len(desc), 2136bd4c625cSLinus Torvalds get_desc_trans_id(desc)); 21371da177e4SLinus Torvalds return 1; 21381da177e4SLinus Torvalds } else { 21391da177e4SLinus Torvalds return 0; 21401da177e4SLinus Torvalds } 21411da177e4SLinus Torvalds } 21421da177e4SLinus Torvalds 2143bd4c625cSLinus Torvalds static void brelse_array(struct buffer_head **heads, int num) 2144bd4c625cSLinus Torvalds { 21451da177e4SLinus Torvalds int i; 21461da177e4SLinus Torvalds for (i = 0; i < num; i++) { 21471da177e4SLinus Torvalds brelse(heads[i]); 21481da177e4SLinus Torvalds } 21491da177e4SLinus Torvalds } 21501da177e4SLinus Torvalds 21511da177e4SLinus Torvalds /* 21521da177e4SLinus Torvalds ** given the start, and values for the oldest acceptable transactions, 21531da177e4SLinus Torvalds ** this either reads in a replays a transaction, or returns because the transaction 21541da177e4SLinus Torvalds ** is invalid, or too old. 21551da177e4SLinus Torvalds */ 2156a9dd3643SJeff Mahoney static int journal_read_transaction(struct super_block *sb, 2157bd4c625cSLinus Torvalds unsigned long cur_dblock, 2158bd4c625cSLinus Torvalds unsigned long oldest_start, 2159600ed416SJeff Mahoney unsigned int oldest_trans_id, 2160bd4c625cSLinus Torvalds unsigned long newest_mount_id) 2161bd4c625cSLinus Torvalds { 2162a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 21631da177e4SLinus Torvalds struct reiserfs_journal_desc *desc; 21641da177e4SLinus Torvalds struct reiserfs_journal_commit *commit; 2165600ed416SJeff Mahoney unsigned int trans_id = 0; 21661da177e4SLinus Torvalds struct buffer_head *c_bh; 21671da177e4SLinus Torvalds struct buffer_head *d_bh; 21681da177e4SLinus Torvalds struct buffer_head **log_blocks = NULL; 21691da177e4SLinus Torvalds struct buffer_head **real_blocks = NULL; 2170600ed416SJeff Mahoney unsigned int trans_offset; 21711da177e4SLinus Torvalds int i; 21721da177e4SLinus Torvalds int trans_half; 21731da177e4SLinus Torvalds 2174a9dd3643SJeff Mahoney d_bh = journal_bread(sb, cur_dblock); 21751da177e4SLinus Torvalds if (!d_bh) 21761da177e4SLinus Torvalds return 1; 21771da177e4SLinus Torvalds desc = (struct reiserfs_journal_desc *)d_bh->b_data; 2178a9dd3643SJeff Mahoney trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb); 2179a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1037: " 21801da177e4SLinus Torvalds "journal_read_transaction, offset %llu, len %d mount_id %d", 2181a9dd3643SJeff Mahoney d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb), 21821da177e4SLinus Torvalds get_desc_trans_len(desc), get_desc_mount_id(desc)); 21831da177e4SLinus Torvalds if (get_desc_trans_id(desc) < oldest_trans_id) { 2184a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1039: " 21851da177e4SLinus Torvalds "journal_read_trans skipping because %lu is too old", 2186bd4c625cSLinus Torvalds cur_dblock - 2187a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb)); 21881da177e4SLinus Torvalds brelse(d_bh); 21891da177e4SLinus Torvalds return 1; 21901da177e4SLinus Torvalds } 21911da177e4SLinus Torvalds if (get_desc_mount_id(desc) != newest_mount_id) { 2192a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1146: " 21931da177e4SLinus Torvalds "journal_read_trans skipping because %d is != " 21941da177e4SLinus Torvalds "newest_mount_id %lu", get_desc_mount_id(desc), 21951da177e4SLinus Torvalds newest_mount_id); 21961da177e4SLinus Torvalds brelse(d_bh); 21971da177e4SLinus Torvalds return 1; 21981da177e4SLinus Torvalds } 2199a9dd3643SJeff Mahoney c_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 22001da177e4SLinus Torvalds ((trans_offset + get_desc_trans_len(desc) + 1) % 2201a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb))); 22021da177e4SLinus Torvalds if (!c_bh) { 22031da177e4SLinus Torvalds brelse(d_bh); 22041da177e4SLinus Torvalds return 1; 22051da177e4SLinus Torvalds } 22061da177e4SLinus Torvalds commit = (struct reiserfs_journal_commit *)c_bh->b_data; 2207a9dd3643SJeff Mahoney if (journal_compare_desc_commit(sb, desc, commit)) { 2208a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2209bd4c625cSLinus Torvalds "journal_read_transaction, " 22101da177e4SLinus Torvalds "commit offset %llu had bad time %d or length %d", 2211bd4c625cSLinus Torvalds c_bh->b_blocknr - 2212a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb), 2213bd4c625cSLinus Torvalds get_commit_trans_id(commit), 2214bd4c625cSLinus Torvalds get_commit_trans_len(commit)); 22151da177e4SLinus Torvalds brelse(c_bh); 22161da177e4SLinus Torvalds brelse(d_bh); 22171da177e4SLinus Torvalds return 1; 22181da177e4SLinus Torvalds } 22191da177e4SLinus Torvalds trans_id = get_desc_trans_id(desc); 22201da177e4SLinus Torvalds /* now we know we've got a good transaction, and it was inside the valid time ranges */ 2221d739b42bSPekka Enberg log_blocks = kmalloc(get_desc_trans_len(desc) * 2222d739b42bSPekka Enberg sizeof(struct buffer_head *), GFP_NOFS); 2223d739b42bSPekka Enberg real_blocks = kmalloc(get_desc_trans_len(desc) * 2224d739b42bSPekka Enberg sizeof(struct buffer_head *), GFP_NOFS); 22251da177e4SLinus Torvalds if (!log_blocks || !real_blocks) { 22261da177e4SLinus Torvalds brelse(c_bh); 22271da177e4SLinus Torvalds brelse(d_bh); 2228d739b42bSPekka Enberg kfree(log_blocks); 2229d739b42bSPekka Enberg kfree(real_blocks); 2230a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1169", 223145b03d5eSJeff Mahoney "kmalloc failed, unable to mount FS"); 22321da177e4SLinus Torvalds return -1; 22331da177e4SLinus Torvalds } 22341da177e4SLinus Torvalds /* get all the buffer heads */ 2235a9dd3643SJeff Mahoney trans_half = journal_trans_half(sb->s_blocksize); 22361da177e4SLinus Torvalds for (i = 0; i < get_desc_trans_len(desc); i++) { 2237bd4c625cSLinus Torvalds log_blocks[i] = 2238a9dd3643SJeff Mahoney journal_getblk(sb, 2239a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2240bd4c625cSLinus Torvalds (trans_offset + 1 + 2241a9dd3643SJeff Mahoney i) % SB_ONDISK_JOURNAL_SIZE(sb)); 22421da177e4SLinus Torvalds if (i < trans_half) { 2243bd4c625cSLinus Torvalds real_blocks[i] = 2244a9dd3643SJeff Mahoney sb_getblk(sb, 2245bd4c625cSLinus Torvalds le32_to_cpu(desc->j_realblock[i])); 22461da177e4SLinus Torvalds } else { 2247bd4c625cSLinus Torvalds real_blocks[i] = 2248a9dd3643SJeff Mahoney sb_getblk(sb, 2249bd4c625cSLinus Torvalds le32_to_cpu(commit-> 2250bd4c625cSLinus Torvalds j_realblock[i - trans_half])); 22511da177e4SLinus Torvalds } 2252a9dd3643SJeff Mahoney if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(sb)) { 2253a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1207", 225445b03d5eSJeff Mahoney "REPLAY FAILURE fsck required! " 225545b03d5eSJeff Mahoney "Block to replay is outside of " 225645b03d5eSJeff Mahoney "filesystem"); 22571da177e4SLinus Torvalds goto abort_replay; 22581da177e4SLinus Torvalds } 22591da177e4SLinus Torvalds /* make sure we don't try to replay onto log or reserved area */ 2260bd4c625cSLinus Torvalds if (is_block_in_log_or_reserved_area 2261a9dd3643SJeff Mahoney (sb, real_blocks[i]->b_blocknr)) { 2262a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1204", 226345b03d5eSJeff Mahoney "REPLAY FAILURE fsck required! " 226445b03d5eSJeff Mahoney "Trying to replay onto a log block"); 22651da177e4SLinus Torvalds abort_replay: 22661da177e4SLinus Torvalds brelse_array(log_blocks, i); 22671da177e4SLinus Torvalds brelse_array(real_blocks, i); 22681da177e4SLinus Torvalds brelse(c_bh); 22691da177e4SLinus Torvalds brelse(d_bh); 2270d739b42bSPekka Enberg kfree(log_blocks); 2271d739b42bSPekka Enberg kfree(real_blocks); 22721da177e4SLinus Torvalds return -1; 22731da177e4SLinus Torvalds } 22741da177e4SLinus Torvalds } 22751da177e4SLinus Torvalds /* read in the log blocks, memcpy to the corresponding real block */ 22761da177e4SLinus Torvalds ll_rw_block(READ, get_desc_trans_len(desc), log_blocks); 22771da177e4SLinus Torvalds for (i = 0; i < get_desc_trans_len(desc); i++) { 22788ebc4232SFrederic Weisbecker 22798ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 22801da177e4SLinus Torvalds wait_on_buffer(log_blocks[i]); 22818ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 22828ebc4232SFrederic Weisbecker 22831da177e4SLinus Torvalds if (!buffer_uptodate(log_blocks[i])) { 2284a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1212", 228545b03d5eSJeff Mahoney "REPLAY FAILURE fsck required! " 228645b03d5eSJeff Mahoney "buffer write failed"); 2287bd4c625cSLinus Torvalds brelse_array(log_blocks + i, 2288bd4c625cSLinus Torvalds get_desc_trans_len(desc) - i); 22891da177e4SLinus Torvalds brelse_array(real_blocks, get_desc_trans_len(desc)); 22901da177e4SLinus Torvalds brelse(c_bh); 22911da177e4SLinus Torvalds brelse(d_bh); 2292d739b42bSPekka Enberg kfree(log_blocks); 2293d739b42bSPekka Enberg kfree(real_blocks); 22941da177e4SLinus Torvalds return -1; 22951da177e4SLinus Torvalds } 2296bd4c625cSLinus Torvalds memcpy(real_blocks[i]->b_data, log_blocks[i]->b_data, 2297bd4c625cSLinus Torvalds real_blocks[i]->b_size); 22981da177e4SLinus Torvalds set_buffer_uptodate(real_blocks[i]); 22991da177e4SLinus Torvalds brelse(log_blocks[i]); 23001da177e4SLinus Torvalds } 23011da177e4SLinus Torvalds /* flush out the real blocks */ 23021da177e4SLinus Torvalds for (i = 0; i < get_desc_trans_len(desc); i++) { 23031da177e4SLinus Torvalds set_buffer_dirty(real_blocks[i]); 230453778ffdSJan Kara ll_rw_block(SWRITE, 1, real_blocks + i); 23051da177e4SLinus Torvalds } 23061da177e4SLinus Torvalds for (i = 0; i < get_desc_trans_len(desc); i++) { 23071da177e4SLinus Torvalds wait_on_buffer(real_blocks[i]); 23081da177e4SLinus Torvalds if (!buffer_uptodate(real_blocks[i])) { 2309a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1226", 231045b03d5eSJeff Mahoney "REPLAY FAILURE, fsck required! " 231145b03d5eSJeff Mahoney "buffer write failed"); 2312bd4c625cSLinus Torvalds brelse_array(real_blocks + i, 2313bd4c625cSLinus Torvalds get_desc_trans_len(desc) - i); 23141da177e4SLinus Torvalds brelse(c_bh); 23151da177e4SLinus Torvalds brelse(d_bh); 2316d739b42bSPekka Enberg kfree(log_blocks); 2317d739b42bSPekka Enberg kfree(real_blocks); 23181da177e4SLinus Torvalds return -1; 23191da177e4SLinus Torvalds } 23201da177e4SLinus Torvalds brelse(real_blocks[i]); 23211da177e4SLinus Torvalds } 2322bd4c625cSLinus Torvalds cur_dblock = 2323a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2324bd4c625cSLinus Torvalds ((trans_offset + get_desc_trans_len(desc) + 2325a9dd3643SJeff Mahoney 2) % SB_ONDISK_JOURNAL_SIZE(sb)); 2326a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2327bd4c625cSLinus Torvalds "journal-1095: setting journal " "start to offset %ld", 2328a9dd3643SJeff Mahoney cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb)); 23291da177e4SLinus Torvalds 23301da177e4SLinus Torvalds /* init starting values for the first transaction, in case this is the last transaction to be replayed. */ 2331a9dd3643SJeff Mahoney journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb); 23321da177e4SLinus Torvalds journal->j_last_flush_trans_id = trans_id; 23331da177e4SLinus Torvalds journal->j_trans_id = trans_id + 1; 2334a44c94a7SAlexander Zarochentsev /* check for trans_id overflow */ 2335a44c94a7SAlexander Zarochentsev if (journal->j_trans_id == 0) 2336a44c94a7SAlexander Zarochentsev journal->j_trans_id = 10; 23371da177e4SLinus Torvalds brelse(c_bh); 23381da177e4SLinus Torvalds brelse(d_bh); 2339d739b42bSPekka Enberg kfree(log_blocks); 2340d739b42bSPekka Enberg kfree(real_blocks); 23411da177e4SLinus Torvalds return 0; 23421da177e4SLinus Torvalds } 23431da177e4SLinus Torvalds 23441da177e4SLinus Torvalds /* This function reads blocks starting from block and to max_block of bufsize 23451da177e4SLinus Torvalds size (but no more than BUFNR blocks at a time). This proved to improve 23461da177e4SLinus Torvalds mounting speed on self-rebuilding raid5 arrays at least. 23471da177e4SLinus Torvalds Right now it is only used from journal code. But later we might use it 23481da177e4SLinus Torvalds from other places. 23491da177e4SLinus Torvalds Note: Do not use journal_getblk/sb_getblk functions here! */ 23503ee16670SJeff Mahoney static struct buffer_head *reiserfs_breada(struct block_device *dev, 23513ee16670SJeff Mahoney b_blocknr_t block, int bufsize, 23523ee16670SJeff Mahoney b_blocknr_t max_block) 23531da177e4SLinus Torvalds { 23541da177e4SLinus Torvalds struct buffer_head *bhlist[BUFNR]; 23551da177e4SLinus Torvalds unsigned int blocks = BUFNR; 23561da177e4SLinus Torvalds struct buffer_head *bh; 23571da177e4SLinus Torvalds int i, j; 23581da177e4SLinus Torvalds 23591da177e4SLinus Torvalds bh = __getblk(dev, block, bufsize); 23601da177e4SLinus Torvalds if (buffer_uptodate(bh)) 23611da177e4SLinus Torvalds return (bh); 23621da177e4SLinus Torvalds 23631da177e4SLinus Torvalds if (block + BUFNR > max_block) { 23641da177e4SLinus Torvalds blocks = max_block - block; 23651da177e4SLinus Torvalds } 23661da177e4SLinus Torvalds bhlist[0] = bh; 23671da177e4SLinus Torvalds j = 1; 23681da177e4SLinus Torvalds for (i = 1; i < blocks; i++) { 23691da177e4SLinus Torvalds bh = __getblk(dev, block + i, bufsize); 23701da177e4SLinus Torvalds if (buffer_uptodate(bh)) { 23711da177e4SLinus Torvalds brelse(bh); 23721da177e4SLinus Torvalds break; 2373bd4c625cSLinus Torvalds } else 2374bd4c625cSLinus Torvalds bhlist[j++] = bh; 23751da177e4SLinus Torvalds } 23761da177e4SLinus Torvalds ll_rw_block(READ, j, bhlist); 23771da177e4SLinus Torvalds for (i = 1; i < j; i++) 23781da177e4SLinus Torvalds brelse(bhlist[i]); 23791da177e4SLinus Torvalds bh = bhlist[0]; 23801da177e4SLinus Torvalds wait_on_buffer(bh); 23811da177e4SLinus Torvalds if (buffer_uptodate(bh)) 23821da177e4SLinus Torvalds return bh; 23831da177e4SLinus Torvalds brelse(bh); 23841da177e4SLinus Torvalds return NULL; 23851da177e4SLinus Torvalds } 23861da177e4SLinus Torvalds 23871da177e4SLinus Torvalds /* 23881da177e4SLinus Torvalds ** read and replay the log 23891da177e4SLinus Torvalds ** on a clean unmount, the journal header's next unflushed pointer will be to an invalid 23901da177e4SLinus Torvalds ** transaction. This tests that before finding all the transactions in the log, which makes normal mount times fast. 23911da177e4SLinus Torvalds ** 23921da177e4SLinus Torvalds ** After a crash, this starts with the next unflushed transaction, and replays until it finds one too old, or invalid. 23931da177e4SLinus Torvalds ** 23941da177e4SLinus Torvalds ** On exit, it sets things up so the first transaction will work correctly. 23951da177e4SLinus Torvalds */ 2396a9dd3643SJeff Mahoney static int journal_read(struct super_block *sb) 2397bd4c625cSLinus Torvalds { 2398a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 23991da177e4SLinus Torvalds struct reiserfs_journal_desc *desc; 2400600ed416SJeff Mahoney unsigned int oldest_trans_id = 0; 2401600ed416SJeff Mahoney unsigned int oldest_invalid_trans_id = 0; 24021da177e4SLinus Torvalds time_t start; 24031da177e4SLinus Torvalds unsigned long oldest_start = 0; 24041da177e4SLinus Torvalds unsigned long cur_dblock = 0; 24051da177e4SLinus Torvalds unsigned long newest_mount_id = 9; 24061da177e4SLinus Torvalds struct buffer_head *d_bh; 24071da177e4SLinus Torvalds struct reiserfs_journal_header *jh; 24081da177e4SLinus Torvalds int valid_journal_header = 0; 24091da177e4SLinus Torvalds int replay_count = 0; 24101da177e4SLinus Torvalds int continue_replay = 1; 24111da177e4SLinus Torvalds int ret; 24121da177e4SLinus Torvalds char b[BDEVNAME_SIZE]; 24131da177e4SLinus Torvalds 2414a9dd3643SJeff Mahoney cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(sb); 2415a9dd3643SJeff Mahoney reiserfs_info(sb, "checking transaction log (%s)\n", 24161da177e4SLinus Torvalds bdevname(journal->j_dev_bd, b)); 24171da177e4SLinus Torvalds start = get_seconds(); 24181da177e4SLinus Torvalds 24191da177e4SLinus Torvalds /* step 1, read in the journal header block. Check the transaction it says 24201da177e4SLinus Torvalds ** is the first unflushed, and if that transaction is not valid, 24211da177e4SLinus Torvalds ** replay is done 24221da177e4SLinus Torvalds */ 2423a9dd3643SJeff Mahoney journal->j_header_bh = journal_bread(sb, 2424a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) 2425a9dd3643SJeff Mahoney + SB_ONDISK_JOURNAL_SIZE(sb)); 24261da177e4SLinus Torvalds if (!journal->j_header_bh) { 24271da177e4SLinus Torvalds return 1; 24281da177e4SLinus Torvalds } 24291da177e4SLinus Torvalds jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data); 2430c499ec24SVladimir V. Saveliev if (le32_to_cpu(jh->j_first_unflushed_offset) < 2431a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb) 2432bd4c625cSLinus Torvalds && le32_to_cpu(jh->j_last_flush_trans_id) > 0) { 2433bd4c625cSLinus Torvalds oldest_start = 2434a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 24351da177e4SLinus Torvalds le32_to_cpu(jh->j_first_unflushed_offset); 24361da177e4SLinus Torvalds oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1; 24371da177e4SLinus Torvalds newest_mount_id = le32_to_cpu(jh->j_mount_id); 2438a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2439bd4c625cSLinus Torvalds "journal-1153: found in " 24401da177e4SLinus Torvalds "header: first_unflushed_offset %d, last_flushed_trans_id " 24411da177e4SLinus Torvalds "%lu", le32_to_cpu(jh->j_first_unflushed_offset), 24421da177e4SLinus Torvalds le32_to_cpu(jh->j_last_flush_trans_id)); 24431da177e4SLinus Torvalds valid_journal_header = 1; 24441da177e4SLinus Torvalds 24451da177e4SLinus Torvalds /* now, we try to read the first unflushed offset. If it is not valid, 24461da177e4SLinus Torvalds ** there is nothing more we can do, and it makes no sense to read 24471da177e4SLinus Torvalds ** through the whole log. 24481da177e4SLinus Torvalds */ 2449bd4c625cSLinus Torvalds d_bh = 2450a9dd3643SJeff Mahoney journal_bread(sb, 2451a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2452bd4c625cSLinus Torvalds le32_to_cpu(jh->j_first_unflushed_offset)); 2453a9dd3643SJeff Mahoney ret = journal_transaction_is_valid(sb, d_bh, NULL, NULL); 24541da177e4SLinus Torvalds if (!ret) { 24551da177e4SLinus Torvalds continue_replay = 0; 24561da177e4SLinus Torvalds } 24571da177e4SLinus Torvalds brelse(d_bh); 24581da177e4SLinus Torvalds goto start_log_replay; 24591da177e4SLinus Torvalds } 24601da177e4SLinus Torvalds 2461a9dd3643SJeff Mahoney if (continue_replay && bdev_read_only(sb->s_bdev)) { 2462a9dd3643SJeff Mahoney reiserfs_warning(sb, "clm-2076", 246345b03d5eSJeff Mahoney "device is readonly, unable to replay log"); 24641da177e4SLinus Torvalds return -1; 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds 24671da177e4SLinus Torvalds /* ok, there are transactions that need to be replayed. start with the first log block, find 24681da177e4SLinus Torvalds ** all the valid transactions, and pick out the oldest. 24691da177e4SLinus Torvalds */ 2470bd4c625cSLinus Torvalds while (continue_replay 2471bd4c625cSLinus Torvalds && cur_dblock < 2472a9dd3643SJeff Mahoney (SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2473a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb))) { 24741da177e4SLinus Torvalds /* Note that it is required for blocksize of primary fs device and journal 24751da177e4SLinus Torvalds device to be the same */ 2476bd4c625cSLinus Torvalds d_bh = 2477bd4c625cSLinus Torvalds reiserfs_breada(journal->j_dev_bd, cur_dblock, 2478a9dd3643SJeff Mahoney sb->s_blocksize, 2479a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2480a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb)); 2481bd4c625cSLinus Torvalds ret = 2482a9dd3643SJeff Mahoney journal_transaction_is_valid(sb, d_bh, 2483bd4c625cSLinus Torvalds &oldest_invalid_trans_id, 2484bd4c625cSLinus Torvalds &newest_mount_id); 24851da177e4SLinus Torvalds if (ret == 1) { 24861da177e4SLinus Torvalds desc = (struct reiserfs_journal_desc *)d_bh->b_data; 24871da177e4SLinus Torvalds if (oldest_start == 0) { /* init all oldest_ values */ 24881da177e4SLinus Torvalds oldest_trans_id = get_desc_trans_id(desc); 24891da177e4SLinus Torvalds oldest_start = d_bh->b_blocknr; 24901da177e4SLinus Torvalds newest_mount_id = get_desc_mount_id(desc); 2491a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2492bd4c625cSLinus Torvalds "journal-1179: Setting " 24931da177e4SLinus Torvalds "oldest_start to offset %llu, trans_id %lu", 2494bd4c625cSLinus Torvalds oldest_start - 2495bd4c625cSLinus Torvalds SB_ONDISK_JOURNAL_1st_BLOCK 2496a9dd3643SJeff Mahoney (sb), oldest_trans_id); 24971da177e4SLinus Torvalds } else if (oldest_trans_id > get_desc_trans_id(desc)) { 24981da177e4SLinus Torvalds /* one we just read was older */ 24991da177e4SLinus Torvalds oldest_trans_id = get_desc_trans_id(desc); 25001da177e4SLinus Torvalds oldest_start = d_bh->b_blocknr; 2501a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2502bd4c625cSLinus Torvalds "journal-1180: Resetting " 25031da177e4SLinus Torvalds "oldest_start to offset %lu, trans_id %lu", 2504bd4c625cSLinus Torvalds oldest_start - 2505bd4c625cSLinus Torvalds SB_ONDISK_JOURNAL_1st_BLOCK 2506a9dd3643SJeff Mahoney (sb), oldest_trans_id); 25071da177e4SLinus Torvalds } 25081da177e4SLinus Torvalds if (newest_mount_id < get_desc_mount_id(desc)) { 25091da177e4SLinus Torvalds newest_mount_id = get_desc_mount_id(desc); 2510a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2511bd4c625cSLinus Torvalds "journal-1299: Setting " 2512bd4c625cSLinus Torvalds "newest_mount_id to %d", 2513bd4c625cSLinus Torvalds get_desc_mount_id(desc)); 25141da177e4SLinus Torvalds } 25151da177e4SLinus Torvalds cur_dblock += get_desc_trans_len(desc) + 2; 25161da177e4SLinus Torvalds } else { 25171da177e4SLinus Torvalds cur_dblock++; 25181da177e4SLinus Torvalds } 25191da177e4SLinus Torvalds brelse(d_bh); 25201da177e4SLinus Torvalds } 25211da177e4SLinus Torvalds 25221da177e4SLinus Torvalds start_log_replay: 25231da177e4SLinus Torvalds cur_dblock = oldest_start; 25241da177e4SLinus Torvalds if (oldest_trans_id) { 2525a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2526bd4c625cSLinus Torvalds "journal-1206: Starting replay " 25271da177e4SLinus Torvalds "from offset %llu, trans_id %lu", 2528a9dd3643SJeff Mahoney cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb), 25291da177e4SLinus Torvalds oldest_trans_id); 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds } 25321da177e4SLinus Torvalds replay_count = 0; 25331da177e4SLinus Torvalds while (continue_replay && oldest_trans_id > 0) { 2534bd4c625cSLinus Torvalds ret = 2535a9dd3643SJeff Mahoney journal_read_transaction(sb, cur_dblock, oldest_start, 2536bd4c625cSLinus Torvalds oldest_trans_id, newest_mount_id); 25371da177e4SLinus Torvalds if (ret < 0) { 25381da177e4SLinus Torvalds return ret; 25391da177e4SLinus Torvalds } else if (ret != 0) { 25401da177e4SLinus Torvalds break; 25411da177e4SLinus Torvalds } 2542bd4c625cSLinus Torvalds cur_dblock = 2543a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + journal->j_start; 25441da177e4SLinus Torvalds replay_count++; 25451da177e4SLinus Torvalds if (cur_dblock == oldest_start) 25461da177e4SLinus Torvalds break; 25471da177e4SLinus Torvalds } 25481da177e4SLinus Torvalds 25491da177e4SLinus Torvalds if (oldest_trans_id == 0) { 2550a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, 2551bd4c625cSLinus Torvalds "journal-1225: No valid " "transactions found"); 25521da177e4SLinus Torvalds } 25531da177e4SLinus Torvalds /* j_start does not get set correctly if we don't replay any transactions. 25541da177e4SLinus Torvalds ** if we had a valid journal_header, set j_start to the first unflushed transaction value, 25551da177e4SLinus Torvalds ** copy the trans_id from the header 25561da177e4SLinus Torvalds */ 25571da177e4SLinus Torvalds if (valid_journal_header && replay_count == 0) { 25581da177e4SLinus Torvalds journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset); 2559bd4c625cSLinus Torvalds journal->j_trans_id = 2560bd4c625cSLinus Torvalds le32_to_cpu(jh->j_last_flush_trans_id) + 1; 2561a44c94a7SAlexander Zarochentsev /* check for trans_id overflow */ 2562a44c94a7SAlexander Zarochentsev if (journal->j_trans_id == 0) 2563a44c94a7SAlexander Zarochentsev journal->j_trans_id = 10; 2564bd4c625cSLinus Torvalds journal->j_last_flush_trans_id = 2565bd4c625cSLinus Torvalds le32_to_cpu(jh->j_last_flush_trans_id); 25661da177e4SLinus Torvalds journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1; 25671da177e4SLinus Torvalds } else { 25681da177e4SLinus Torvalds journal->j_mount_id = newest_mount_id + 1; 25691da177e4SLinus Torvalds } 2570a9dd3643SJeff Mahoney reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1299: Setting " 25711da177e4SLinus Torvalds "newest_mount_id to %lu", journal->j_mount_id); 25721da177e4SLinus Torvalds journal->j_first_unflushed_offset = journal->j_start; 25731da177e4SLinus Torvalds if (replay_count > 0) { 2574a9dd3643SJeff Mahoney reiserfs_info(sb, 2575bd4c625cSLinus Torvalds "replayed %d transactions in %lu seconds\n", 25761da177e4SLinus Torvalds replay_count, get_seconds() - start); 25771da177e4SLinus Torvalds } 2578a9dd3643SJeff Mahoney if (!bdev_read_only(sb->s_bdev) && 2579a9dd3643SJeff Mahoney _update_journal_header_block(sb, journal->j_start, 2580bd4c625cSLinus Torvalds journal->j_last_flush_trans_id)) { 25811da177e4SLinus Torvalds /* replay failed, caller must call free_journal_ram and abort 25821da177e4SLinus Torvalds ** the mount 25831da177e4SLinus Torvalds */ 25841da177e4SLinus Torvalds return -1; 25851da177e4SLinus Torvalds } 25861da177e4SLinus Torvalds return 0; 25871da177e4SLinus Torvalds } 25881da177e4SLinus Torvalds 25891da177e4SLinus Torvalds static struct reiserfs_journal_list *alloc_journal_list(struct super_block *s) 25901da177e4SLinus Torvalds { 25911da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 25928c777cc4SPekka Enberg jl = kzalloc(sizeof(struct reiserfs_journal_list), 25938c777cc4SPekka Enberg GFP_NOFS | __GFP_NOFAIL); 25941da177e4SLinus Torvalds INIT_LIST_HEAD(&jl->j_list); 25951da177e4SLinus Torvalds INIT_LIST_HEAD(&jl->j_working_list); 25961da177e4SLinus Torvalds INIT_LIST_HEAD(&jl->j_tail_bh_list); 25971da177e4SLinus Torvalds INIT_LIST_HEAD(&jl->j_bh_list); 259890415deaSJeff Mahoney mutex_init(&jl->j_commit_mutex); 25991da177e4SLinus Torvalds SB_JOURNAL(s)->j_num_lists++; 26001da177e4SLinus Torvalds get_journal_list(jl); 26011da177e4SLinus Torvalds return jl; 26021da177e4SLinus Torvalds } 26031da177e4SLinus Torvalds 2604a9dd3643SJeff Mahoney static void journal_list_init(struct super_block *sb) 2605bd4c625cSLinus Torvalds { 2606a9dd3643SJeff Mahoney SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb); 26071da177e4SLinus Torvalds } 26081da177e4SLinus Torvalds 26091da177e4SLinus Torvalds static int release_journal_dev(struct super_block *super, 26101da177e4SLinus Torvalds struct reiserfs_journal *journal) 26111da177e4SLinus Torvalds { 26121da177e4SLinus Torvalds int result; 26131da177e4SLinus Torvalds 26141da177e4SLinus Torvalds result = 0; 26151da177e4SLinus Torvalds 261686098fa0SChristoph Hellwig if (journal->j_dev_bd != NULL) { 261786098fa0SChristoph Hellwig if (journal->j_dev_bd->bd_dev != super->s_dev) 261886098fa0SChristoph Hellwig bd_release(journal->j_dev_bd); 2619e5eb8caaSAl Viro result = blkdev_put(journal->j_dev_bd, journal->j_dev_mode); 26201da177e4SLinus Torvalds journal->j_dev_bd = NULL; 26211da177e4SLinus Torvalds } 26221da177e4SLinus Torvalds 26231da177e4SLinus Torvalds if (result != 0) { 262445b03d5eSJeff Mahoney reiserfs_warning(super, "sh-457", 262545b03d5eSJeff Mahoney "Cannot release journal device: %i", result); 26261da177e4SLinus Torvalds } 26271da177e4SLinus Torvalds return result; 26281da177e4SLinus Torvalds } 26291da177e4SLinus Torvalds 26301da177e4SLinus Torvalds static int journal_init_dev(struct super_block *super, 26311da177e4SLinus Torvalds struct reiserfs_journal *journal, 26321da177e4SLinus Torvalds const char *jdev_name) 26331da177e4SLinus Torvalds { 26341da177e4SLinus Torvalds int result; 26351da177e4SLinus Torvalds dev_t jdev; 2636aeb5d727SAl Viro fmode_t blkdev_mode = FMODE_READ | FMODE_WRITE; 26371da177e4SLinus Torvalds char b[BDEVNAME_SIZE]; 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds result = 0; 26401da177e4SLinus Torvalds 26411da177e4SLinus Torvalds journal->j_dev_bd = NULL; 26421da177e4SLinus Torvalds jdev = SB_ONDISK_JOURNAL_DEVICE(super) ? 26431da177e4SLinus Torvalds new_decode_dev(SB_ONDISK_JOURNAL_DEVICE(super)) : super->s_dev; 26441da177e4SLinus Torvalds 26451da177e4SLinus Torvalds if (bdev_read_only(super->s_bdev)) 26461da177e4SLinus Torvalds blkdev_mode = FMODE_READ; 26471da177e4SLinus Torvalds 26481da177e4SLinus Torvalds /* there is no "jdev" option and journal is on separate device */ 26491da177e4SLinus Torvalds if ((!jdev_name || !jdev_name[0])) { 26501da177e4SLinus Torvalds journal->j_dev_bd = open_by_devnum(jdev, blkdev_mode); 2651e5eb8caaSAl Viro journal->j_dev_mode = blkdev_mode; 26521da177e4SLinus Torvalds if (IS_ERR(journal->j_dev_bd)) { 26531da177e4SLinus Torvalds result = PTR_ERR(journal->j_dev_bd); 26541da177e4SLinus Torvalds journal->j_dev_bd = NULL; 265545b03d5eSJeff Mahoney reiserfs_warning(super, "sh-458", 26561da177e4SLinus Torvalds "cannot init journal device '%s': %i", 26571da177e4SLinus Torvalds __bdevname(jdev, b), result); 26581da177e4SLinus Torvalds return result; 265986098fa0SChristoph Hellwig } else if (jdev != super->s_dev) { 266086098fa0SChristoph Hellwig result = bd_claim(journal->j_dev_bd, journal); 266186098fa0SChristoph Hellwig if (result) { 26629a1c3542SAl Viro blkdev_put(journal->j_dev_bd, blkdev_mode); 266386098fa0SChristoph Hellwig return result; 266486098fa0SChristoph Hellwig } 266586098fa0SChristoph Hellwig 26661da177e4SLinus Torvalds set_blocksize(journal->j_dev_bd, super->s_blocksize); 266786098fa0SChristoph Hellwig } 266886098fa0SChristoph Hellwig 26691da177e4SLinus Torvalds return 0; 26701da177e4SLinus Torvalds } 26711da177e4SLinus Torvalds 2672e5eb8caaSAl Viro journal->j_dev_mode = blkdev_mode; 267330c40d2cSAl Viro journal->j_dev_bd = open_bdev_exclusive(jdev_name, 2674e5eb8caaSAl Viro blkdev_mode, journal); 267586098fa0SChristoph Hellwig if (IS_ERR(journal->j_dev_bd)) { 267686098fa0SChristoph Hellwig result = PTR_ERR(journal->j_dev_bd); 267786098fa0SChristoph Hellwig journal->j_dev_bd = NULL; 267886098fa0SChristoph Hellwig reiserfs_warning(super, 267986098fa0SChristoph Hellwig "journal_init_dev: Cannot open '%s': %i", 268086098fa0SChristoph Hellwig jdev_name, result); 268186098fa0SChristoph Hellwig return result; 268286098fa0SChristoph Hellwig } 268386098fa0SChristoph Hellwig 26841da177e4SLinus Torvalds set_blocksize(journal->j_dev_bd, super->s_blocksize); 2685bd4c625cSLinus Torvalds reiserfs_info(super, 2686bd4c625cSLinus Torvalds "journal_init_dev: journal device: %s\n", 268774f9f974SEdward Shishkin bdevname(journal->j_dev_bd, b)); 268886098fa0SChristoph Hellwig return 0; 26891da177e4SLinus Torvalds } 26901da177e4SLinus Torvalds 2691cf3d0b81SEdward Shishkin /** 2692cf3d0b81SEdward Shishkin * When creating/tuning a file system user can assign some 2693cf3d0b81SEdward Shishkin * journal params within boundaries which depend on the ratio 2694cf3d0b81SEdward Shishkin * blocksize/standard_blocksize. 2695cf3d0b81SEdward Shishkin * 2696cf3d0b81SEdward Shishkin * For blocks >= standard_blocksize transaction size should 2697cf3d0b81SEdward Shishkin * be not less then JOURNAL_TRANS_MIN_DEFAULT, and not more 2698cf3d0b81SEdward Shishkin * then JOURNAL_TRANS_MAX_DEFAULT. 2699cf3d0b81SEdward Shishkin * 2700cf3d0b81SEdward Shishkin * For blocks < standard_blocksize these boundaries should be 2701cf3d0b81SEdward Shishkin * decreased proportionally. 2702cf3d0b81SEdward Shishkin */ 2703cf3d0b81SEdward Shishkin #define REISERFS_STANDARD_BLKSIZE (4096) 2704cf3d0b81SEdward Shishkin 2705a9dd3643SJeff Mahoney static int check_advise_trans_params(struct super_block *sb, 2706cf3d0b81SEdward Shishkin struct reiserfs_journal *journal) 2707cf3d0b81SEdward Shishkin { 2708cf3d0b81SEdward Shishkin if (journal->j_trans_max) { 2709cf3d0b81SEdward Shishkin /* Non-default journal params. 2710cf3d0b81SEdward Shishkin Do sanity check for them. */ 2711cf3d0b81SEdward Shishkin int ratio = 1; 2712a9dd3643SJeff Mahoney if (sb->s_blocksize < REISERFS_STANDARD_BLKSIZE) 2713a9dd3643SJeff Mahoney ratio = REISERFS_STANDARD_BLKSIZE / sb->s_blocksize; 2714cf3d0b81SEdward Shishkin 2715cf3d0b81SEdward Shishkin if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio || 2716cf3d0b81SEdward Shishkin journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio || 2717a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb) / journal->j_trans_max < 2718cf3d0b81SEdward Shishkin JOURNAL_MIN_RATIO) { 2719a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-462", 272045b03d5eSJeff Mahoney "bad transaction max size (%u). " 272145b03d5eSJeff Mahoney "FSCK?", journal->j_trans_max); 2722cf3d0b81SEdward Shishkin return 1; 2723cf3d0b81SEdward Shishkin } 2724cf3d0b81SEdward Shishkin if (journal->j_max_batch != (journal->j_trans_max) * 2725cf3d0b81SEdward Shishkin JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) { 2726a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-463", 272745b03d5eSJeff Mahoney "bad transaction max batch (%u). " 272845b03d5eSJeff Mahoney "FSCK?", journal->j_max_batch); 2729cf3d0b81SEdward Shishkin return 1; 2730cf3d0b81SEdward Shishkin } 2731cf3d0b81SEdward Shishkin } else { 2732cf3d0b81SEdward Shishkin /* Default journal params. 2733cf3d0b81SEdward Shishkin The file system was created by old version 2734cf3d0b81SEdward Shishkin of mkreiserfs, so some fields contain zeros, 2735cf3d0b81SEdward Shishkin and we need to advise proper values for them */ 2736a9dd3643SJeff Mahoney if (sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) { 2737a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-464", "bad blocksize (%u)", 2738a9dd3643SJeff Mahoney sb->s_blocksize); 273945b03d5eSJeff Mahoney return 1; 274045b03d5eSJeff Mahoney } 2741cf3d0b81SEdward Shishkin journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT; 2742cf3d0b81SEdward Shishkin journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT; 2743cf3d0b81SEdward Shishkin journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE; 2744cf3d0b81SEdward Shishkin } 2745cf3d0b81SEdward Shishkin return 0; 2746cf3d0b81SEdward Shishkin } 2747cf3d0b81SEdward Shishkin 27481da177e4SLinus Torvalds /* 27491da177e4SLinus Torvalds ** must be called once on fs mount. calls journal_read for you 27501da177e4SLinus Torvalds */ 2751a9dd3643SJeff Mahoney int journal_init(struct super_block *sb, const char *j_dev_name, 2752bd4c625cSLinus Torvalds int old_format, unsigned int commit_max_age) 2753bd4c625cSLinus Torvalds { 2754a9dd3643SJeff Mahoney int num_cnodes = SB_ONDISK_JOURNAL_SIZE(sb) * 2; 27551da177e4SLinus Torvalds struct buffer_head *bhjh; 27561da177e4SLinus Torvalds struct reiserfs_super_block *rs; 27571da177e4SLinus Torvalds struct reiserfs_journal_header *jh; 27581da177e4SLinus Torvalds struct reiserfs_journal *journal; 27591da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 27601da177e4SLinus Torvalds char b[BDEVNAME_SIZE]; 276198ea3f50SFrederic Weisbecker int ret; 27621da177e4SLinus Torvalds 276398ea3f50SFrederic Weisbecker /* 276498ea3f50SFrederic Weisbecker * Unlock here to avoid various RECLAIM-FS-ON <-> IN-RECLAIM-FS 276598ea3f50SFrederic Weisbecker * dependency inversion warnings. 276698ea3f50SFrederic Weisbecker */ 276798ea3f50SFrederic Weisbecker reiserfs_write_unlock(sb); 2768a9dd3643SJeff Mahoney journal = SB_JOURNAL(sb) = vmalloc(sizeof(struct reiserfs_journal)); 27691da177e4SLinus Torvalds if (!journal) { 2770a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1256", 277145b03d5eSJeff Mahoney "unable to get memory for journal structure"); 277298ea3f50SFrederic Weisbecker reiserfs_write_lock(sb); 27731da177e4SLinus Torvalds return 1; 27741da177e4SLinus Torvalds } 27751da177e4SLinus Torvalds memset(journal, 0, sizeof(struct reiserfs_journal)); 27761da177e4SLinus Torvalds INIT_LIST_HEAD(&journal->j_bitmap_nodes); 27771da177e4SLinus Torvalds INIT_LIST_HEAD(&journal->j_prealloc_list); 27781da177e4SLinus Torvalds INIT_LIST_HEAD(&journal->j_working_list); 27791da177e4SLinus Torvalds INIT_LIST_HEAD(&journal->j_journal_list); 27801da177e4SLinus Torvalds journal->j_persistent_trans = 0; 278198ea3f50SFrederic Weisbecker ret = reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap, 278298ea3f50SFrederic Weisbecker reiserfs_bmap_count(sb)); 278398ea3f50SFrederic Weisbecker reiserfs_write_lock(sb); 278498ea3f50SFrederic Weisbecker if (ret) 27851da177e4SLinus Torvalds goto free_and_return; 278698ea3f50SFrederic Weisbecker 2787a9dd3643SJeff Mahoney allocate_bitmap_nodes(sb); 27881da177e4SLinus Torvalds 27891da177e4SLinus Torvalds /* reserved for journal area support */ 2790a9dd3643SJeff Mahoney SB_JOURNAL_1st_RESERVED_BLOCK(sb) = (old_format ? 2791bd4c625cSLinus Torvalds REISERFS_OLD_DISK_OFFSET_IN_BYTES 2792a9dd3643SJeff Mahoney / sb->s_blocksize + 2793a9dd3643SJeff Mahoney reiserfs_bmap_count(sb) + 2794bd4c625cSLinus Torvalds 1 : 2795bd4c625cSLinus Torvalds REISERFS_DISK_OFFSET_IN_BYTES / 2796a9dd3643SJeff Mahoney sb->s_blocksize + 2); 27971da177e4SLinus Torvalds 27981da177e4SLinus Torvalds /* Sanity check to see is the standard journal fitting withing first bitmap 27991da177e4SLinus Torvalds (actual for small blocksizes) */ 2800a9dd3643SJeff Mahoney if (!SB_ONDISK_JOURNAL_DEVICE(sb) && 2801a9dd3643SJeff Mahoney (SB_JOURNAL_1st_RESERVED_BLOCK(sb) + 2802a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb) > sb->s_blocksize * 8)) { 2803a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1393", 280445b03d5eSJeff Mahoney "journal does not fit for area addressed " 280545b03d5eSJeff Mahoney "by first of bitmap blocks. It starts at " 28061da177e4SLinus Torvalds "%u and its size is %u. Block size %ld", 2807a9dd3643SJeff Mahoney SB_JOURNAL_1st_RESERVED_BLOCK(sb), 2808a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb), 2809a9dd3643SJeff Mahoney sb->s_blocksize); 28101da177e4SLinus Torvalds goto free_and_return; 28111da177e4SLinus Torvalds } 28121da177e4SLinus Torvalds 2813193be0eeSFrederic Weisbecker /* 2814193be0eeSFrederic Weisbecker * We need to unlock here to avoid creating the following 2815193be0eeSFrederic Weisbecker * dependency: 2816193be0eeSFrederic Weisbecker * reiserfs_lock -> sysfs_mutex 2817193be0eeSFrederic Weisbecker * Because the reiserfs mmap path creates the following dependency: 2818193be0eeSFrederic Weisbecker * mm->mmap -> reiserfs_lock, hence we have 2819193be0eeSFrederic Weisbecker * mm->mmap -> reiserfs_lock ->sysfs_mutex 2820193be0eeSFrederic Weisbecker * This would ends up in a circular dependency with sysfs readdir path 2821193be0eeSFrederic Weisbecker * which does sysfs_mutex -> mm->mmap_sem 2822193be0eeSFrederic Weisbecker * This is fine because the reiserfs lock is useless in mount path, 2823193be0eeSFrederic Weisbecker * at least until we call journal_begin. We keep it for paranoid 2824193be0eeSFrederic Weisbecker * reasons. 2825193be0eeSFrederic Weisbecker */ 2826193be0eeSFrederic Weisbecker reiserfs_write_unlock(sb); 2827a9dd3643SJeff Mahoney if (journal_init_dev(sb, journal, j_dev_name) != 0) { 2828193be0eeSFrederic Weisbecker reiserfs_write_lock(sb); 2829a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-462", 283045b03d5eSJeff Mahoney "unable to initialize jornal device"); 28311da177e4SLinus Torvalds goto free_and_return; 28321da177e4SLinus Torvalds } 2833193be0eeSFrederic Weisbecker reiserfs_write_lock(sb); 28341da177e4SLinus Torvalds 2835a9dd3643SJeff Mahoney rs = SB_DISK_SUPER_BLOCK(sb); 28361da177e4SLinus Torvalds 28371da177e4SLinus Torvalds /* read journal header */ 2838a9dd3643SJeff Mahoney bhjh = journal_bread(sb, 2839a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 2840a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb)); 28411da177e4SLinus Torvalds if (!bhjh) { 2842a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-459", 284345b03d5eSJeff Mahoney "unable to read journal header"); 28441da177e4SLinus Torvalds goto free_and_return; 28451da177e4SLinus Torvalds } 28461da177e4SLinus Torvalds jh = (struct reiserfs_journal_header *)(bhjh->b_data); 28471da177e4SLinus Torvalds 28481da177e4SLinus Torvalds /* make sure that journal matches to the super block */ 2849bd4c625cSLinus Torvalds if (is_reiserfs_jr(rs) 2850bd4c625cSLinus Torvalds && (le32_to_cpu(jh->jh_journal.jp_journal_magic) != 2851bd4c625cSLinus Torvalds sb_jp_journal_magic(rs))) { 2852a9dd3643SJeff Mahoney reiserfs_warning(sb, "sh-460", 285345b03d5eSJeff Mahoney "journal header magic %x (device %s) does " 285445b03d5eSJeff Mahoney "not match to magic found in super block %x", 285545b03d5eSJeff Mahoney jh->jh_journal.jp_journal_magic, 28561da177e4SLinus Torvalds bdevname(journal->j_dev_bd, b), 28571da177e4SLinus Torvalds sb_jp_journal_magic(rs)); 28581da177e4SLinus Torvalds brelse(bhjh); 28591da177e4SLinus Torvalds goto free_and_return; 28601da177e4SLinus Torvalds } 28611da177e4SLinus Torvalds 28621da177e4SLinus Torvalds journal->j_trans_max = le32_to_cpu(jh->jh_journal.jp_journal_trans_max); 28631da177e4SLinus Torvalds journal->j_max_batch = le32_to_cpu(jh->jh_journal.jp_journal_max_batch); 2864bd4c625cSLinus Torvalds journal->j_max_commit_age = 2865bd4c625cSLinus Torvalds le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age); 28661da177e4SLinus Torvalds journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE; 28671da177e4SLinus Torvalds 2868a9dd3643SJeff Mahoney if (check_advise_trans_params(sb, journal) != 0) 2869cf3d0b81SEdward Shishkin goto free_and_return; 28701da177e4SLinus Torvalds journal->j_default_max_commit_age = journal->j_max_commit_age; 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds if (commit_max_age != 0) { 28731da177e4SLinus Torvalds journal->j_max_commit_age = commit_max_age; 28741da177e4SLinus Torvalds journal->j_max_trans_age = commit_max_age; 28751da177e4SLinus Torvalds } 28761da177e4SLinus Torvalds 2877a9dd3643SJeff Mahoney reiserfs_info(sb, "journal params: device %s, size %u, " 28781da177e4SLinus Torvalds "journal first block %u, max trans len %u, max batch %u, " 28791da177e4SLinus Torvalds "max commit age %u, max trans age %u\n", 28801da177e4SLinus Torvalds bdevname(journal->j_dev_bd, b), 2881a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb), 2882a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb), 28831da177e4SLinus Torvalds journal->j_trans_max, 28841da177e4SLinus Torvalds journal->j_max_batch, 2885bd4c625cSLinus Torvalds journal->j_max_commit_age, journal->j_max_trans_age); 28861da177e4SLinus Torvalds 28871da177e4SLinus Torvalds brelse(bhjh); 28881da177e4SLinus Torvalds 28891da177e4SLinus Torvalds journal->j_list_bitmap_index = 0; 2890a9dd3643SJeff Mahoney journal_list_init(sb); 28911da177e4SLinus Torvalds 2892bd4c625cSLinus Torvalds memset(journal->j_list_hash_table, 0, 2893bd4c625cSLinus Torvalds JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *)); 28941da177e4SLinus Torvalds 28951da177e4SLinus Torvalds INIT_LIST_HEAD(&journal->j_dirty_buffers); 28961da177e4SLinus Torvalds spin_lock_init(&journal->j_dirty_buffers_lock); 28971da177e4SLinus Torvalds 28981da177e4SLinus Torvalds journal->j_start = 0; 28991da177e4SLinus Torvalds journal->j_len = 0; 29001da177e4SLinus Torvalds journal->j_len_alloc = 0; 29011da177e4SLinus Torvalds atomic_set(&(journal->j_wcount), 0); 29021da177e4SLinus Torvalds atomic_set(&(journal->j_async_throttle), 0); 29031da177e4SLinus Torvalds journal->j_bcount = 0; 29041da177e4SLinus Torvalds journal->j_trans_start_time = 0; 29051da177e4SLinus Torvalds journal->j_last = NULL; 29061da177e4SLinus Torvalds journal->j_first = NULL; 29071da177e4SLinus Torvalds init_waitqueue_head(&(journal->j_join_wait)); 2908f68215c4SJeff Mahoney mutex_init(&journal->j_mutex); 2909afe70259SJeff Mahoney mutex_init(&journal->j_flush_mutex); 29101da177e4SLinus Torvalds 29111da177e4SLinus Torvalds journal->j_trans_id = 10; 29121da177e4SLinus Torvalds journal->j_mount_id = 10; 29131da177e4SLinus Torvalds journal->j_state = 0; 29141da177e4SLinus Torvalds atomic_set(&(journal->j_jlock), 0); 29151da177e4SLinus Torvalds journal->j_cnode_free_list = allocate_cnodes(num_cnodes); 29161da177e4SLinus Torvalds journal->j_cnode_free_orig = journal->j_cnode_free_list; 29171da177e4SLinus Torvalds journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0; 29181da177e4SLinus Torvalds journal->j_cnode_used = 0; 29191da177e4SLinus Torvalds journal->j_must_wait = 0; 29201da177e4SLinus Torvalds 2921576f6d79SJeff Mahoney if (journal->j_cnode_free == 0) { 2922a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-2004", "Journal cnode memory " 2923576f6d79SJeff Mahoney "allocation failed (%ld bytes). Journal is " 2924576f6d79SJeff Mahoney "too large for available memory. Usually " 2925576f6d79SJeff Mahoney "this is due to a journal that is too large.", 2926576f6d79SJeff Mahoney sizeof (struct reiserfs_journal_cnode) * num_cnodes); 2927576f6d79SJeff Mahoney goto free_and_return; 2928576f6d79SJeff Mahoney } 2929576f6d79SJeff Mahoney 2930a9dd3643SJeff Mahoney init_journal_hash(sb); 29311da177e4SLinus Torvalds jl = journal->j_current_jl; 2932a9dd3643SJeff Mahoney jl->j_list_bitmap = get_list_bitmap(sb, jl); 29331da177e4SLinus Torvalds if (!jl->j_list_bitmap) { 2934a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-2005", 293545b03d5eSJeff Mahoney "get_list_bitmap failed for journal list 0"); 29361da177e4SLinus Torvalds goto free_and_return; 29371da177e4SLinus Torvalds } 2938a9dd3643SJeff Mahoney if (journal_read(sb) < 0) { 2939a9dd3643SJeff Mahoney reiserfs_warning(sb, "reiserfs-2006", 294045b03d5eSJeff Mahoney "Replay Failure, unable to mount"); 29411da177e4SLinus Torvalds goto free_and_return; 29421da177e4SLinus Torvalds } 29431da177e4SLinus Torvalds 29441da177e4SLinus Torvalds reiserfs_mounted_fs_count++; 294548f6ba5eSFrederic Weisbecker if (reiserfs_mounted_fs_count <= 1) { 294648f6ba5eSFrederic Weisbecker reiserfs_write_unlock(sb); 29471da177e4SLinus Torvalds commit_wq = create_workqueue("reiserfs"); 294848f6ba5eSFrederic Weisbecker reiserfs_write_lock(sb); 294948f6ba5eSFrederic Weisbecker } 29501da177e4SLinus Torvalds 2951c4028958SDavid Howells INIT_DELAYED_WORK(&journal->j_work, flush_async_commits); 2952a9dd3643SJeff Mahoney journal->j_work_sb = sb; 29531da177e4SLinus Torvalds return 0; 29541da177e4SLinus Torvalds free_and_return: 2955a9dd3643SJeff Mahoney free_journal_ram(sb); 29561da177e4SLinus Torvalds return 1; 29571da177e4SLinus Torvalds } 29581da177e4SLinus Torvalds 29591da177e4SLinus Torvalds /* 29601da177e4SLinus Torvalds ** test for a polite end of the current transaction. Used by file_write, and should 29611da177e4SLinus Torvalds ** be used by delete to make sure they don't write more than can fit inside a single 29621da177e4SLinus Torvalds ** transaction 29631da177e4SLinus Torvalds */ 2964bd4c625cSLinus Torvalds int journal_transaction_should_end(struct reiserfs_transaction_handle *th, 2965bd4c625cSLinus Torvalds int new_alloc) 2966bd4c625cSLinus Torvalds { 29671da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(th->t_super); 29681da177e4SLinus Torvalds time_t now = get_seconds(); 29691da177e4SLinus Torvalds /* cannot restart while nested */ 29701da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 29711da177e4SLinus Torvalds if (th->t_refcount > 1) 29721da177e4SLinus Torvalds return 0; 29731da177e4SLinus Torvalds if (journal->j_must_wait > 0 || 29741da177e4SLinus Torvalds (journal->j_len_alloc + new_alloc) >= journal->j_max_batch || 29751da177e4SLinus Torvalds atomic_read(&(journal->j_jlock)) || 29761da177e4SLinus Torvalds (now - journal->j_trans_start_time) > journal->j_max_trans_age || 29771da177e4SLinus Torvalds journal->j_cnode_free < (journal->j_trans_max * 3)) { 29781da177e4SLinus Torvalds return 1; 29791da177e4SLinus Torvalds } 29806ae1ea44SChris Mason /* protected by the BKL here */ 29816ae1ea44SChris Mason journal->j_len_alloc += new_alloc; 29826ae1ea44SChris Mason th->t_blocks_allocated += new_alloc ; 29831da177e4SLinus Torvalds return 0; 29841da177e4SLinus Torvalds } 29851da177e4SLinus Torvalds 29861da177e4SLinus Torvalds /* this must be called inside a transaction, and requires the 29871da177e4SLinus Torvalds ** kernel_lock to be held 29881da177e4SLinus Torvalds */ 2989bd4c625cSLinus Torvalds void reiserfs_block_writes(struct reiserfs_transaction_handle *th) 2990bd4c625cSLinus Torvalds { 29911da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(th->t_super); 29921da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 29931da177e4SLinus Torvalds journal->j_must_wait = 1; 29941da177e4SLinus Torvalds set_bit(J_WRITERS_BLOCKED, &journal->j_state); 29951da177e4SLinus Torvalds return; 29961da177e4SLinus Torvalds } 29971da177e4SLinus Torvalds 29981da177e4SLinus Torvalds /* this must be called without a transaction started, and does not 29991da177e4SLinus Torvalds ** require BKL 30001da177e4SLinus Torvalds */ 3001bd4c625cSLinus Torvalds void reiserfs_allow_writes(struct super_block *s) 3002bd4c625cSLinus Torvalds { 30031da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 30041da177e4SLinus Torvalds clear_bit(J_WRITERS_BLOCKED, &journal->j_state); 30051da177e4SLinus Torvalds wake_up(&journal->j_join_wait); 30061da177e4SLinus Torvalds } 30071da177e4SLinus Torvalds 30081da177e4SLinus Torvalds /* this must be called without a transaction started, and does not 30091da177e4SLinus Torvalds ** require BKL 30101da177e4SLinus Torvalds */ 3011bd4c625cSLinus Torvalds void reiserfs_wait_on_write_block(struct super_block *s) 3012bd4c625cSLinus Torvalds { 30131da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 30141da177e4SLinus Torvalds wait_event(journal->j_join_wait, 30151da177e4SLinus Torvalds !test_bit(J_WRITERS_BLOCKED, &journal->j_state)); 30161da177e4SLinus Torvalds } 30171da177e4SLinus Torvalds 3018bd4c625cSLinus Torvalds static void queue_log_writer(struct super_block *s) 3019bd4c625cSLinus Torvalds { 30201da177e4SLinus Torvalds wait_queue_t wait; 30211da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 30221da177e4SLinus Torvalds set_bit(J_WRITERS_QUEUED, &journal->j_state); 30231da177e4SLinus Torvalds 30241da177e4SLinus Torvalds /* 30251da177e4SLinus Torvalds * we don't want to use wait_event here because 30261da177e4SLinus Torvalds * we only want to wait once. 30271da177e4SLinus Torvalds */ 30281da177e4SLinus Torvalds init_waitqueue_entry(&wait, current); 30291da177e4SLinus Torvalds add_wait_queue(&journal->j_join_wait, &wait); 30301da177e4SLinus Torvalds set_current_state(TASK_UNINTERRUPTIBLE); 30318ebc4232SFrederic Weisbecker if (test_bit(J_WRITERS_QUEUED, &journal->j_state)) { 30328ebc4232SFrederic Weisbecker reiserfs_write_unlock(s); 30331da177e4SLinus Torvalds schedule(); 30348ebc4232SFrederic Weisbecker reiserfs_write_lock(s); 30358ebc4232SFrederic Weisbecker } 30365ab2f7e0SMilind Arun Choudhary __set_current_state(TASK_RUNNING); 30371da177e4SLinus Torvalds remove_wait_queue(&journal->j_join_wait, &wait); 30381da177e4SLinus Torvalds } 30391da177e4SLinus Torvalds 3040bd4c625cSLinus Torvalds static void wake_queued_writers(struct super_block *s) 3041bd4c625cSLinus Torvalds { 30421da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 30431da177e4SLinus Torvalds if (test_and_clear_bit(J_WRITERS_QUEUED, &journal->j_state)) 30441da177e4SLinus Torvalds wake_up(&journal->j_join_wait); 30451da177e4SLinus Torvalds } 30461da177e4SLinus Torvalds 3047600ed416SJeff Mahoney static void let_transaction_grow(struct super_block *sb, unsigned int trans_id) 30481da177e4SLinus Torvalds { 30491da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(sb); 30501da177e4SLinus Torvalds unsigned long bcount = journal->j_bcount; 30511da177e4SLinus Torvalds while (1) { 30528ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 3053041e0e3bSNishanth Aravamudan schedule_timeout_uninterruptible(1); 30548ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 30551da177e4SLinus Torvalds journal->j_current_jl->j_state |= LIST_COMMIT_PENDING; 30561da177e4SLinus Torvalds while ((atomic_read(&journal->j_wcount) > 0 || 30571da177e4SLinus Torvalds atomic_read(&journal->j_jlock)) && 30581da177e4SLinus Torvalds journal->j_trans_id == trans_id) { 30591da177e4SLinus Torvalds queue_log_writer(sb); 30601da177e4SLinus Torvalds } 30611da177e4SLinus Torvalds if (journal->j_trans_id != trans_id) 30621da177e4SLinus Torvalds break; 30631da177e4SLinus Torvalds if (bcount == journal->j_bcount) 30641da177e4SLinus Torvalds break; 30651da177e4SLinus Torvalds bcount = journal->j_bcount; 30661da177e4SLinus Torvalds } 30671da177e4SLinus Torvalds } 30681da177e4SLinus Torvalds 30691da177e4SLinus Torvalds /* join == true if you must join an existing transaction. 30701da177e4SLinus Torvalds ** join == false if you can deal with waiting for others to finish 30711da177e4SLinus Torvalds ** 30721da177e4SLinus Torvalds ** this will block until the transaction is joinable. send the number of blocks you 30731da177e4SLinus Torvalds ** expect to use in nblocks. 30741da177e4SLinus Torvalds */ 3075bd4c625cSLinus Torvalds static int do_journal_begin_r(struct reiserfs_transaction_handle *th, 3076a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks, 3077bd4c625cSLinus Torvalds int join) 3078bd4c625cSLinus Torvalds { 30791da177e4SLinus Torvalds time_t now = get_seconds(); 3080600ed416SJeff Mahoney unsigned int old_trans_id; 3081a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 30821da177e4SLinus Torvalds struct reiserfs_transaction_handle myth; 30831da177e4SLinus Torvalds int sched_count = 0; 30841da177e4SLinus Torvalds int retval; 30851da177e4SLinus Torvalds 3086a9dd3643SJeff Mahoney reiserfs_check_lock_depth(sb, "journal_begin"); 308714a61442SEric Sesterhenn BUG_ON(nblocks > journal->j_trans_max); 30881da177e4SLinus Torvalds 3089a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.journal_being); 30901da177e4SLinus Torvalds /* set here for journal_join */ 30911da177e4SLinus Torvalds th->t_refcount = 1; 3092a9dd3643SJeff Mahoney th->t_super = sb; 30931da177e4SLinus Torvalds 30941da177e4SLinus Torvalds relock: 3095a9dd3643SJeff Mahoney lock_journal(sb); 30961da177e4SLinus Torvalds if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) { 3097a9dd3643SJeff Mahoney unlock_journal(sb); 30981da177e4SLinus Torvalds retval = journal->j_errno; 30991da177e4SLinus Torvalds goto out_fail; 31001da177e4SLinus Torvalds } 31011da177e4SLinus Torvalds journal->j_bcount++; 31021da177e4SLinus Torvalds 31031da177e4SLinus Torvalds if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) { 3104a9dd3643SJeff Mahoney unlock_journal(sb); 31058ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 3106a9dd3643SJeff Mahoney reiserfs_wait_on_write_block(sb); 31078ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 3108a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.journal_relock_writers); 31091da177e4SLinus Torvalds goto relock; 31101da177e4SLinus Torvalds } 31111da177e4SLinus Torvalds now = get_seconds(); 31121da177e4SLinus Torvalds 31131da177e4SLinus Torvalds /* if there is no room in the journal OR 31141da177e4SLinus Torvalds ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning 31151da177e4SLinus Torvalds ** we don't sleep if there aren't other writers 31161da177e4SLinus Torvalds */ 31171da177e4SLinus Torvalds 31181da177e4SLinus Torvalds if ((!join && journal->j_must_wait > 0) || 3119bd4c625cSLinus Torvalds (!join 3120bd4c625cSLinus Torvalds && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch) 3121bd4c625cSLinus Torvalds || (!join && atomic_read(&journal->j_wcount) > 0 3122bd4c625cSLinus Torvalds && journal->j_trans_start_time > 0 3123bd4c625cSLinus Torvalds && (now - journal->j_trans_start_time) > 3124bd4c625cSLinus Torvalds journal->j_max_trans_age) || (!join 3125bd4c625cSLinus Torvalds && atomic_read(&journal->j_jlock)) 3126bd4c625cSLinus Torvalds || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) { 31271da177e4SLinus Torvalds 31281da177e4SLinus Torvalds old_trans_id = journal->j_trans_id; 3129a9dd3643SJeff Mahoney unlock_journal(sb); /* allow others to finish this transaction */ 31301da177e4SLinus Torvalds 31311da177e4SLinus Torvalds if (!join && (journal->j_len_alloc + nblocks + 2) >= 31321da177e4SLinus Torvalds journal->j_max_batch && 3133bd4c625cSLinus Torvalds ((journal->j_len + nblocks + 2) * 100) < 3134bd4c625cSLinus Torvalds (journal->j_len_alloc * 75)) { 31351da177e4SLinus Torvalds if (atomic_read(&journal->j_wcount) > 10) { 31361da177e4SLinus Torvalds sched_count++; 3137a9dd3643SJeff Mahoney queue_log_writer(sb); 31381da177e4SLinus Torvalds goto relock; 31391da177e4SLinus Torvalds } 31401da177e4SLinus Torvalds } 31411da177e4SLinus Torvalds /* don't mess with joining the transaction if all we have to do is 31421da177e4SLinus Torvalds * wait for someone else to do a commit 31431da177e4SLinus Torvalds */ 31441da177e4SLinus Torvalds if (atomic_read(&journal->j_jlock)) { 31451da177e4SLinus Torvalds while (journal->j_trans_id == old_trans_id && 31461da177e4SLinus Torvalds atomic_read(&journal->j_jlock)) { 3147a9dd3643SJeff Mahoney queue_log_writer(sb); 31481da177e4SLinus Torvalds } 31491da177e4SLinus Torvalds goto relock; 31501da177e4SLinus Torvalds } 3151a9dd3643SJeff Mahoney retval = journal_join(&myth, sb, 1); 31521da177e4SLinus Torvalds if (retval) 31531da177e4SLinus Torvalds goto out_fail; 31541da177e4SLinus Torvalds 31551da177e4SLinus Torvalds /* someone might have ended the transaction while we joined */ 31561da177e4SLinus Torvalds if (old_trans_id != journal->j_trans_id) { 3157a9dd3643SJeff Mahoney retval = do_journal_end(&myth, sb, 1, 0); 31581da177e4SLinus Torvalds } else { 3159a9dd3643SJeff Mahoney retval = do_journal_end(&myth, sb, 1, COMMIT_NOW); 31601da177e4SLinus Torvalds } 31611da177e4SLinus Torvalds 31621da177e4SLinus Torvalds if (retval) 31631da177e4SLinus Torvalds goto out_fail; 31641da177e4SLinus Torvalds 3165a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.journal_relock_wcount); 31661da177e4SLinus Torvalds goto relock; 31671da177e4SLinus Torvalds } 31681da177e4SLinus Torvalds /* we are the first writer, set trans_id */ 31691da177e4SLinus Torvalds if (journal->j_trans_start_time == 0) { 31701da177e4SLinus Torvalds journal->j_trans_start_time = get_seconds(); 31711da177e4SLinus Torvalds } 31721da177e4SLinus Torvalds atomic_inc(&(journal->j_wcount)); 31731da177e4SLinus Torvalds journal->j_len_alloc += nblocks; 31741da177e4SLinus Torvalds th->t_blocks_logged = 0; 31751da177e4SLinus Torvalds th->t_blocks_allocated = nblocks; 31761da177e4SLinus Torvalds th->t_trans_id = journal->j_trans_id; 3177a9dd3643SJeff Mahoney unlock_journal(sb); 31781da177e4SLinus Torvalds INIT_LIST_HEAD(&th->t_list); 317922e2c507SJens Axboe get_fs_excl(); 31801da177e4SLinus Torvalds return 0; 31811da177e4SLinus Torvalds 31821da177e4SLinus Torvalds out_fail: 31831da177e4SLinus Torvalds memset(th, 0, sizeof(*th)); 31841da177e4SLinus Torvalds /* Re-set th->t_super, so we can properly keep track of how many 31851da177e4SLinus Torvalds * persistent transactions there are. We need to do this so if this 31861da177e4SLinus Torvalds * call is part of a failed restart_transaction, we can free it later */ 3187a9dd3643SJeff Mahoney th->t_super = sb; 31881da177e4SLinus Torvalds return retval; 31891da177e4SLinus Torvalds } 31901da177e4SLinus Torvalds 3191bd4c625cSLinus Torvalds struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct 3192bd4c625cSLinus Torvalds super_block 3193bd4c625cSLinus Torvalds *s, 3194bd4c625cSLinus Torvalds int nblocks) 3195bd4c625cSLinus Torvalds { 31961da177e4SLinus Torvalds int ret; 31971da177e4SLinus Torvalds struct reiserfs_transaction_handle *th; 31981da177e4SLinus Torvalds 31991da177e4SLinus Torvalds /* if we're nesting into an existing transaction. It will be 32001da177e4SLinus Torvalds ** persistent on its own 32011da177e4SLinus Torvalds */ 32021da177e4SLinus Torvalds if (reiserfs_transaction_running(s)) { 32031da177e4SLinus Torvalds th = current->journal_info; 32041da177e4SLinus Torvalds th->t_refcount++; 320514a61442SEric Sesterhenn BUG_ON(th->t_refcount < 2); 320614a61442SEric Sesterhenn 32071da177e4SLinus Torvalds return th; 32081da177e4SLinus Torvalds } 3209d739b42bSPekka Enberg th = kmalloc(sizeof(struct reiserfs_transaction_handle), GFP_NOFS); 32101da177e4SLinus Torvalds if (!th) 32111da177e4SLinus Torvalds return NULL; 32121da177e4SLinus Torvalds ret = journal_begin(th, s, nblocks); 32131da177e4SLinus Torvalds if (ret) { 3214d739b42bSPekka Enberg kfree(th); 32151da177e4SLinus Torvalds return NULL; 32161da177e4SLinus Torvalds } 32171da177e4SLinus Torvalds 32181da177e4SLinus Torvalds SB_JOURNAL(s)->j_persistent_trans++; 32191da177e4SLinus Torvalds return th; 32201da177e4SLinus Torvalds } 32211da177e4SLinus Torvalds 3222bd4c625cSLinus Torvalds int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th) 3223bd4c625cSLinus Torvalds { 32241da177e4SLinus Torvalds struct super_block *s = th->t_super; 32251da177e4SLinus Torvalds int ret = 0; 32261da177e4SLinus Torvalds if (th->t_trans_id) 32271da177e4SLinus Torvalds ret = journal_end(th, th->t_super, th->t_blocks_allocated); 32281da177e4SLinus Torvalds else 32291da177e4SLinus Torvalds ret = -EIO; 32301da177e4SLinus Torvalds if (th->t_refcount == 0) { 32311da177e4SLinus Torvalds SB_JOURNAL(s)->j_persistent_trans--; 3232d739b42bSPekka Enberg kfree(th); 32331da177e4SLinus Torvalds } 32341da177e4SLinus Torvalds return ret; 32351da177e4SLinus Torvalds } 32361da177e4SLinus Torvalds 3237bd4c625cSLinus Torvalds static int journal_join(struct reiserfs_transaction_handle *th, 3238a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks) 3239bd4c625cSLinus Torvalds { 32401da177e4SLinus Torvalds struct reiserfs_transaction_handle *cur_th = current->journal_info; 32411da177e4SLinus Torvalds 32421da177e4SLinus Torvalds /* this keeps do_journal_end from NULLing out the current->journal_info 32431da177e4SLinus Torvalds ** pointer 32441da177e4SLinus Torvalds */ 32451da177e4SLinus Torvalds th->t_handle_save = cur_th; 324614a61442SEric Sesterhenn BUG_ON(cur_th && cur_th->t_refcount > 1); 3247a9dd3643SJeff Mahoney return do_journal_begin_r(th, sb, nblocks, JBEGIN_JOIN); 32481da177e4SLinus Torvalds } 32491da177e4SLinus Torvalds 3250bd4c625cSLinus Torvalds int journal_join_abort(struct reiserfs_transaction_handle *th, 3251a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks) 3252bd4c625cSLinus Torvalds { 32531da177e4SLinus Torvalds struct reiserfs_transaction_handle *cur_th = current->journal_info; 32541da177e4SLinus Torvalds 32551da177e4SLinus Torvalds /* this keeps do_journal_end from NULLing out the current->journal_info 32561da177e4SLinus Torvalds ** pointer 32571da177e4SLinus Torvalds */ 32581da177e4SLinus Torvalds th->t_handle_save = cur_th; 325914a61442SEric Sesterhenn BUG_ON(cur_th && cur_th->t_refcount > 1); 3260a9dd3643SJeff Mahoney return do_journal_begin_r(th, sb, nblocks, JBEGIN_ABORT); 32611da177e4SLinus Torvalds } 32621da177e4SLinus Torvalds 3263bd4c625cSLinus Torvalds int journal_begin(struct reiserfs_transaction_handle *th, 3264a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks) 3265bd4c625cSLinus Torvalds { 32661da177e4SLinus Torvalds struct reiserfs_transaction_handle *cur_th = current->journal_info; 32671da177e4SLinus Torvalds int ret; 32681da177e4SLinus Torvalds 32691da177e4SLinus Torvalds th->t_handle_save = NULL; 32701da177e4SLinus Torvalds if (cur_th) { 32711da177e4SLinus Torvalds /* we are nesting into the current transaction */ 3272a9dd3643SJeff Mahoney if (cur_th->t_super == sb) { 32731da177e4SLinus Torvalds BUG_ON(!cur_th->t_refcount); 32741da177e4SLinus Torvalds cur_th->t_refcount++; 32751da177e4SLinus Torvalds memcpy(th, cur_th, sizeof(*th)); 32761da177e4SLinus Torvalds if (th->t_refcount <= 1) 3277a9dd3643SJeff Mahoney reiserfs_warning(sb, "reiserfs-2005", 327845b03d5eSJeff Mahoney "BAD: refcount <= 1, but " 327945b03d5eSJeff Mahoney "journal_info != 0"); 32801da177e4SLinus Torvalds return 0; 32811da177e4SLinus Torvalds } else { 32821da177e4SLinus Torvalds /* we've ended up with a handle from a different filesystem. 32831da177e4SLinus Torvalds ** save it and restore on journal_end. This should never 32841da177e4SLinus Torvalds ** really happen... 32851da177e4SLinus Torvalds */ 3286a9dd3643SJeff Mahoney reiserfs_warning(sb, "clm-2100", 328745b03d5eSJeff Mahoney "nesting info a different FS"); 32881da177e4SLinus Torvalds th->t_handle_save = current->journal_info; 32891da177e4SLinus Torvalds current->journal_info = th; 32901da177e4SLinus Torvalds } 32911da177e4SLinus Torvalds } else { 32921da177e4SLinus Torvalds current->journal_info = th; 32931da177e4SLinus Torvalds } 3294a9dd3643SJeff Mahoney ret = do_journal_begin_r(th, sb, nblocks, JBEGIN_REG); 329514a61442SEric Sesterhenn BUG_ON(current->journal_info != th); 32961da177e4SLinus Torvalds 32971da177e4SLinus Torvalds /* I guess this boils down to being the reciprocal of clm-2100 above. 32981da177e4SLinus Torvalds * If do_journal_begin_r fails, we need to put it back, since journal_end 32991da177e4SLinus Torvalds * won't be called to do it. */ 33001da177e4SLinus Torvalds if (ret) 33011da177e4SLinus Torvalds current->journal_info = th->t_handle_save; 33021da177e4SLinus Torvalds else 33031da177e4SLinus Torvalds BUG_ON(!th->t_refcount); 33041da177e4SLinus Torvalds 33051da177e4SLinus Torvalds return ret; 33061da177e4SLinus Torvalds } 33071da177e4SLinus Torvalds 33081da177e4SLinus Torvalds /* 33091da177e4SLinus Torvalds ** puts bh into the current transaction. If it was already there, reorders removes the 33101da177e4SLinus Torvalds ** old pointers from the hash, and puts new ones in (to make sure replay happen in the right order). 33111da177e4SLinus Torvalds ** 33121da177e4SLinus Torvalds ** if it was dirty, cleans and files onto the clean list. I can't let it be dirty again until the 33131da177e4SLinus Torvalds ** transaction is committed. 33141da177e4SLinus Torvalds ** 33151da177e4SLinus Torvalds ** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len. 33161da177e4SLinus Torvalds */ 3317bd4c625cSLinus Torvalds int journal_mark_dirty(struct reiserfs_transaction_handle *th, 3318a9dd3643SJeff Mahoney struct super_block *sb, struct buffer_head *bh) 3319bd4c625cSLinus Torvalds { 3320a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 33211da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn = NULL; 33221da177e4SLinus Torvalds int count_already_incd = 0; 33231da177e4SLinus Torvalds int prepared = 0; 33241da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 33251da177e4SLinus Torvalds 3326a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.mark_dirty); 33271da177e4SLinus Torvalds if (th->t_trans_id != journal->j_trans_id) { 3328c3a9c210SJeff Mahoney reiserfs_panic(th->t_super, "journal-1577", 3329c3a9c210SJeff Mahoney "handle trans id %ld != current trans id %ld", 33301da177e4SLinus Torvalds th->t_trans_id, journal->j_trans_id); 33311da177e4SLinus Torvalds } 33321da177e4SLinus Torvalds 3333a9dd3643SJeff Mahoney sb->s_dirt = 1; 33341da177e4SLinus Torvalds 33351da177e4SLinus Torvalds prepared = test_clear_buffer_journal_prepared(bh); 33361da177e4SLinus Torvalds clear_buffer_journal_restore_dirty(bh); 33371da177e4SLinus Torvalds /* already in this transaction, we are done */ 33381da177e4SLinus Torvalds if (buffer_journaled(bh)) { 3339a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.mark_dirty_already); 33401da177e4SLinus Torvalds return 0; 33411da177e4SLinus Torvalds } 33421da177e4SLinus Torvalds 33431da177e4SLinus Torvalds /* this must be turned into a panic instead of a warning. We can't allow 33441da177e4SLinus Torvalds ** a dirty or journal_dirty or locked buffer to be logged, as some changes 33451da177e4SLinus Torvalds ** could get to disk too early. NOT GOOD. 33461da177e4SLinus Torvalds */ 33471da177e4SLinus Torvalds if (!prepared || buffer_dirty(bh)) { 3348a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1777", 334945b03d5eSJeff Mahoney "buffer %llu bad state " 33501da177e4SLinus Torvalds "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT", 3351bd4c625cSLinus Torvalds (unsigned long long)bh->b_blocknr, 3352bd4c625cSLinus Torvalds prepared ? ' ' : '!', 33531da177e4SLinus Torvalds buffer_locked(bh) ? ' ' : '!', 33541da177e4SLinus Torvalds buffer_dirty(bh) ? ' ' : '!', 33551da177e4SLinus Torvalds buffer_journal_dirty(bh) ? ' ' : '!'); 33561da177e4SLinus Torvalds } 33571da177e4SLinus Torvalds 33581da177e4SLinus Torvalds if (atomic_read(&(journal->j_wcount)) <= 0) { 3359a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1409", 336045b03d5eSJeff Mahoney "returning because j_wcount was %d", 3361bd4c625cSLinus Torvalds atomic_read(&(journal->j_wcount))); 33621da177e4SLinus Torvalds return 1; 33631da177e4SLinus Torvalds } 33641da177e4SLinus Torvalds /* this error means I've screwed up, and we've overflowed the transaction. 33651da177e4SLinus Torvalds ** Nothing can be done here, except make the FS readonly or panic. 33661da177e4SLinus Torvalds */ 33671da177e4SLinus Torvalds if (journal->j_len >= journal->j_trans_max) { 3368c3a9c210SJeff Mahoney reiserfs_panic(th->t_super, "journal-1413", 3369c3a9c210SJeff Mahoney "j_len (%lu) is too big", 3370bd4c625cSLinus Torvalds journal->j_len); 33711da177e4SLinus Torvalds } 33721da177e4SLinus Torvalds 33731da177e4SLinus Torvalds if (buffer_journal_dirty(bh)) { 33741da177e4SLinus Torvalds count_already_incd = 1; 3375a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.mark_dirty_notjournal); 33761da177e4SLinus Torvalds clear_buffer_journal_dirty(bh); 33771da177e4SLinus Torvalds } 33781da177e4SLinus Torvalds 33791da177e4SLinus Torvalds if (journal->j_len > journal->j_len_alloc) { 33801da177e4SLinus Torvalds journal->j_len_alloc = journal->j_len + JOURNAL_PER_BALANCE_CNT; 33811da177e4SLinus Torvalds } 33821da177e4SLinus Torvalds 33831da177e4SLinus Torvalds set_buffer_journaled(bh); 33841da177e4SLinus Torvalds 33851da177e4SLinus Torvalds /* now put this guy on the end */ 33861da177e4SLinus Torvalds if (!cn) { 3387a9dd3643SJeff Mahoney cn = get_cnode(sb); 33881da177e4SLinus Torvalds if (!cn) { 3389a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-4", "get_cnode failed!"); 33901da177e4SLinus Torvalds } 33911da177e4SLinus Torvalds 33921da177e4SLinus Torvalds if (th->t_blocks_logged == th->t_blocks_allocated) { 33931da177e4SLinus Torvalds th->t_blocks_allocated += JOURNAL_PER_BALANCE_CNT; 33941da177e4SLinus Torvalds journal->j_len_alloc += JOURNAL_PER_BALANCE_CNT; 33951da177e4SLinus Torvalds } 33961da177e4SLinus Torvalds th->t_blocks_logged++; 33971da177e4SLinus Torvalds journal->j_len++; 33981da177e4SLinus Torvalds 33991da177e4SLinus Torvalds cn->bh = bh; 34001da177e4SLinus Torvalds cn->blocknr = bh->b_blocknr; 3401a9dd3643SJeff Mahoney cn->sb = sb; 34021da177e4SLinus Torvalds cn->jlist = NULL; 34031da177e4SLinus Torvalds insert_journal_hash(journal->j_hash_table, cn); 34041da177e4SLinus Torvalds if (!count_already_incd) { 34051da177e4SLinus Torvalds get_bh(bh); 34061da177e4SLinus Torvalds } 34071da177e4SLinus Torvalds } 34081da177e4SLinus Torvalds cn->next = NULL; 34091da177e4SLinus Torvalds cn->prev = journal->j_last; 34101da177e4SLinus Torvalds cn->bh = bh; 34111da177e4SLinus Torvalds if (journal->j_last) { 34121da177e4SLinus Torvalds journal->j_last->next = cn; 34131da177e4SLinus Torvalds journal->j_last = cn; 34141da177e4SLinus Torvalds } else { 34151da177e4SLinus Torvalds journal->j_first = cn; 34161da177e4SLinus Torvalds journal->j_last = cn; 34171da177e4SLinus Torvalds } 34181da177e4SLinus Torvalds return 0; 34191da177e4SLinus Torvalds } 34201da177e4SLinus Torvalds 3421bd4c625cSLinus Torvalds int journal_end(struct reiserfs_transaction_handle *th, 3422a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks) 3423bd4c625cSLinus Torvalds { 34241da177e4SLinus Torvalds if (!current->journal_info && th->t_refcount > 1) 3425a9dd3643SJeff Mahoney reiserfs_warning(sb, "REISER-NESTING", 342645b03d5eSJeff Mahoney "th NULL, refcount %d", th->t_refcount); 34271da177e4SLinus Torvalds 34281da177e4SLinus Torvalds if (!th->t_trans_id) { 34291da177e4SLinus Torvalds WARN_ON(1); 34301da177e4SLinus Torvalds return -EIO; 34311da177e4SLinus Torvalds } 34321da177e4SLinus Torvalds 34331da177e4SLinus Torvalds th->t_refcount--; 34341da177e4SLinus Torvalds if (th->t_refcount > 0) { 3435bd4c625cSLinus Torvalds struct reiserfs_transaction_handle *cur_th = 3436bd4c625cSLinus Torvalds current->journal_info; 34371da177e4SLinus Torvalds 34381da177e4SLinus Torvalds /* we aren't allowed to close a nested transaction on a different 34391da177e4SLinus Torvalds ** filesystem from the one in the task struct 34401da177e4SLinus Torvalds */ 344114a61442SEric Sesterhenn BUG_ON(cur_th->t_super != th->t_super); 34421da177e4SLinus Torvalds 34431da177e4SLinus Torvalds if (th != cur_th) { 34441da177e4SLinus Torvalds memcpy(current->journal_info, th, sizeof(*th)); 34451da177e4SLinus Torvalds th->t_trans_id = 0; 34461da177e4SLinus Torvalds } 34471da177e4SLinus Torvalds return 0; 34481da177e4SLinus Torvalds } else { 3449a9dd3643SJeff Mahoney return do_journal_end(th, sb, nblocks, 0); 34501da177e4SLinus Torvalds } 34511da177e4SLinus Torvalds } 34521da177e4SLinus Torvalds 34531da177e4SLinus Torvalds /* removes from the current transaction, relsing and descrementing any counters. 34541da177e4SLinus Torvalds ** also files the removed buffer directly onto the clean list 34551da177e4SLinus Torvalds ** 34561da177e4SLinus Torvalds ** called by journal_mark_freed when a block has been deleted 34571da177e4SLinus Torvalds ** 34581da177e4SLinus Torvalds ** returns 1 if it cleaned and relsed the buffer. 0 otherwise 34591da177e4SLinus Torvalds */ 3460a9dd3643SJeff Mahoney static int remove_from_transaction(struct super_block *sb, 3461bd4c625cSLinus Torvalds b_blocknr_t blocknr, int already_cleaned) 3462bd4c625cSLinus Torvalds { 34631da177e4SLinus Torvalds struct buffer_head *bh; 34641da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 3465a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 34661da177e4SLinus Torvalds int ret = 0; 34671da177e4SLinus Torvalds 3468a9dd3643SJeff Mahoney cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr); 34691da177e4SLinus Torvalds if (!cn || !cn->bh) { 34701da177e4SLinus Torvalds return ret; 34711da177e4SLinus Torvalds } 34721da177e4SLinus Torvalds bh = cn->bh; 34731da177e4SLinus Torvalds if (cn->prev) { 34741da177e4SLinus Torvalds cn->prev->next = cn->next; 34751da177e4SLinus Torvalds } 34761da177e4SLinus Torvalds if (cn->next) { 34771da177e4SLinus Torvalds cn->next->prev = cn->prev; 34781da177e4SLinus Torvalds } 34791da177e4SLinus Torvalds if (cn == journal->j_first) { 34801da177e4SLinus Torvalds journal->j_first = cn->next; 34811da177e4SLinus Torvalds } 34821da177e4SLinus Torvalds if (cn == journal->j_last) { 34831da177e4SLinus Torvalds journal->j_last = cn->prev; 34841da177e4SLinus Torvalds } 34851da177e4SLinus Torvalds if (bh) 3486a9dd3643SJeff Mahoney remove_journal_hash(sb, journal->j_hash_table, NULL, 3487bd4c625cSLinus Torvalds bh->b_blocknr, 0); 34881da177e4SLinus Torvalds clear_buffer_journaled(bh); /* don't log this one */ 34891da177e4SLinus Torvalds 34901da177e4SLinus Torvalds if (!already_cleaned) { 34911da177e4SLinus Torvalds clear_buffer_journal_dirty(bh); 34921da177e4SLinus Torvalds clear_buffer_dirty(bh); 34931da177e4SLinus Torvalds clear_buffer_journal_test(bh); 34941da177e4SLinus Torvalds put_bh(bh); 34951da177e4SLinus Torvalds if (atomic_read(&(bh->b_count)) < 0) { 3496a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-1752", 349745b03d5eSJeff Mahoney "b_count < 0"); 34981da177e4SLinus Torvalds } 34991da177e4SLinus Torvalds ret = 1; 35001da177e4SLinus Torvalds } 35011da177e4SLinus Torvalds journal->j_len--; 35021da177e4SLinus Torvalds journal->j_len_alloc--; 3503a9dd3643SJeff Mahoney free_cnode(sb, cn); 35041da177e4SLinus Torvalds return ret; 35051da177e4SLinus Torvalds } 35061da177e4SLinus Torvalds 35071da177e4SLinus Torvalds /* 35081da177e4SLinus Torvalds ** for any cnode in a journal list, it can only be dirtied of all the 35090779bf2dSMatt LaPlante ** transactions that include it are committed to disk. 35101da177e4SLinus Torvalds ** this checks through each transaction, and returns 1 if you are allowed to dirty, 35111da177e4SLinus Torvalds ** and 0 if you aren't 35121da177e4SLinus Torvalds ** 35131da177e4SLinus Torvalds ** it is called by dirty_journal_list, which is called after flush_commit_list has gotten all the log 35141da177e4SLinus Torvalds ** blocks for a given transaction on disk 35151da177e4SLinus Torvalds ** 35161da177e4SLinus Torvalds */ 3517bd4c625cSLinus Torvalds static int can_dirty(struct reiserfs_journal_cnode *cn) 3518bd4c625cSLinus Torvalds { 35191da177e4SLinus Torvalds struct super_block *sb = cn->sb; 35201da177e4SLinus Torvalds b_blocknr_t blocknr = cn->blocknr; 35211da177e4SLinus Torvalds struct reiserfs_journal_cnode *cur = cn->hprev; 35221da177e4SLinus Torvalds int can_dirty = 1; 35231da177e4SLinus Torvalds 35241da177e4SLinus Torvalds /* first test hprev. These are all newer than cn, so any node here 35251da177e4SLinus Torvalds ** with the same block number and dev means this node can't be sent 35261da177e4SLinus Torvalds ** to disk right now. 35271da177e4SLinus Torvalds */ 35281da177e4SLinus Torvalds while (cur && can_dirty) { 35291da177e4SLinus Torvalds if (cur->jlist && cur->bh && cur->blocknr && cur->sb == sb && 35301da177e4SLinus Torvalds cur->blocknr == blocknr) { 35311da177e4SLinus Torvalds can_dirty = 0; 35321da177e4SLinus Torvalds } 35331da177e4SLinus Torvalds cur = cur->hprev; 35341da177e4SLinus Torvalds } 35351da177e4SLinus Torvalds /* then test hnext. These are all older than cn. As long as they 35361da177e4SLinus Torvalds ** are committed to the log, it is safe to write cn to disk 35371da177e4SLinus Torvalds */ 35381da177e4SLinus Torvalds cur = cn->hnext; 35391da177e4SLinus Torvalds while (cur && can_dirty) { 35401da177e4SLinus Torvalds if (cur->jlist && cur->jlist->j_len > 0 && 35411da177e4SLinus Torvalds atomic_read(&(cur->jlist->j_commit_left)) > 0 && cur->bh && 35421da177e4SLinus Torvalds cur->blocknr && cur->sb == sb && cur->blocknr == blocknr) { 35431da177e4SLinus Torvalds can_dirty = 0; 35441da177e4SLinus Torvalds } 35451da177e4SLinus Torvalds cur = cur->hnext; 35461da177e4SLinus Torvalds } 35471da177e4SLinus Torvalds return can_dirty; 35481da177e4SLinus Torvalds } 35491da177e4SLinus Torvalds 35501da177e4SLinus Torvalds /* syncs the commit blocks, but does not force the real buffers to disk 35510779bf2dSMatt LaPlante ** will wait until the current transaction is done/committed before returning 35521da177e4SLinus Torvalds */ 3553bd4c625cSLinus Torvalds int journal_end_sync(struct reiserfs_transaction_handle *th, 3554a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks) 3555bd4c625cSLinus Torvalds { 3556a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 35571da177e4SLinus Torvalds 35581da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 35591da177e4SLinus Torvalds /* you can sync while nested, very, very bad */ 356014a61442SEric Sesterhenn BUG_ON(th->t_refcount > 1); 35611da177e4SLinus Torvalds if (journal->j_len == 0) { 3562a9dd3643SJeff Mahoney reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 3563bd4c625cSLinus Torvalds 1); 3564a9dd3643SJeff Mahoney journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb)); 35651da177e4SLinus Torvalds } 3566a9dd3643SJeff Mahoney return do_journal_end(th, sb, nblocks, COMMIT_NOW | WAIT); 35671da177e4SLinus Torvalds } 35681da177e4SLinus Torvalds 35691da177e4SLinus Torvalds /* 35701da177e4SLinus Torvalds ** writeback the pending async commits to disk 35711da177e4SLinus Torvalds */ 3572c4028958SDavid Howells static void flush_async_commits(struct work_struct *work) 3573bd4c625cSLinus Torvalds { 3574c4028958SDavid Howells struct reiserfs_journal *journal = 3575c4028958SDavid Howells container_of(work, struct reiserfs_journal, j_work.work); 3576a9dd3643SJeff Mahoney struct super_block *sb = journal->j_work_sb; 35771da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 35781da177e4SLinus Torvalds struct list_head *entry; 35791da177e4SLinus Torvalds 35808ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 35811da177e4SLinus Torvalds if (!list_empty(&journal->j_journal_list)) { 35821da177e4SLinus Torvalds /* last entry is the youngest, commit it and you get everything */ 35831da177e4SLinus Torvalds entry = journal->j_journal_list.prev; 35841da177e4SLinus Torvalds jl = JOURNAL_LIST_ENTRY(entry); 3585a9dd3643SJeff Mahoney flush_commit_list(sb, jl, 1); 35861da177e4SLinus Torvalds } 35878ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 35881da177e4SLinus Torvalds } 35891da177e4SLinus Torvalds 35901da177e4SLinus Torvalds /* 35911da177e4SLinus Torvalds ** flushes any old transactions to disk 35921da177e4SLinus Torvalds ** ends the current transaction if it is too old 35931da177e4SLinus Torvalds */ 3594a9dd3643SJeff Mahoney int reiserfs_flush_old_commits(struct super_block *sb) 3595bd4c625cSLinus Torvalds { 35961da177e4SLinus Torvalds time_t now; 35971da177e4SLinus Torvalds struct reiserfs_transaction_handle th; 3598a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 35991da177e4SLinus Torvalds 36001da177e4SLinus Torvalds now = get_seconds(); 36011da177e4SLinus Torvalds /* safety check so we don't flush while we are replaying the log during 36021da177e4SLinus Torvalds * mount 36031da177e4SLinus Torvalds */ 36041da177e4SLinus Torvalds if (list_empty(&journal->j_journal_list)) { 36051da177e4SLinus Torvalds return 0; 36061da177e4SLinus Torvalds } 36071da177e4SLinus Torvalds 36081da177e4SLinus Torvalds /* check the current transaction. If there are no writers, and it is 36091da177e4SLinus Torvalds * too old, finish it, and force the commit blocks to disk 36101da177e4SLinus Torvalds */ 36111da177e4SLinus Torvalds if (atomic_read(&journal->j_wcount) <= 0 && 36121da177e4SLinus Torvalds journal->j_trans_start_time > 0 && 36131da177e4SLinus Torvalds journal->j_len > 0 && 3614bd4c625cSLinus Torvalds (now - journal->j_trans_start_time) > journal->j_max_trans_age) { 3615a9dd3643SJeff Mahoney if (!journal_join(&th, sb, 1)) { 3616a9dd3643SJeff Mahoney reiserfs_prepare_for_journal(sb, 3617a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb), 3618bd4c625cSLinus Torvalds 1); 3619a9dd3643SJeff Mahoney journal_mark_dirty(&th, sb, 3620a9dd3643SJeff Mahoney SB_BUFFER_WITH_SB(sb)); 36211da177e4SLinus Torvalds 36221da177e4SLinus Torvalds /* we're only being called from kreiserfsd, it makes no sense to do 36231da177e4SLinus Torvalds ** an async commit so that kreiserfsd can do it later 36241da177e4SLinus Torvalds */ 3625a9dd3643SJeff Mahoney do_journal_end(&th, sb, 1, COMMIT_NOW | WAIT); 36261da177e4SLinus Torvalds } 36271da177e4SLinus Torvalds } 3628a9dd3643SJeff Mahoney return sb->s_dirt; 36291da177e4SLinus Torvalds } 36301da177e4SLinus Torvalds 36311da177e4SLinus Torvalds /* 36321da177e4SLinus Torvalds ** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit 36331da177e4SLinus Torvalds ** 36341da177e4SLinus Torvalds ** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all 36351da177e4SLinus Torvalds ** the writers are done. By the time it wakes up, the transaction it was called has already ended, so it just 36361da177e4SLinus Torvalds ** flushes the commit list and returns 0. 36371da177e4SLinus Torvalds ** 36381da177e4SLinus Torvalds ** Won't batch when flush or commit_now is set. Also won't batch when others are waiting on j_join_wait. 36391da177e4SLinus Torvalds ** 36401da177e4SLinus Torvalds ** Note, we can't allow the journal_end to proceed while there are still writers in the log. 36411da177e4SLinus Torvalds */ 3642bd4c625cSLinus Torvalds static int check_journal_end(struct reiserfs_transaction_handle *th, 3643a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks, 3644bd4c625cSLinus Torvalds int flags) 3645bd4c625cSLinus Torvalds { 36461da177e4SLinus Torvalds 36471da177e4SLinus Torvalds time_t now; 36481da177e4SLinus Torvalds int flush = flags & FLUSH_ALL; 36491da177e4SLinus Torvalds int commit_now = flags & COMMIT_NOW; 36501da177e4SLinus Torvalds int wait_on_commit = flags & WAIT; 36511da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 3652a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 36531da177e4SLinus Torvalds 36541da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 36551da177e4SLinus Torvalds 36561da177e4SLinus Torvalds if (th->t_trans_id != journal->j_trans_id) { 3657c3a9c210SJeff Mahoney reiserfs_panic(th->t_super, "journal-1577", 3658c3a9c210SJeff Mahoney "handle trans id %ld != current trans id %ld", 36591da177e4SLinus Torvalds th->t_trans_id, journal->j_trans_id); 36601da177e4SLinus Torvalds } 36611da177e4SLinus Torvalds 36621da177e4SLinus Torvalds journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged); 36631da177e4SLinus Torvalds if (atomic_read(&(journal->j_wcount)) > 0) { /* <= 0 is allowed. unmounting might not call begin */ 36641da177e4SLinus Torvalds atomic_dec(&(journal->j_wcount)); 36651da177e4SLinus Torvalds } 36661da177e4SLinus Torvalds 36671da177e4SLinus Torvalds /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released 36681da177e4SLinus Torvalds ** will be dealt with by next transaction that actually writes something, but should be taken 36691da177e4SLinus Torvalds ** care of in this trans 36701da177e4SLinus Torvalds */ 367114a61442SEric Sesterhenn BUG_ON(journal->j_len == 0); 367214a61442SEric Sesterhenn 36731da177e4SLinus Torvalds /* if wcount > 0, and we are called to with flush or commit_now, 36741da177e4SLinus Torvalds ** we wait on j_join_wait. We will wake up when the last writer has 36751da177e4SLinus Torvalds ** finished the transaction, and started it on its way to the disk. 36761da177e4SLinus Torvalds ** Then, we flush the commit or journal list, and just return 0 36771da177e4SLinus Torvalds ** because the rest of journal end was already done for this transaction. 36781da177e4SLinus Torvalds */ 36791da177e4SLinus Torvalds if (atomic_read(&(journal->j_wcount)) > 0) { 36801da177e4SLinus Torvalds if (flush || commit_now) { 36811da177e4SLinus Torvalds unsigned trans_id; 36821da177e4SLinus Torvalds 36831da177e4SLinus Torvalds jl = journal->j_current_jl; 36841da177e4SLinus Torvalds trans_id = jl->j_trans_id; 36851da177e4SLinus Torvalds if (wait_on_commit) 36861da177e4SLinus Torvalds jl->j_state |= LIST_COMMIT_PENDING; 36871da177e4SLinus Torvalds atomic_set(&(journal->j_jlock), 1); 36881da177e4SLinus Torvalds if (flush) { 36891da177e4SLinus Torvalds journal->j_next_full_flush = 1; 36901da177e4SLinus Torvalds } 3691a9dd3643SJeff Mahoney unlock_journal(sb); 36921da177e4SLinus Torvalds 36931da177e4SLinus Torvalds /* sleep while the current transaction is still j_jlocked */ 36941da177e4SLinus Torvalds while (journal->j_trans_id == trans_id) { 36951da177e4SLinus Torvalds if (atomic_read(&journal->j_jlock)) { 3696a9dd3643SJeff Mahoney queue_log_writer(sb); 36971da177e4SLinus Torvalds } else { 3698a9dd3643SJeff Mahoney lock_journal(sb); 36991da177e4SLinus Torvalds if (journal->j_trans_id == trans_id) { 3700bd4c625cSLinus Torvalds atomic_set(&(journal->j_jlock), 3701bd4c625cSLinus Torvalds 1); 37021da177e4SLinus Torvalds } 3703a9dd3643SJeff Mahoney unlock_journal(sb); 37041da177e4SLinus Torvalds } 37051da177e4SLinus Torvalds } 370614a61442SEric Sesterhenn BUG_ON(journal->j_trans_id == trans_id); 370714a61442SEric Sesterhenn 3708bd4c625cSLinus Torvalds if (commit_now 3709a9dd3643SJeff Mahoney && journal_list_still_alive(sb, trans_id) 3710bd4c625cSLinus Torvalds && wait_on_commit) { 3711a9dd3643SJeff Mahoney flush_commit_list(sb, jl, 1); 37121da177e4SLinus Torvalds } 37131da177e4SLinus Torvalds return 0; 37141da177e4SLinus Torvalds } 3715a9dd3643SJeff Mahoney unlock_journal(sb); 37161da177e4SLinus Torvalds return 0; 37171da177e4SLinus Torvalds } 37181da177e4SLinus Torvalds 37191da177e4SLinus Torvalds /* deal with old transactions where we are the last writers */ 37201da177e4SLinus Torvalds now = get_seconds(); 37211da177e4SLinus Torvalds if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) { 37221da177e4SLinus Torvalds commit_now = 1; 37231da177e4SLinus Torvalds journal->j_next_async_flush = 1; 37241da177e4SLinus Torvalds } 37251da177e4SLinus Torvalds /* don't batch when someone is waiting on j_join_wait */ 37261da177e4SLinus Torvalds /* don't batch when syncing the commit or flushing the whole trans */ 3727bd4c625cSLinus Torvalds if (!(journal->j_must_wait > 0) && !(atomic_read(&(journal->j_jlock))) 3728bd4c625cSLinus Torvalds && !flush && !commit_now && (journal->j_len < journal->j_max_batch) 3729bd4c625cSLinus Torvalds && journal->j_len_alloc < journal->j_max_batch 3730bd4c625cSLinus Torvalds && journal->j_cnode_free > (journal->j_trans_max * 3)) { 37311da177e4SLinus Torvalds journal->j_bcount++; 3732a9dd3643SJeff Mahoney unlock_journal(sb); 37331da177e4SLinus Torvalds return 0; 37341da177e4SLinus Torvalds } 37351da177e4SLinus Torvalds 3736a9dd3643SJeff Mahoney if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) { 3737a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-003", 3738c3a9c210SJeff Mahoney "j_start (%ld) is too high", 3739bd4c625cSLinus Torvalds journal->j_start); 37401da177e4SLinus Torvalds } 37411da177e4SLinus Torvalds return 1; 37421da177e4SLinus Torvalds } 37431da177e4SLinus Torvalds 37441da177e4SLinus Torvalds /* 37451da177e4SLinus Torvalds ** Does all the work that makes deleting blocks safe. 37461da177e4SLinus Torvalds ** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on. 37471da177e4SLinus Torvalds ** 37481da177e4SLinus Torvalds ** otherwise: 37491da177e4SLinus Torvalds ** set a bit for the block in the journal bitmap. That will prevent it from being allocated for unformatted nodes 37501da177e4SLinus Torvalds ** before this transaction has finished. 37511da177e4SLinus Torvalds ** 37521da177e4SLinus Torvalds ** mark any cnodes for this block as BLOCK_FREED, and clear their bh pointers. That will prevent any old transactions with 37531da177e4SLinus Torvalds ** this block from trying to flush to the real location. Since we aren't removing the cnode from the journal_list_hash, 37541da177e4SLinus Torvalds ** the block can't be reallocated yet. 37551da177e4SLinus Torvalds ** 37561da177e4SLinus Torvalds ** Then remove it from the current transaction, decrementing any counters and filing it on the clean list. 37571da177e4SLinus Torvalds */ 3758bd4c625cSLinus Torvalds int journal_mark_freed(struct reiserfs_transaction_handle *th, 3759a9dd3643SJeff Mahoney struct super_block *sb, b_blocknr_t blocknr) 3760bd4c625cSLinus Torvalds { 3761a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 37621da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn = NULL; 37631da177e4SLinus Torvalds struct buffer_head *bh = NULL; 37641da177e4SLinus Torvalds struct reiserfs_list_bitmap *jb = NULL; 37651da177e4SLinus Torvalds int cleaned = 0; 37661da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 37671da177e4SLinus Torvalds 3768a9dd3643SJeff Mahoney cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr); 37691da177e4SLinus Torvalds if (cn && cn->bh) { 37701da177e4SLinus Torvalds bh = cn->bh; 37711da177e4SLinus Torvalds get_bh(bh); 37721da177e4SLinus Torvalds } 37731da177e4SLinus Torvalds /* if it is journal new, we just remove it from this transaction */ 37741da177e4SLinus Torvalds if (bh && buffer_journal_new(bh)) { 37751da177e4SLinus Torvalds clear_buffer_journal_new(bh); 37761da177e4SLinus Torvalds clear_prepared_bits(bh); 37771da177e4SLinus Torvalds reiserfs_clean_and_file_buffer(bh); 3778a9dd3643SJeff Mahoney cleaned = remove_from_transaction(sb, blocknr, cleaned); 37791da177e4SLinus Torvalds } else { 37801da177e4SLinus Torvalds /* set the bit for this block in the journal bitmap for this transaction */ 37811da177e4SLinus Torvalds jb = journal->j_current_jl->j_list_bitmap; 37821da177e4SLinus Torvalds if (!jb) { 3783a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-1702", 3784c3a9c210SJeff Mahoney "journal_list_bitmap is NULL"); 37851da177e4SLinus Torvalds } 3786a9dd3643SJeff Mahoney set_bit_in_list_bitmap(sb, blocknr, jb); 37871da177e4SLinus Torvalds 37881da177e4SLinus Torvalds /* Note, the entire while loop is not allowed to schedule. */ 37891da177e4SLinus Torvalds 37901da177e4SLinus Torvalds if (bh) { 37911da177e4SLinus Torvalds clear_prepared_bits(bh); 37921da177e4SLinus Torvalds reiserfs_clean_and_file_buffer(bh); 37931da177e4SLinus Torvalds } 3794a9dd3643SJeff Mahoney cleaned = remove_from_transaction(sb, blocknr, cleaned); 37951da177e4SLinus Torvalds 37961da177e4SLinus Torvalds /* find all older transactions with this block, make sure they don't try to write it out */ 3797a9dd3643SJeff Mahoney cn = get_journal_hash_dev(sb, journal->j_list_hash_table, 3798bd4c625cSLinus Torvalds blocknr); 37991da177e4SLinus Torvalds while (cn) { 3800a9dd3643SJeff Mahoney if (sb == cn->sb && blocknr == cn->blocknr) { 38011da177e4SLinus Torvalds set_bit(BLOCK_FREED, &cn->state); 38021da177e4SLinus Torvalds if (cn->bh) { 38031da177e4SLinus Torvalds if (!cleaned) { 38041da177e4SLinus Torvalds /* remove_from_transaction will brelse the buffer if it was 38051da177e4SLinus Torvalds ** in the current trans 38061da177e4SLinus Torvalds */ 3807bd4c625cSLinus Torvalds clear_buffer_journal_dirty(cn-> 3808bd4c625cSLinus Torvalds bh); 38091da177e4SLinus Torvalds clear_buffer_dirty(cn->bh); 3810bd4c625cSLinus Torvalds clear_buffer_journal_test(cn-> 3811bd4c625cSLinus Torvalds bh); 38121da177e4SLinus Torvalds cleaned = 1; 38131da177e4SLinus Torvalds put_bh(cn->bh); 3814bd4c625cSLinus Torvalds if (atomic_read 3815bd4c625cSLinus Torvalds (&(cn->bh->b_count)) < 0) { 3816a9dd3643SJeff Mahoney reiserfs_warning(sb, 381745b03d5eSJeff Mahoney "journal-2138", 381845b03d5eSJeff Mahoney "cn->bh->b_count < 0"); 38191da177e4SLinus Torvalds } 38201da177e4SLinus Torvalds } 38211da177e4SLinus Torvalds if (cn->jlist) { /* since we are clearing the bh, we MUST dec nonzerolen */ 3822bd4c625cSLinus Torvalds atomic_dec(& 3823bd4c625cSLinus Torvalds (cn->jlist-> 3824bd4c625cSLinus Torvalds j_nonzerolen)); 38251da177e4SLinus Torvalds } 38261da177e4SLinus Torvalds cn->bh = NULL; 38271da177e4SLinus Torvalds } 38281da177e4SLinus Torvalds } 38291da177e4SLinus Torvalds cn = cn->hnext; 38301da177e4SLinus Torvalds } 38311da177e4SLinus Torvalds } 38321da177e4SLinus Torvalds 3833398c95bdSChris Mason if (bh) 3834398c95bdSChris Mason release_buffer_page(bh); /* get_hash grabs the buffer */ 38351da177e4SLinus Torvalds return 0; 38361da177e4SLinus Torvalds } 38371da177e4SLinus Torvalds 3838bd4c625cSLinus Torvalds void reiserfs_update_inode_transaction(struct inode *inode) 3839bd4c625cSLinus Torvalds { 38401da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb); 38411da177e4SLinus Torvalds REISERFS_I(inode)->i_jl = journal->j_current_jl; 38421da177e4SLinus Torvalds REISERFS_I(inode)->i_trans_id = journal->j_trans_id; 38431da177e4SLinus Torvalds } 38441da177e4SLinus Torvalds 38451da177e4SLinus Torvalds /* 38461da177e4SLinus Torvalds * returns -1 on error, 0 if no commits/barriers were done and 1 38471da177e4SLinus Torvalds * if a transaction was actually committed and the barrier was done 38481da177e4SLinus Torvalds */ 38491da177e4SLinus Torvalds static int __commit_trans_jl(struct inode *inode, unsigned long id, 38501da177e4SLinus Torvalds struct reiserfs_journal_list *jl) 38511da177e4SLinus Torvalds { 38521da177e4SLinus Torvalds struct reiserfs_transaction_handle th; 38531da177e4SLinus Torvalds struct super_block *sb = inode->i_sb; 38541da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(sb); 38551da177e4SLinus Torvalds int ret = 0; 38561da177e4SLinus Torvalds 38571da177e4SLinus Torvalds /* is it from the current transaction, or from an unknown transaction? */ 38581da177e4SLinus Torvalds if (id == journal->j_trans_id) { 38591da177e4SLinus Torvalds jl = journal->j_current_jl; 38601da177e4SLinus Torvalds /* try to let other writers come in and grow this transaction */ 38611da177e4SLinus Torvalds let_transaction_grow(sb, id); 38621da177e4SLinus Torvalds if (journal->j_trans_id != id) { 38631da177e4SLinus Torvalds goto flush_commit_only; 38641da177e4SLinus Torvalds } 38651da177e4SLinus Torvalds 38661da177e4SLinus Torvalds ret = journal_begin(&th, sb, 1); 38671da177e4SLinus Torvalds if (ret) 38681da177e4SLinus Torvalds return ret; 38691da177e4SLinus Torvalds 38701da177e4SLinus Torvalds /* someone might have ended this transaction while we joined */ 38711da177e4SLinus Torvalds if (journal->j_trans_id != id) { 3872bd4c625cSLinus Torvalds reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 3873bd4c625cSLinus Torvalds 1); 38741da177e4SLinus Torvalds journal_mark_dirty(&th, sb, SB_BUFFER_WITH_SB(sb)); 38751da177e4SLinus Torvalds ret = journal_end(&th, sb, 1); 38761da177e4SLinus Torvalds goto flush_commit_only; 38771da177e4SLinus Torvalds } 38781da177e4SLinus Torvalds 38791da177e4SLinus Torvalds ret = journal_end_sync(&th, sb, 1); 38801da177e4SLinus Torvalds if (!ret) 38811da177e4SLinus Torvalds ret = 1; 38821da177e4SLinus Torvalds 38831da177e4SLinus Torvalds } else { 38841da177e4SLinus Torvalds /* this gets tricky, we have to make sure the journal list in 38851da177e4SLinus Torvalds * the inode still exists. We know the list is still around 38861da177e4SLinus Torvalds * if we've got a larger transaction id than the oldest list 38871da177e4SLinus Torvalds */ 38881da177e4SLinus Torvalds flush_commit_only: 38891da177e4SLinus Torvalds if (journal_list_still_alive(inode->i_sb, id)) { 38901da177e4SLinus Torvalds /* 38911da177e4SLinus Torvalds * we only set ret to 1 when we know for sure 38921da177e4SLinus Torvalds * the barrier hasn't been started yet on the commit 38931da177e4SLinus Torvalds * block. 38941da177e4SLinus Torvalds */ 38951da177e4SLinus Torvalds if (atomic_read(&jl->j_commit_left) > 1) 38961da177e4SLinus Torvalds ret = 1; 38971da177e4SLinus Torvalds flush_commit_list(sb, jl, 1); 38981da177e4SLinus Torvalds if (journal->j_errno) 38991da177e4SLinus Torvalds ret = journal->j_errno; 39001da177e4SLinus Torvalds } 39011da177e4SLinus Torvalds } 39021da177e4SLinus Torvalds /* otherwise the list is gone, and long since committed */ 39031da177e4SLinus Torvalds return ret; 39041da177e4SLinus Torvalds } 39051da177e4SLinus Torvalds 3906bd4c625cSLinus Torvalds int reiserfs_commit_for_inode(struct inode *inode) 3907bd4c625cSLinus Torvalds { 3908600ed416SJeff Mahoney unsigned int id = REISERFS_I(inode)->i_trans_id; 39091da177e4SLinus Torvalds struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl; 39101da177e4SLinus Torvalds 39111da177e4SLinus Torvalds /* for the whole inode, assume unset id means it was 39121da177e4SLinus Torvalds * changed in the current transaction. More conservative 39131da177e4SLinus Torvalds */ 39141da177e4SLinus Torvalds if (!id || !jl) { 39151da177e4SLinus Torvalds reiserfs_update_inode_transaction(inode); 39161da177e4SLinus Torvalds id = REISERFS_I(inode)->i_trans_id; 39171da177e4SLinus Torvalds /* jl will be updated in __commit_trans_jl */ 39181da177e4SLinus Torvalds } 39191da177e4SLinus Torvalds 39201da177e4SLinus Torvalds return __commit_trans_jl(inode, id, jl); 39211da177e4SLinus Torvalds } 39221da177e4SLinus Torvalds 3923a9dd3643SJeff Mahoney void reiserfs_restore_prepared_buffer(struct super_block *sb, 3924bd4c625cSLinus Torvalds struct buffer_head *bh) 3925bd4c625cSLinus Torvalds { 3926a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 3927a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.restore_prepared); 39281da177e4SLinus Torvalds if (!bh) { 39291da177e4SLinus Torvalds return; 39301da177e4SLinus Torvalds } 39311da177e4SLinus Torvalds if (test_clear_buffer_journal_restore_dirty(bh) && 39321da177e4SLinus Torvalds buffer_journal_dirty(bh)) { 39331da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn; 3934a9dd3643SJeff Mahoney cn = get_journal_hash_dev(sb, 39351da177e4SLinus Torvalds journal->j_list_hash_table, 39361da177e4SLinus Torvalds bh->b_blocknr); 39371da177e4SLinus Torvalds if (cn && can_dirty(cn)) { 39381da177e4SLinus Torvalds set_buffer_journal_test(bh); 39391da177e4SLinus Torvalds mark_buffer_dirty(bh); 39401da177e4SLinus Torvalds } 39411da177e4SLinus Torvalds } 39421da177e4SLinus Torvalds clear_buffer_journal_prepared(bh); 39431da177e4SLinus Torvalds } 39441da177e4SLinus Torvalds 39451da177e4SLinus Torvalds extern struct tree_balance *cur_tb; 39461da177e4SLinus Torvalds /* 39471da177e4SLinus Torvalds ** before we can change a metadata block, we have to make sure it won't 39481da177e4SLinus Torvalds ** be written to disk while we are altering it. So, we must: 39491da177e4SLinus Torvalds ** clean it 39501da177e4SLinus Torvalds ** wait on it. 39511da177e4SLinus Torvalds ** 39521da177e4SLinus Torvalds */ 3953a9dd3643SJeff Mahoney int reiserfs_prepare_for_journal(struct super_block *sb, 3954bd4c625cSLinus Torvalds struct buffer_head *bh, int wait) 3955bd4c625cSLinus Torvalds { 3956a9dd3643SJeff Mahoney PROC_INFO_INC(sb, journal.prepare); 39571da177e4SLinus Torvalds 3958ca5de404SNick Piggin if (!trylock_buffer(bh)) { 39591da177e4SLinus Torvalds if (!wait) 39601da177e4SLinus Torvalds return 0; 39611da177e4SLinus Torvalds lock_buffer(bh); 39621da177e4SLinus Torvalds } 39631da177e4SLinus Torvalds set_buffer_journal_prepared(bh); 39641da177e4SLinus Torvalds if (test_clear_buffer_dirty(bh) && buffer_journal_dirty(bh)) { 39651da177e4SLinus Torvalds clear_buffer_journal_test(bh); 39661da177e4SLinus Torvalds set_buffer_journal_restore_dirty(bh); 39671da177e4SLinus Torvalds } 39681da177e4SLinus Torvalds unlock_buffer(bh); 39691da177e4SLinus Torvalds return 1; 39701da177e4SLinus Torvalds } 39711da177e4SLinus Torvalds 3972bd4c625cSLinus Torvalds static void flush_old_journal_lists(struct super_block *s) 3973bd4c625cSLinus Torvalds { 39741da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(s); 39751da177e4SLinus Torvalds struct reiserfs_journal_list *jl; 39761da177e4SLinus Torvalds struct list_head *entry; 39771da177e4SLinus Torvalds time_t now = get_seconds(); 39781da177e4SLinus Torvalds 39791da177e4SLinus Torvalds while (!list_empty(&journal->j_journal_list)) { 39801da177e4SLinus Torvalds entry = journal->j_journal_list.next; 39811da177e4SLinus Torvalds jl = JOURNAL_LIST_ENTRY(entry); 39821da177e4SLinus Torvalds /* this check should always be run, to send old lists to disk */ 3983a3172027SChris Mason if (jl->j_timestamp < (now - (JOURNAL_MAX_TRANS_AGE * 4)) && 3984a3172027SChris Mason atomic_read(&jl->j_commit_left) == 0 && 3985a3172027SChris Mason test_transaction(s, jl)) { 39861da177e4SLinus Torvalds flush_used_journal_lists(s, jl); 39871da177e4SLinus Torvalds } else { 39881da177e4SLinus Torvalds break; 39891da177e4SLinus Torvalds } 39901da177e4SLinus Torvalds } 39911da177e4SLinus Torvalds } 39921da177e4SLinus Torvalds 39931da177e4SLinus Torvalds /* 39941da177e4SLinus Torvalds ** long and ugly. If flush, will not return until all commit 39951da177e4SLinus Torvalds ** blocks and all real buffers in the trans are on disk. 39961da177e4SLinus Torvalds ** If no_async, won't return until all commit blocks are on disk. 39971da177e4SLinus Torvalds ** 39981da177e4SLinus Torvalds ** keep reading, there are comments as you go along 39991da177e4SLinus Torvalds ** 40001da177e4SLinus Torvalds ** If the journal is aborted, we just clean up. Things like flushing 40011da177e4SLinus Torvalds ** journal lists, etc just won't happen. 40021da177e4SLinus Torvalds */ 4003bd4c625cSLinus Torvalds static int do_journal_end(struct reiserfs_transaction_handle *th, 4004a9dd3643SJeff Mahoney struct super_block *sb, unsigned long nblocks, 4005bd4c625cSLinus Torvalds int flags) 4006bd4c625cSLinus Torvalds { 4007a9dd3643SJeff Mahoney struct reiserfs_journal *journal = SB_JOURNAL(sb); 40081da177e4SLinus Torvalds struct reiserfs_journal_cnode *cn, *next, *jl_cn; 40091da177e4SLinus Torvalds struct reiserfs_journal_cnode *last_cn = NULL; 40101da177e4SLinus Torvalds struct reiserfs_journal_desc *desc; 40111da177e4SLinus Torvalds struct reiserfs_journal_commit *commit; 40121da177e4SLinus Torvalds struct buffer_head *c_bh; /* commit bh */ 40131da177e4SLinus Torvalds struct buffer_head *d_bh; /* desc bh */ 40141da177e4SLinus Torvalds int cur_write_start = 0; /* start index of current log write */ 40151da177e4SLinus Torvalds int old_start; 40161da177e4SLinus Torvalds int i; 4017a44c94a7SAlexander Zarochentsev int flush; 4018a44c94a7SAlexander Zarochentsev int wait_on_commit; 40191da177e4SLinus Torvalds struct reiserfs_journal_list *jl, *temp_jl; 40201da177e4SLinus Torvalds struct list_head *entry, *safe; 40211da177e4SLinus Torvalds unsigned long jindex; 4022600ed416SJeff Mahoney unsigned int commit_trans_id; 40231da177e4SLinus Torvalds int trans_half; 40241da177e4SLinus Torvalds 40251da177e4SLinus Torvalds BUG_ON(th->t_refcount > 1); 40261da177e4SLinus Torvalds BUG_ON(!th->t_trans_id); 40271da177e4SLinus Torvalds 4028a44c94a7SAlexander Zarochentsev /* protect flush_older_commits from doing mistakes if the 4029a44c94a7SAlexander Zarochentsev transaction ID counter gets overflowed. */ 4030600ed416SJeff Mahoney if (th->t_trans_id == ~0U) 4031a44c94a7SAlexander Zarochentsev flags |= FLUSH_ALL | COMMIT_NOW | WAIT; 4032a44c94a7SAlexander Zarochentsev flush = flags & FLUSH_ALL; 4033a44c94a7SAlexander Zarochentsev wait_on_commit = flags & WAIT; 4034a44c94a7SAlexander Zarochentsev 403522e2c507SJens Axboe put_fs_excl(); 40361da177e4SLinus Torvalds current->journal_info = th->t_handle_save; 4037a9dd3643SJeff Mahoney reiserfs_check_lock_depth(sb, "journal end"); 40381da177e4SLinus Torvalds if (journal->j_len == 0) { 4039a9dd3643SJeff Mahoney reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb), 4040bd4c625cSLinus Torvalds 1); 4041a9dd3643SJeff Mahoney journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb)); 40421da177e4SLinus Torvalds } 40431da177e4SLinus Torvalds 4044a9dd3643SJeff Mahoney lock_journal(sb); 40451da177e4SLinus Torvalds if (journal->j_next_full_flush) { 40461da177e4SLinus Torvalds flags |= FLUSH_ALL; 40471da177e4SLinus Torvalds flush = 1; 40481da177e4SLinus Torvalds } 40491da177e4SLinus Torvalds if (journal->j_next_async_flush) { 40501da177e4SLinus Torvalds flags |= COMMIT_NOW | WAIT; 40511da177e4SLinus Torvalds wait_on_commit = 1; 40521da177e4SLinus Torvalds } 40531da177e4SLinus Torvalds 40541da177e4SLinus Torvalds /* check_journal_end locks the journal, and unlocks if it does not return 1 40551da177e4SLinus Torvalds ** it tells us if we should continue with the journal_end, or just return 40561da177e4SLinus Torvalds */ 4057a9dd3643SJeff Mahoney if (!check_journal_end(th, sb, nblocks, flags)) { 4058a9dd3643SJeff Mahoney sb->s_dirt = 1; 4059a9dd3643SJeff Mahoney wake_queued_writers(sb); 4060a9dd3643SJeff Mahoney reiserfs_async_progress_wait(sb); 40611da177e4SLinus Torvalds goto out; 40621da177e4SLinus Torvalds } 40631da177e4SLinus Torvalds 40641da177e4SLinus Torvalds /* check_journal_end might set these, check again */ 40651da177e4SLinus Torvalds if (journal->j_next_full_flush) { 40661da177e4SLinus Torvalds flush = 1; 40671da177e4SLinus Torvalds } 40681da177e4SLinus Torvalds 40691da177e4SLinus Torvalds /* 40701da177e4SLinus Torvalds ** j must wait means we have to flush the log blocks, and the real blocks for 40711da177e4SLinus Torvalds ** this transaction 40721da177e4SLinus Torvalds */ 40731da177e4SLinus Torvalds if (journal->j_must_wait > 0) { 40741da177e4SLinus Torvalds flush = 1; 40751da177e4SLinus Torvalds } 40761da177e4SLinus Torvalds #ifdef REISERFS_PREALLOCATE 4077ef43bc4fSJan Kara /* quota ops might need to nest, setup the journal_info pointer for them 4078ef43bc4fSJan Kara * and raise the refcount so that it is > 0. */ 40791da177e4SLinus Torvalds current->journal_info = th; 4080ef43bc4fSJan Kara th->t_refcount++; 40811da177e4SLinus Torvalds reiserfs_discard_all_prealloc(th); /* it should not involve new blocks into 40821da177e4SLinus Torvalds * the transaction */ 4083ef43bc4fSJan Kara th->t_refcount--; 40841da177e4SLinus Torvalds current->journal_info = th->t_handle_save; 40851da177e4SLinus Torvalds #endif 40861da177e4SLinus Torvalds 40871da177e4SLinus Torvalds /* setup description block */ 4088bd4c625cSLinus Torvalds d_bh = 4089a9dd3643SJeff Mahoney journal_getblk(sb, 4090a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 4091bd4c625cSLinus Torvalds journal->j_start); 40921da177e4SLinus Torvalds set_buffer_uptodate(d_bh); 40931da177e4SLinus Torvalds desc = (struct reiserfs_journal_desc *)(d_bh)->b_data; 40941da177e4SLinus Torvalds memset(d_bh->b_data, 0, d_bh->b_size); 40951da177e4SLinus Torvalds memcpy(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8); 40961da177e4SLinus Torvalds set_desc_trans_id(desc, journal->j_trans_id); 40971da177e4SLinus Torvalds 40981da177e4SLinus Torvalds /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */ 4099a9dd3643SJeff Mahoney c_bh = journal_getblk(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 4100bd4c625cSLinus Torvalds ((journal->j_start + journal->j_len + 4101a9dd3643SJeff Mahoney 1) % SB_ONDISK_JOURNAL_SIZE(sb))); 41021da177e4SLinus Torvalds commit = (struct reiserfs_journal_commit *)c_bh->b_data; 41031da177e4SLinus Torvalds memset(c_bh->b_data, 0, c_bh->b_size); 41041da177e4SLinus Torvalds set_commit_trans_id(commit, journal->j_trans_id); 41051da177e4SLinus Torvalds set_buffer_uptodate(c_bh); 41061da177e4SLinus Torvalds 41071da177e4SLinus Torvalds /* init this journal list */ 41081da177e4SLinus Torvalds jl = journal->j_current_jl; 41091da177e4SLinus Torvalds 41101da177e4SLinus Torvalds /* we lock the commit before doing anything because 41111da177e4SLinus Torvalds * we want to make sure nobody tries to run flush_commit_list until 41121da177e4SLinus Torvalds * the new transaction is fully setup, and we've already flushed the 41131da177e4SLinus Torvalds * ordered bh list 41141da177e4SLinus Torvalds */ 41158ebc4232SFrederic Weisbecker reiserfs_mutex_lock_safe(&jl->j_commit_mutex, sb); 41161da177e4SLinus Torvalds 41171da177e4SLinus Torvalds /* save the transaction id in case we need to commit it later */ 41181da177e4SLinus Torvalds commit_trans_id = jl->j_trans_id; 41191da177e4SLinus Torvalds 41201da177e4SLinus Torvalds atomic_set(&jl->j_older_commits_done, 0); 41211da177e4SLinus Torvalds jl->j_trans_id = journal->j_trans_id; 41221da177e4SLinus Torvalds jl->j_timestamp = journal->j_trans_start_time; 41231da177e4SLinus Torvalds jl->j_commit_bh = c_bh; 41241da177e4SLinus Torvalds jl->j_start = journal->j_start; 41251da177e4SLinus Torvalds jl->j_len = journal->j_len; 41261da177e4SLinus Torvalds atomic_set(&jl->j_nonzerolen, journal->j_len); 41271da177e4SLinus Torvalds atomic_set(&jl->j_commit_left, journal->j_len + 2); 41281da177e4SLinus Torvalds jl->j_realblock = NULL; 41291da177e4SLinus Torvalds 41301da177e4SLinus Torvalds /* The ENTIRE FOR LOOP MUST not cause schedule to occur. 41311da177e4SLinus Torvalds ** for each real block, add it to the journal list hash, 41321da177e4SLinus Torvalds ** copy into real block index array in the commit or desc block 41331da177e4SLinus Torvalds */ 4134a9dd3643SJeff Mahoney trans_half = journal_trans_half(sb->s_blocksize); 41351da177e4SLinus Torvalds for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) { 41361da177e4SLinus Torvalds if (buffer_journaled(cn->bh)) { 4137a9dd3643SJeff Mahoney jl_cn = get_cnode(sb); 41381da177e4SLinus Torvalds if (!jl_cn) { 4139a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-1676", 4140c3a9c210SJeff Mahoney "get_cnode returned NULL"); 41411da177e4SLinus Torvalds } 41421da177e4SLinus Torvalds if (i == 0) { 41431da177e4SLinus Torvalds jl->j_realblock = jl_cn; 41441da177e4SLinus Torvalds } 41451da177e4SLinus Torvalds jl_cn->prev = last_cn; 41461da177e4SLinus Torvalds jl_cn->next = NULL; 41471da177e4SLinus Torvalds if (last_cn) { 41481da177e4SLinus Torvalds last_cn->next = jl_cn; 41491da177e4SLinus Torvalds } 41501da177e4SLinus Torvalds last_cn = jl_cn; 41511da177e4SLinus Torvalds /* make sure the block we are trying to log is not a block 41521da177e4SLinus Torvalds of journal or reserved area */ 41531da177e4SLinus Torvalds 4154bd4c625cSLinus Torvalds if (is_block_in_log_or_reserved_area 4155a9dd3643SJeff Mahoney (sb, cn->bh->b_blocknr)) { 4156a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-2332", 4157c3a9c210SJeff Mahoney "Trying to log block %lu, " 4158c3a9c210SJeff Mahoney "which is a log block", 4159bd4c625cSLinus Torvalds cn->bh->b_blocknr); 41601da177e4SLinus Torvalds } 41611da177e4SLinus Torvalds jl_cn->blocknr = cn->bh->b_blocknr; 41621da177e4SLinus Torvalds jl_cn->state = 0; 4163a9dd3643SJeff Mahoney jl_cn->sb = sb; 41641da177e4SLinus Torvalds jl_cn->bh = cn->bh; 41651da177e4SLinus Torvalds jl_cn->jlist = jl; 41661da177e4SLinus Torvalds insert_journal_hash(journal->j_list_hash_table, jl_cn); 41671da177e4SLinus Torvalds if (i < trans_half) { 4168bd4c625cSLinus Torvalds desc->j_realblock[i] = 4169bd4c625cSLinus Torvalds cpu_to_le32(cn->bh->b_blocknr); 41701da177e4SLinus Torvalds } else { 4171bd4c625cSLinus Torvalds commit->j_realblock[i - trans_half] = 4172bd4c625cSLinus Torvalds cpu_to_le32(cn->bh->b_blocknr); 41731da177e4SLinus Torvalds } 41741da177e4SLinus Torvalds } else { 41751da177e4SLinus Torvalds i--; 41761da177e4SLinus Torvalds } 41771da177e4SLinus Torvalds } 41781da177e4SLinus Torvalds set_desc_trans_len(desc, journal->j_len); 41791da177e4SLinus Torvalds set_desc_mount_id(desc, journal->j_mount_id); 41801da177e4SLinus Torvalds set_desc_trans_id(desc, journal->j_trans_id); 41811da177e4SLinus Torvalds set_commit_trans_len(commit, journal->j_len); 41821da177e4SLinus Torvalds 41831da177e4SLinus Torvalds /* special check in case all buffers in the journal were marked for not logging */ 418414a61442SEric Sesterhenn BUG_ON(journal->j_len == 0); 41851da177e4SLinus Torvalds 41861da177e4SLinus Torvalds /* we're about to dirty all the log blocks, mark the description block 41871da177e4SLinus Torvalds * dirty now too. Don't mark the commit block dirty until all the 41881da177e4SLinus Torvalds * others are on disk 41891da177e4SLinus Torvalds */ 41901da177e4SLinus Torvalds mark_buffer_dirty(d_bh); 41911da177e4SLinus Torvalds 41921da177e4SLinus Torvalds /* first data block is j_start + 1, so add one to cur_write_start wherever you use it */ 41931da177e4SLinus Torvalds cur_write_start = journal->j_start; 41941da177e4SLinus Torvalds cn = journal->j_first; 41951da177e4SLinus Torvalds jindex = 1; /* start at one so we don't get the desc again */ 41961da177e4SLinus Torvalds while (cn) { 41971da177e4SLinus Torvalds clear_buffer_journal_new(cn->bh); 41981da177e4SLinus Torvalds /* copy all the real blocks into log area. dirty log blocks */ 41991da177e4SLinus Torvalds if (buffer_journaled(cn->bh)) { 42001da177e4SLinus Torvalds struct buffer_head *tmp_bh; 42011da177e4SLinus Torvalds char *addr; 42021da177e4SLinus Torvalds struct page *page; 4203bd4c625cSLinus Torvalds tmp_bh = 4204a9dd3643SJeff Mahoney journal_getblk(sb, 4205a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_1st_BLOCK(sb) + 4206bd4c625cSLinus Torvalds ((cur_write_start + 4207bd4c625cSLinus Torvalds jindex) % 4208a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb))); 42091da177e4SLinus Torvalds set_buffer_uptodate(tmp_bh); 42101da177e4SLinus Torvalds page = cn->bh->b_page; 42111da177e4SLinus Torvalds addr = kmap(page); 4212bd4c625cSLinus Torvalds memcpy(tmp_bh->b_data, 4213bd4c625cSLinus Torvalds addr + offset_in_page(cn->bh->b_data), 42141da177e4SLinus Torvalds cn->bh->b_size); 42151da177e4SLinus Torvalds kunmap(page); 42161da177e4SLinus Torvalds mark_buffer_dirty(tmp_bh); 42171da177e4SLinus Torvalds jindex++; 42181da177e4SLinus Torvalds set_buffer_journal_dirty(cn->bh); 42191da177e4SLinus Torvalds clear_buffer_journaled(cn->bh); 42201da177e4SLinus Torvalds } else { 42211da177e4SLinus Torvalds /* JDirty cleared sometime during transaction. don't log this one */ 4222a9dd3643SJeff Mahoney reiserfs_warning(sb, "journal-2048", 422345b03d5eSJeff Mahoney "BAD, buffer in journal hash, " 422445b03d5eSJeff Mahoney "but not JDirty!"); 42251da177e4SLinus Torvalds brelse(cn->bh); 42261da177e4SLinus Torvalds } 42271da177e4SLinus Torvalds next = cn->next; 4228a9dd3643SJeff Mahoney free_cnode(sb, cn); 42291da177e4SLinus Torvalds cn = next; 4230e6950a4dSFrederic Weisbecker reiserfs_write_unlock(sb); 42311da177e4SLinus Torvalds cond_resched(); 4232e6950a4dSFrederic Weisbecker reiserfs_write_lock(sb); 42331da177e4SLinus Torvalds } 42341da177e4SLinus Torvalds 42351da177e4SLinus Torvalds /* we are done with both the c_bh and d_bh, but 42361da177e4SLinus Torvalds ** c_bh must be written after all other commit blocks, 42371da177e4SLinus Torvalds ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1. 42381da177e4SLinus Torvalds */ 42391da177e4SLinus Torvalds 4240a9dd3643SJeff Mahoney journal->j_current_jl = alloc_journal_list(sb); 42411da177e4SLinus Torvalds 42421da177e4SLinus Torvalds /* now it is safe to insert this transaction on the main list */ 42431da177e4SLinus Torvalds list_add_tail(&jl->j_list, &journal->j_journal_list); 42441da177e4SLinus Torvalds list_add_tail(&jl->j_working_list, &journal->j_working_list); 42451da177e4SLinus Torvalds journal->j_num_work_lists++; 42461da177e4SLinus Torvalds 42471da177e4SLinus Torvalds /* reset journal values for the next transaction */ 42481da177e4SLinus Torvalds old_start = journal->j_start; 4249bd4c625cSLinus Torvalds journal->j_start = 4250bd4c625cSLinus Torvalds (journal->j_start + journal->j_len + 4251a9dd3643SJeff Mahoney 2) % SB_ONDISK_JOURNAL_SIZE(sb); 42521da177e4SLinus Torvalds atomic_set(&(journal->j_wcount), 0); 42531da177e4SLinus Torvalds journal->j_bcount = 0; 42541da177e4SLinus Torvalds journal->j_last = NULL; 42551da177e4SLinus Torvalds journal->j_first = NULL; 42561da177e4SLinus Torvalds journal->j_len = 0; 42571da177e4SLinus Torvalds journal->j_trans_start_time = 0; 4258a44c94a7SAlexander Zarochentsev /* check for trans_id overflow */ 4259a44c94a7SAlexander Zarochentsev if (++journal->j_trans_id == 0) 4260a44c94a7SAlexander Zarochentsev journal->j_trans_id = 10; 42611da177e4SLinus Torvalds journal->j_current_jl->j_trans_id = journal->j_trans_id; 42621da177e4SLinus Torvalds journal->j_must_wait = 0; 42631da177e4SLinus Torvalds journal->j_len_alloc = 0; 42641da177e4SLinus Torvalds journal->j_next_full_flush = 0; 42651da177e4SLinus Torvalds journal->j_next_async_flush = 0; 4266a9dd3643SJeff Mahoney init_journal_hash(sb); 42671da177e4SLinus Torvalds 42681da177e4SLinus Torvalds // make sure reiserfs_add_jh sees the new current_jl before we 42691da177e4SLinus Torvalds // write out the tails 42701da177e4SLinus Torvalds smp_mb(); 42711da177e4SLinus Torvalds 42721da177e4SLinus Torvalds /* tail conversion targets have to hit the disk before we end the 42731da177e4SLinus Torvalds * transaction. Otherwise a later transaction might repack the tail 42741da177e4SLinus Torvalds * before this transaction commits, leaving the data block unflushed and 42751da177e4SLinus Torvalds * clean, if we crash before the later transaction commits, the data block 42761da177e4SLinus Torvalds * is lost. 42771da177e4SLinus Torvalds */ 42781da177e4SLinus Torvalds if (!list_empty(&jl->j_tail_bh_list)) { 42798ebc4232SFrederic Weisbecker reiserfs_write_unlock(sb); 42801da177e4SLinus Torvalds write_ordered_buffers(&journal->j_dirty_buffers_lock, 42811da177e4SLinus Torvalds journal, jl, &jl->j_tail_bh_list); 42828ebc4232SFrederic Weisbecker reiserfs_write_lock(sb); 42831da177e4SLinus Torvalds } 428414a61442SEric Sesterhenn BUG_ON(!list_empty(&jl->j_tail_bh_list)); 428590415deaSJeff Mahoney mutex_unlock(&jl->j_commit_mutex); 42861da177e4SLinus Torvalds 42871da177e4SLinus Torvalds /* honor the flush wishes from the caller, simple commits can 42881da177e4SLinus Torvalds ** be done outside the journal lock, they are done below 42891da177e4SLinus Torvalds ** 42901da177e4SLinus Torvalds ** if we don't flush the commit list right now, we put it into 42911da177e4SLinus Torvalds ** the work queue so the people waiting on the async progress work 42921da177e4SLinus Torvalds ** queue don't wait for this proc to flush journal lists and such. 42931da177e4SLinus Torvalds */ 42941da177e4SLinus Torvalds if (flush) { 4295a9dd3643SJeff Mahoney flush_commit_list(sb, jl, 1); 4296a9dd3643SJeff Mahoney flush_journal_list(sb, jl, 1); 42971da177e4SLinus Torvalds } else if (!(jl->j_state & LIST_COMMIT_PENDING)) 42981da177e4SLinus Torvalds queue_delayed_work(commit_wq, &journal->j_work, HZ / 10); 42991da177e4SLinus Torvalds 43001da177e4SLinus Torvalds /* if the next transaction has any chance of wrapping, flush 43011da177e4SLinus Torvalds ** transactions that might get overwritten. If any journal lists are very 43021da177e4SLinus Torvalds ** old flush them as well. 43031da177e4SLinus Torvalds */ 43041da177e4SLinus Torvalds first_jl: 43051da177e4SLinus Torvalds list_for_each_safe(entry, safe, &journal->j_journal_list) { 43061da177e4SLinus Torvalds temp_jl = JOURNAL_LIST_ENTRY(entry); 43071da177e4SLinus Torvalds if (journal->j_start <= temp_jl->j_start) { 43081da177e4SLinus Torvalds if ((journal->j_start + journal->j_trans_max + 1) >= 4309bd4c625cSLinus Torvalds temp_jl->j_start) { 4310a9dd3643SJeff Mahoney flush_used_journal_lists(sb, temp_jl); 43111da177e4SLinus Torvalds goto first_jl; 43121da177e4SLinus Torvalds } else if ((journal->j_start + 43131da177e4SLinus Torvalds journal->j_trans_max + 1) < 4314a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb)) { 43151da177e4SLinus Torvalds /* if we don't cross into the next transaction and we don't 43161da177e4SLinus Torvalds * wrap, there is no way we can overlap any later transactions 43171da177e4SLinus Torvalds * break now 43181da177e4SLinus Torvalds */ 43191da177e4SLinus Torvalds break; 43201da177e4SLinus Torvalds } 43211da177e4SLinus Torvalds } else if ((journal->j_start + 43221da177e4SLinus Torvalds journal->j_trans_max + 1) > 4323a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb)) { 43241da177e4SLinus Torvalds if (((journal->j_start + journal->j_trans_max + 1) % 4325a9dd3643SJeff Mahoney SB_ONDISK_JOURNAL_SIZE(sb)) >= 4326bd4c625cSLinus Torvalds temp_jl->j_start) { 4327a9dd3643SJeff Mahoney flush_used_journal_lists(sb, temp_jl); 43281da177e4SLinus Torvalds goto first_jl; 43291da177e4SLinus Torvalds } else { 43301da177e4SLinus Torvalds /* we don't overlap anything from out start to the end of the 43311da177e4SLinus Torvalds * log, and our wrapped portion doesn't overlap anything at 43321da177e4SLinus Torvalds * the start of the log. We can break 43331da177e4SLinus Torvalds */ 43341da177e4SLinus Torvalds break; 43351da177e4SLinus Torvalds } 43361da177e4SLinus Torvalds } 43371da177e4SLinus Torvalds } 4338a9dd3643SJeff Mahoney flush_old_journal_lists(sb); 43391da177e4SLinus Torvalds 4340bd4c625cSLinus Torvalds journal->j_current_jl->j_list_bitmap = 4341a9dd3643SJeff Mahoney get_list_bitmap(sb, journal->j_current_jl); 43421da177e4SLinus Torvalds 43431da177e4SLinus Torvalds if (!(journal->j_current_jl->j_list_bitmap)) { 4344a9dd3643SJeff Mahoney reiserfs_panic(sb, "journal-1996", 4345c3a9c210SJeff Mahoney "could not get a list bitmap"); 43461da177e4SLinus Torvalds } 43471da177e4SLinus Torvalds 43481da177e4SLinus Torvalds atomic_set(&(journal->j_jlock), 0); 4349a9dd3643SJeff Mahoney unlock_journal(sb); 43501da177e4SLinus Torvalds /* wake up any body waiting to join. */ 43511da177e4SLinus Torvalds clear_bit(J_WRITERS_QUEUED, &journal->j_state); 43521da177e4SLinus Torvalds wake_up(&(journal->j_join_wait)); 43531da177e4SLinus Torvalds 43541da177e4SLinus Torvalds if (!flush && wait_on_commit && 4355a9dd3643SJeff Mahoney journal_list_still_alive(sb, commit_trans_id)) { 4356a9dd3643SJeff Mahoney flush_commit_list(sb, jl, 1); 43571da177e4SLinus Torvalds } 43581da177e4SLinus Torvalds out: 4359a9dd3643SJeff Mahoney reiserfs_check_lock_depth(sb, "journal end2"); 43601da177e4SLinus Torvalds 43611da177e4SLinus Torvalds memset(th, 0, sizeof(*th)); 43621da177e4SLinus Torvalds /* Re-set th->t_super, so we can properly keep track of how many 43631da177e4SLinus Torvalds * persistent transactions there are. We need to do this so if this 43641da177e4SLinus Torvalds * call is part of a failed restart_transaction, we can free it later */ 4365a9dd3643SJeff Mahoney th->t_super = sb; 43661da177e4SLinus Torvalds 43671da177e4SLinus Torvalds return journal->j_errno; 43681da177e4SLinus Torvalds } 43691da177e4SLinus Torvalds 437032e8b106SJeff Mahoney /* Send the file system read only and refuse new transactions */ 437132e8b106SJeff Mahoney void reiserfs_abort_journal(struct super_block *sb, int errno) 43721da177e4SLinus Torvalds { 43731da177e4SLinus Torvalds struct reiserfs_journal *journal = SB_JOURNAL(sb); 43741da177e4SLinus Torvalds if (test_bit(J_ABORTED, &journal->j_state)) 43751da177e4SLinus Torvalds return; 43761da177e4SLinus Torvalds 437732e8b106SJeff Mahoney if (!journal->j_errno) 437832e8b106SJeff Mahoney journal->j_errno = errno; 43791da177e4SLinus Torvalds 43801da177e4SLinus Torvalds sb->s_flags |= MS_RDONLY; 43811da177e4SLinus Torvalds set_bit(J_ABORTED, &journal->j_state); 43821da177e4SLinus Torvalds 43831da177e4SLinus Torvalds #ifdef CONFIG_REISERFS_CHECK 43841da177e4SLinus Torvalds dump_stack(); 43851da177e4SLinus Torvalds #endif 43861da177e4SLinus Torvalds } 43871da177e4SLinus Torvalds 4388