diff -uNr linux-2.4.18.o1/fs/reiserfs/bitmap.c linux-2.4.18.o/fs/reiserfs/bitmap.c --- linux-2.4.18.o1/fs/reiserfs/bitmap.c Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/fs/reiserfs/bitmap.c Thu Feb 28 18:48:51 2002 @@ -400,8 +400,8 @@ goto free_and_return ; } search_start = new_block ; - if (search_start >= reiserfs_get_journal_block(s) && - search_start < (reiserfs_get_journal_block(s) + JOURNAL_BLOCK_COUNT)) { + if (search_start >= SB_JOURNAL_BLOCK (s) && + search_start < (SB_JOURNAL_BLOCK (s) + SB_JOURNAL_SIZE(s))) { reiserfs_warning("vs-4130: reiserfs_new_blocknrs: trying to allocate log block %lu\n", search_start) ; search_start++ ; @@ -522,7 +522,7 @@ * no disk space returns */ - if ( (p_s_inode->i_size < 4 * 4096) || + if ( (p_s_inode->i_size < 4 * th->t_super->s_blocksize) || !(S_ISREG(p_s_inode->i_mode)) ) { if ( search_start < border diff -uNr linux-2.4.18.o1/fs/reiserfs/journal.c linux-2.4.18.o/fs/reiserfs/journal.c --- linux-2.4.18.o1/fs/reiserfs/journal.c Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/fs/reiserfs/journal.c Thu Feb 28 18:51:27 2002 @@ -672,7 +672,7 @@ atomic_set(&(jl->j_commit_flushing), 1) ; - if (jl->j_len > JOURNAL_TRANS_MAX) { + if (jl->j_len > SB_JOURNAL_TRANS_MAX(s)) { reiserfs_panic(s, "journal-512: flush_commit_list: length is %lu, list number %d\n", jl->j_len, jl - SB_JOURNAL_LIST(s)) ; return 0 ; } @@ -686,7 +686,7 @@ retry: count = 0 ; for (i = 0 ; atomic_read(&(jl->j_commit_left)) > 1 && i < (jl->j_len + 1) ; i++) { /* everything but commit_bh */ - bn = reiserfs_get_journal_block(s) + (jl->j_start+i) % JOURNAL_BLOCK_COUNT; + bn = SB_JOURNAL_BLOCK(s) + (jl->j_start+i) % SB_JOURNAL_SIZE(s) ; tbh = sb_get_hash_table(s, bn) ; /* kill this sanity check */ @@ -715,7 +715,7 @@ if (count > 0) { for (i = 0 ; atomic_read(&(jl->j_commit_left)) > 1 && i < (jl->j_len + 1) ; i++) { /* everything but commit_bh */ - bn = reiserfs_get_journal_block(s) + (jl->j_start + i) % JOURNAL_BLOCK_COUNT ; + bn = SB_JOURNAL_BLOCK(s) + (jl->j_start + i) % SB_JOURNAL_SIZE(s) ; tbh = sb_get_hash_table(s, bn) ; wait_on_buffer(tbh) ; @@ -931,7 +931,7 @@ atomic_set(&(jl->j_flushing), 1) ; count = 0 ; - if (j_len_saved > JOURNAL_TRANS_MAX) { + if (j_len_saved > SB_JOURNAL_TRANS_MAX(s)) { reiserfs_panic(s, "journal-715: flush_journal_list, length is %lu, list number %d\n", j_len_saved, jl - SB_JOURNAL_LIST(s)) ; atomic_dec(&(jl->j_flushing)) ; return 0 ; @@ -1088,7 +1088,7 @@ ** being flushed */ if (flushall) { - update_journal_header_block(s, (jl->j_start + jl->j_len + 2) % JOURNAL_BLOCK_COUNT, jl->j_trans_id) ; + update_journal_header_block(s, (jl->j_start + jl->j_len + 2) % SB_JOURNAL_SIZE(s), jl->j_trans_id) ; } remove_all_from_journal_list(s, jl, 0) ; jl->j_len = 0 ; @@ -1366,10 +1366,10 @@ /* compares description block with commit block. returns 1 if they differ, 0 if they are the same */ static int journal_compare_desc_commit(struct super_block *p_s_sb, struct reiserfs_journal_desc *desc, struct reiserfs_journal_commit *commit) { - if (le32_to_cpu(commit->j_trans_id) != le32_to_cpu(desc->j_trans_id) || - le32_to_cpu(commit->j_len) != le32_to_cpu(desc->j_len) || - le32_to_cpu(commit->j_len) > JOURNAL_TRANS_MAX || - le32_to_cpu(commit->j_len) <= 0 + if (get_commit_trans_id (commit) != get_desc_trans_id (desc) || + get_commit_trans_len (commit) != get_desc_trans_len (desc) || + get_commit_trans_len (commit) > SB_JOURNAL_TRANS_MAX(p_s_sb) || + get_commit_trans_len (commit) == 0 ) { return 1 ; } @@ -1389,25 +1389,25 @@ return 0 ; desc = (struct reiserfs_journal_desc *)d_bh->b_data ; - if (le32_to_cpu(desc->j_len) > 0 && !memcmp(desc->j_magic, JOURNAL_DESC_MAGIC, 8)) { - if (oldest_invalid_trans_id && *oldest_invalid_trans_id && le32_to_cpu(desc->j_trans_id) > *oldest_invalid_trans_id) { + if (get_desc_trans_len(desc) > 0 && !memcmp(get_journal_desc_magic (d_bh), JOURNAL_DESC_MAGIC, 8)) { + if (oldest_invalid_trans_id && *oldest_invalid_trans_id && get_desc_trans_id(desc) > *oldest_invalid_trans_id) { reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-986: transaction " "is valid returning because trans_id %d is greater than " - "oldest_invalid %lu\n", le32_to_cpu(desc->j_trans_id), + "oldest_invalid %lu\n", get_desc_trans_id(desc), *oldest_invalid_trans_id); return 0 ; } - if (newest_mount_id && *newest_mount_id > le32_to_cpu(desc->j_mount_id)) { + if (newest_mount_id && *newest_mount_id > get_desc_mount_id (desc)) { reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1087: transaction " "is valid returning because mount_id %d is less than " - "newest_mount_id %lu\n", desc->j_mount_id, + "newest_mount_id %lu\n", get_desc_mount_id (desc), *newest_mount_id) ; return -1 ; } - offset = d_bh->b_blocknr - reiserfs_get_journal_block(p_s_sb) ; + offset = d_bh->b_blocknr - SB_JOURNAL_BLOCK(p_s_sb) ; /* ok, we have a journal description block, lets see if the transaction was valid */ - c_bh = sb_bread(p_s_sb, reiserfs_get_journal_block(p_s_sb) + ((offset + le32_to_cpu(desc->j_len) + 1) % JOURNAL_BLOCK_COUNT)) ; + c_bh = sb_bread(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + ((offset + get_desc_trans_len(desc) + 1) % SB_JOURNAL_SIZE(p_s_sb))) ; if (!c_bh) return 0 ; commit = (struct reiserfs_journal_commit *)c_bh->b_data ; @@ -1415,22 +1415,22 @@ reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal_transaction_is_valid, commit offset %ld had bad " "time %d or length %d\n", - c_bh->b_blocknr - reiserfs_get_journal_block(p_s_sb), - le32_to_cpu(commit->j_trans_id), - le32_to_cpu(commit->j_len)); + c_bh->b_blocknr - SB_JOURNAL_BLOCK(p_s_sb), + get_commit_trans_id (commit), + get_commit_trans_len(commit)); brelse(c_bh) ; if (oldest_invalid_trans_id) - *oldest_invalid_trans_id = le32_to_cpu(desc->j_trans_id) ; + *oldest_invalid_trans_id = get_desc_trans_id(desc) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1004: " "transaction_is_valid setting oldest invalid trans_id " - "to %d\n", le32_to_cpu(desc->j_trans_id)) ; + "to %d\n", get_desc_trans_id(desc)) ; return -1; } brelse(c_bh) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1006: found valid " "transaction start offset %lu, len %d id %d\n", - d_bh->b_blocknr - reiserfs_get_journal_block(p_s_sb), - le32_to_cpu(desc->j_len), le32_to_cpu(desc->j_trans_id)) ; + d_bh->b_blocknr - SB_JOURNAL_BLOCK(p_s_sb), + get_desc_trans_len(desc), get_desc_trans_id(desc)) ; return 1 ; } else { return 0 ; @@ -1460,32 +1460,33 @@ struct buffer_head **real_blocks = NULL ; unsigned long trans_offset ; int i; + int trans_half; d_bh = sb_bread(p_s_sb, cur_dblock) ; if (!d_bh) return 1 ; desc = (struct reiserfs_journal_desc *)d_bh->b_data ; - trans_offset = d_bh->b_blocknr - reiserfs_get_journal_block(p_s_sb) ; + trans_offset = d_bh->b_blocknr - SB_JOURNAL_BLOCK(p_s_sb) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1037: " "journal_read_transaction, offset %lu, len %d mount_id %d\n", - d_bh->b_blocknr - reiserfs_get_journal_block(p_s_sb), - le32_to_cpu(desc->j_len), le32_to_cpu(desc->j_mount_id)) ; - if (le32_to_cpu(desc->j_trans_id) < oldest_trans_id) { + d_bh->b_blocknr - SB_JOURNAL_BLOCK(p_s_sb), + get_desc_trans_len(desc), get_desc_mount_id(desc)) ; + if (get_desc_trans_id(desc) < oldest_trans_id) { reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1039: " "journal_read_trans skipping because %lu is too old\n", - cur_dblock - reiserfs_get_journal_block(p_s_sb)) ; + cur_dblock - SB_JOURNAL_BLOCK(p_s_sb)) ; brelse(d_bh) ; return 1 ; } - if (le32_to_cpu(desc->j_mount_id) != newest_mount_id) { + if (get_desc_mount_id(desc) != newest_mount_id) { reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1146: " "journal_read_trans skipping because %d is != " - "newest_mount_id %lu\n", le32_to_cpu(desc->j_mount_id), + "newest_mount_id %lu\n", get_desc_mount_id(desc), newest_mount_id) ; brelse(d_bh) ; return 1 ; } - c_bh = sb_bread(p_s_sb, reiserfs_get_journal_block(p_s_sb) + ((trans_offset + le32_to_cpu(desc->j_len) + 1) % JOURNAL_BLOCK_COUNT)) ; + c_bh = sb_bread(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + ((trans_offset + get_desc_trans_len(desc) + 1) % SB_JOURNAL_SIZE(p_s_sb))) ; if (!c_bh) { brelse(d_bh) ; return 1 ; @@ -1502,48 +1503,49 @@ } trans_id = le32_to_cpu(desc->j_trans_id) ; /* now we know we've got a good transaction, and it was inside the valid time ranges */ - log_blocks = reiserfs_kmalloc(le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), GFP_NOFS, p_s_sb) ; - real_blocks = reiserfs_kmalloc(le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), GFP_NOFS, p_s_sb) ; + log_blocks = reiserfs_kmalloc(get_desc_trans_len(desc) * sizeof(struct buffer_head *), GFP_NOFS, p_s_sb) ; + real_blocks = reiserfs_kmalloc(get_desc_trans_len(desc) * sizeof(struct buffer_head *), GFP_NOFS, p_s_sb) ; if (!log_blocks || !real_blocks) { brelse(c_bh) ; brelse(d_bh) ; - reiserfs_kfree(log_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; - reiserfs_kfree(real_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(log_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(real_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; reiserfs_warning("journal-1169: kmalloc failed, unable to mount FS\n") ; return -1 ; } /* get all the buffer heads */ - for(i = 0 ; i < le32_to_cpu(desc->j_len) ; i++) { - log_blocks[i] = sb_getblk(p_s_sb, reiserfs_get_journal_block(p_s_sb) + (trans_offset + 1 + i) % JOURNAL_BLOCK_COUNT); - if (i < JOURNAL_TRANS_HALF) { + trans_half = journal_trans_half (p_s_sb->s_blocksize) ; + for(i = 0 ; i < get_desc_trans_len(desc) ; i++) { + log_blocks[i] = sb_getblk(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + (trans_offset + 1 + i) % SB_JOURNAL_SIZE(p_s_sb)); + if (i < trans_half) { real_blocks[i] = sb_getblk(p_s_sb, le32_to_cpu(desc->j_realblock[i])) ; } else { - real_blocks[i] = sb_getblk(p_s_sb, le32_to_cpu(commit->j_realblock[i - JOURNAL_TRANS_HALF])) ; + real_blocks[i] = sb_getblk(p_s_sb, le32_to_cpu(commit->j_realblock[i - trans_half])) ; } - if (real_blocks[i]->b_blocknr >= reiserfs_get_journal_block(p_s_sb) && - real_blocks[i]->b_blocknr < (reiserfs_get_journal_block(p_s_sb)+JOURNAL_BLOCK_COUNT)) { + if (real_blocks[i]->b_blocknr >= SB_JOURNAL_BLOCK(p_s_sb) && + real_blocks[i]->b_blocknr < (SB_JOURNAL_BLOCK(p_s_sb)+SB_JOURNAL_SIZE(p_s_sb))) { reiserfs_warning("journal-1204: REPLAY FAILURE fsck required! Trying to replay onto a log block\n") ; brelse_array(log_blocks, i) ; brelse_array(real_blocks, i) ; brelse(c_bh) ; brelse(d_bh) ; - reiserfs_kfree(log_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; - reiserfs_kfree(real_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(log_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(real_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; return -1 ; } } /* read in the log blocks, memcpy to the corresponding real block */ - ll_rw_block(READ, le32_to_cpu(desc->j_len), log_blocks) ; - for (i = 0 ; i < le32_to_cpu(desc->j_len) ; i++) { + ll_rw_block(READ, get_desc_trans_len(desc), log_blocks) ; + for (i = 0 ; i < get_desc_trans_len(desc) ; i++) { wait_on_buffer(log_blocks[i]) ; if (!buffer_uptodate(log_blocks[i])) { reiserfs_warning("journal-1212: REPLAY FAILURE fsck required! buffer write failed\n") ; - brelse_array(log_blocks + i, le32_to_cpu(desc->j_len) - i) ; - brelse_array(real_blocks, le32_to_cpu(desc->j_len)) ; + brelse_array(log_blocks + i, get_desc_trans_len(desc) - i) ; + brelse_array(real_blocks, get_desc_trans_len(desc)) ; brelse(c_bh) ; brelse(d_bh) ; - reiserfs_kfree(log_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; - reiserfs_kfree(real_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(log_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(real_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; return -1 ; } memcpy(real_blocks[i]->b_data, log_blocks[i]->b_data, real_blocks[i]->b_size) ; @@ -1551,36 +1553,36 @@ brelse(log_blocks[i]) ; } /* flush out the real blocks */ - for (i = 0 ; i < le32_to_cpu(desc->j_len) ; i++) { + for (i = 0 ; i < get_desc_trans_len(desc) ; i++) { set_bit(BH_Dirty, &(real_blocks[i]->b_state)) ; ll_rw_block(WRITE, 1, real_blocks + i) ; } - for (i = 0 ; i < le32_to_cpu(desc->j_len) ; i++) { + for (i = 0 ; i < get_desc_trans_len(desc) ; i++) { wait_on_buffer(real_blocks[i]) ; if (!buffer_uptodate(real_blocks[i])) { reiserfs_warning("journal-1226: REPLAY FAILURE, fsck required! buffer write failed\n") ; - brelse_array(real_blocks + i, le32_to_cpu(desc->j_len) - i) ; + brelse_array(real_blocks + i, get_desc_trans_len(desc) - i) ; brelse(c_bh) ; brelse(d_bh) ; - reiserfs_kfree(log_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; - reiserfs_kfree(real_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(log_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(real_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; return -1 ; } brelse(real_blocks[i]) ; } - cur_dblock = reiserfs_get_journal_block(p_s_sb) + ((trans_offset + le32_to_cpu(desc->j_len) + 2) % JOURNAL_BLOCK_COUNT) ; + cur_dblock = SB_JOURNAL_BLOCK(p_s_sb) + ((trans_offset + get_desc_trans_len(desc) + 2) % SB_JOURNAL_SIZE(p_s_sb)) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1095: setting journal " "start to offset %ld\n", - cur_dblock - reiserfs_get_journal_block(p_s_sb)) ; + cur_dblock - SB_JOURNAL_BLOCK(p_s_sb)) ; /* init starting values for the first transaction, in case this is the last transaction to be replayed. */ - SB_JOURNAL(p_s_sb)->j_start = cur_dblock - reiserfs_get_journal_block(p_s_sb) ; + SB_JOURNAL(p_s_sb)->j_start = cur_dblock - SB_JOURNAL_BLOCK(p_s_sb) ; SB_JOURNAL(p_s_sb)->j_last_flush_trans_id = trans_id ; SB_JOURNAL(p_s_sb)->j_trans_id = trans_id + 1; brelse(c_bh) ; brelse(d_bh) ; - reiserfs_kfree(log_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; - reiserfs_kfree(real_blocks, le32_to_cpu(desc->j_len) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(log_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; + reiserfs_kfree(real_blocks, get_desc_trans_len(desc) * sizeof(struct buffer_head *), p_s_sb) ; return 0 ; } @@ -1645,7 +1647,7 @@ int continue_replay = 1 ; int ret ; - cur_dblock = reiserfs_get_journal_block(p_s_sb) ; + cur_dblock = SB_JOURNAL_BLOCK(p_s_sb) ; printk("reiserfs: checking transaction log (device %s) ...\n", kdevname(p_s_sb->s_dev)) ; start = CURRENT_TIME ; @@ -1655,16 +1657,16 @@ ** replay is done */ SB_JOURNAL(p_s_sb)->j_header_bh = sb_bread(p_s_sb, - reiserfs_get_journal_block(p_s_sb) + - JOURNAL_BLOCK_COUNT) ; + SB_JOURNAL_BLOCK(p_s_sb) + + SB_JOURNAL_SIZE(p_s_sb)) ; if (!SB_JOURNAL(p_s_sb)->j_header_bh) { return 1 ; } jh = (struct reiserfs_journal_header *)(SB_JOURNAL(p_s_sb)->j_header_bh->b_data) ; if (le32_to_cpu(jh->j_first_unflushed_offset) >= 0 && - le32_to_cpu(jh->j_first_unflushed_offset) < JOURNAL_BLOCK_COUNT && + le32_to_cpu(jh->j_first_unflushed_offset) < SB_JOURNAL_SIZE(p_s_sb) && le32_to_cpu(jh->j_last_flush_trans_id) > 0) { - last_flush_start = reiserfs_get_journal_block(p_s_sb) + + last_flush_start = SB_JOURNAL_BLOCK(p_s_sb) + le32_to_cpu(jh->j_first_unflushed_offset) ; last_flush_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1153: found in " @@ -1677,7 +1679,7 @@ ** there is nothing more we can do, and it makes no sense to read ** through the whole log. */ - d_bh = sb_bread(p_s_sb, reiserfs_get_journal_block(p_s_sb) + le32_to_cpu(jh->j_first_unflushed_offset)) ; + d_bh = sb_bread(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + le32_to_cpu(jh->j_first_unflushed_offset)) ; ret = journal_transaction_is_valid(p_s_sb, d_bh, NULL, NULL) ; if (!ret) { continue_replay = 0 ; @@ -1696,35 +1698,35 @@ /* ok, there are transactions that need to be replayed. start with the first log block, find ** all the valid transactions, and pick out the oldest. */ - while(continue_replay && cur_dblock < (reiserfs_get_journal_block(p_s_sb) + JOURNAL_BLOCK_COUNT)) { + while(continue_replay && cur_dblock < (SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL_SIZE(p_s_sb))) { d_bh = reiserfs_breada(p_s_sb->s_dev, cur_dblock, p_s_sb->s_blocksize, - reiserfs_get_journal_block(p_s_sb) + JOURNAL_BLOCK_COUNT) ; + SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL_SIZE(p_s_sb)) ; ret = journal_transaction_is_valid(p_s_sb, d_bh, &oldest_invalid_trans_id, &newest_mount_id) ; if (ret == 1) { desc = (struct reiserfs_journal_desc *)d_bh->b_data ; if (oldest_start == 0) { /* init all oldest_ values */ - oldest_trans_id = le32_to_cpu(desc->j_trans_id) ; + oldest_trans_id = get_desc_trans_id(desc) ; oldest_start = d_bh->b_blocknr ; - newest_mount_id = le32_to_cpu(desc->j_mount_id) ; + newest_mount_id = get_desc_mount_id(desc) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1179: Setting " "oldest_start to offset %lu, trans_id %lu\n", - oldest_start - reiserfs_get_journal_block(p_s_sb), + oldest_start - SB_JOURNAL_BLOCK(p_s_sb), oldest_trans_id) ; - } else if (oldest_trans_id > le32_to_cpu(desc->j_trans_id)) { + } else if (oldest_trans_id > get_desc_trans_id(desc)) { /* one we just read was older */ - oldest_trans_id = le32_to_cpu(desc->j_trans_id) ; + oldest_trans_id = get_desc_trans_id(desc) ; oldest_start = d_bh->b_blocknr ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1180: Resetting " "oldest_start to offset %lu, trans_id %lu\n", - oldest_start - reiserfs_get_journal_block(p_s_sb), + oldest_start - SB_JOURNAL_BLOCK(p_s_sb), oldest_trans_id) ; } - if (newest_mount_id < le32_to_cpu(desc->j_mount_id)) { - newest_mount_id = le32_to_cpu(desc->j_mount_id) ; + if (newest_mount_id < get_desc_mount_id(desc)) { + newest_mount_id = get_desc_mount_id(desc) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1299: Setting " - "newest_mount_id to %d\n", le32_to_cpu(desc->j_mount_id)); + "newest_mount_id to %d\n", get_desc_mount_id(desc)); } - cur_dblock += le32_to_cpu(desc->j_len) + 2 ; + cur_dblock += get_desc_trans_len(desc) + 2 ; } else { cur_dblock++ ; @@ -1740,7 +1742,7 @@ if (oldest_trans_id) { reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1206: Starting replay " "from offset %lu, trans_id %lu\n", - cur_dblock - reiserfs_get_journal_block(p_s_sb), + cur_dblock - SB_JOURNAL_BLOCK(p_s_sb), oldest_trans_id) ; } @@ -1752,7 +1754,7 @@ } else if (ret != 0) { break ; } - cur_dblock = reiserfs_get_journal_block(p_s_sb) + SB_JOURNAL(p_s_sb)->j_start ; + cur_dblock = SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL(p_s_sb)->j_start ; replay_count++ ; if (cur_dblock == oldest_start) break; @@ -1901,23 +1903,34 @@ } } + +/* for blocksize >= 4096 - max transaction size is 1024. For block size < 4096 + - trans max size is decreased proportionally */ +static void set_trans_params (struct super_block * s) +{ + SB_JOURNAL_TRANS_MAX(s) = JOURNAL_TRANS_MAX_DEFAULT ; + SB_JOURNAL_MAX_BATCH(s) = JOURNAL_MAX_BATCH_DEFAULT ; + + if (s->s_blocksize < 4096) { + SB_JOURNAL_TRANS_MAX(s) /= (4096 / s->s_blocksize) ; + SB_JOURNAL_MAX_BATCH(s) = (SB_JOURNAL_TRANS_MAX(s)) * 9 / 10 ; + } +} + + /* ** must be called once on fs mount. calls journal_read for you */ int journal_init(struct super_block *p_s_sb) { - int num_cnodes = JOURNAL_BLOCK_COUNT * 2 ; + int num_cnodes ; + + num_cnodes = SB_JOURNAL_SIZE(p_s_sb) * 2 ; - if (sizeof(struct reiserfs_journal_commit) != 4096 || - sizeof(struct reiserfs_journal_desc) != 4096 - ) { - printk("journal-1249: commit or desc struct not 4096 %Zd %Zd\n", sizeof(struct reiserfs_journal_commit), - sizeof(struct reiserfs_journal_desc)) ; - return 1 ; - } /* sanity check to make sure they don't overflow the journal */ - if (JOURNAL_BLOCK_COUNT > reiserfs_get_journal_orig_size(p_s_sb)) { - printk("journal-1393: current JOURNAL_BLOCK_COUNT (%d) is too big. This FS was created with a journal size of %lu blocks\n", - JOURNAL_BLOCK_COUNT, reiserfs_get_journal_orig_size(p_s_sb)) ; + if (SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL_SIZE(p_s_sb) > p_s_sb->s_blocksize * 8) { + printk("journal-1393: journal does not fit for area addressed by first of bitmap blocks. " + "It starts at %u and its size is %u. Block size %ld\n", + SB_JOURNAL_BLOCK(p_s_sb), SB_JOURNAL_SIZE(p_s_sb), p_s_sb->s_blocksize) ; return 1 ; } SB_JOURNAL(p_s_sb) = vmalloc(sizeof (struct reiserfs_journal)) ; @@ -1965,6 +1978,10 @@ SB_JOURNAL(p_s_sb)->j_cnode_free = SB_JOURNAL(p_s_sb)->j_cnode_free_list ? num_cnodes : 0 ; SB_JOURNAL(p_s_sb)->j_cnode_used = 0 ; SB_JOURNAL(p_s_sb)->j_must_wait = 0 ; + + /* adjust max trans size and max trans batch */ + set_trans_params (p_s_sb); + init_journal_hash(p_s_sb) ; SB_JOURNAL_LIST(p_s_sb)[0].j_list_bitmap = get_list_bitmap(p_s_sb, SB_JOURNAL_LIST(p_s_sb)) ; if (!(SB_JOURNAL_LIST(p_s_sb)[0].j_list_bitmap)) { @@ -2002,10 +2019,10 @@ if (reiserfs_dont_log(th->t_super)) return 0 ; if ( SB_JOURNAL(th->t_super)->j_must_wait > 0 || - (SB_JOURNAL(th->t_super)->j_len_alloc + new_alloc) >= JOURNAL_MAX_BATCH || + (SB_JOURNAL(th->t_super)->j_len_alloc + new_alloc) >= SB_JOURNAL_MAX_BATCH(th->t_super) || atomic_read(&(SB_JOURNAL(th->t_super)->j_jlock)) || (now - SB_JOURNAL(th->t_super)->j_trans_start_time) > JOURNAL_MAX_TRANS_AGE || - SB_JOURNAL(th->t_super)->j_cnode_free < (JOURNAL_TRANS_MAX * 3)) { + SB_JOURNAL(th->t_super)->j_cnode_free < (SB_JOURNAL_TRANS_MAX(th->t_super) * 3)) { return 1 ; } return 0 ; @@ -2074,11 +2091,11 @@ if ( (!join && SB_JOURNAL(p_s_sb)->j_must_wait > 0) || - ( !join && (SB_JOURNAL(p_s_sb)->j_len_alloc + nblocks + 2) >= JOURNAL_MAX_BATCH) || + ( !join && (SB_JOURNAL(p_s_sb)->j_len_alloc + nblocks + 2) >= SB_JOURNAL_MAX_BATCH(p_s_sb)) || (!join && atomic_read(&(SB_JOURNAL(p_s_sb)->j_wcount)) > 0 && SB_JOURNAL(p_s_sb)->j_trans_start_time > 0 && (now - SB_JOURNAL(p_s_sb)->j_trans_start_time) > JOURNAL_MAX_TRANS_AGE) || (!join && atomic_read(&(SB_JOURNAL(p_s_sb)->j_jlock)) ) || - (!join && SB_JOURNAL(p_s_sb)->j_cnode_free < (JOURNAL_TRANS_MAX * 3))) { + (!join && SB_JOURNAL(p_s_sb)->j_cnode_free < (SB_JOURNAL_TRANS_MAX(p_s_sb) * 3))) { unlock_journal(p_s_sb) ; /* allow others to finish this transaction */ @@ -2188,7 +2205,7 @@ /* this error means I've screwed up, and we've overflowed the transaction. ** Nothing can be done here, except make the FS readonly or panic. */ - if (SB_JOURNAL(p_s_sb)->j_len >= JOURNAL_TRANS_MAX) { + if (SB_JOURNAL(p_s_sb)->j_len >= SB_JOURNAL_TRANS_MAX(p_s_sb)) { reiserfs_panic(th->t_super, "journal-1413: journal_mark_dirty: j_len (%lu) is too big\n", SB_JOURNAL(p_s_sb)->j_len) ; } @@ -2544,14 +2561,14 @@ /* don't batch when someone is waiting on j_join_wait */ /* don't batch when syncing the commit or flushing the whole trans */ if (!(SB_JOURNAL(p_s_sb)->j_must_wait > 0) && !(atomic_read(&(SB_JOURNAL(p_s_sb)->j_jlock))) && !flush && !commit_now && - (SB_JOURNAL(p_s_sb)->j_len < JOURNAL_MAX_BATCH) && - SB_JOURNAL(p_s_sb)->j_len_alloc < JOURNAL_MAX_BATCH && SB_JOURNAL(p_s_sb)->j_cnode_free > (JOURNAL_TRANS_MAX * 3)) { + (SB_JOURNAL(p_s_sb)->j_len < SB_JOURNAL_MAX_BATCH(p_s_sb)) && + SB_JOURNAL(p_s_sb)->j_len_alloc < SB_JOURNAL_MAX_BATCH(p_s_sb) && SB_JOURNAL(p_s_sb)->j_cnode_free > (SB_JOURNAL_TRANS_MAX(p_s_sb) * 3)) { SB_JOURNAL(p_s_sb)->j_bcount++ ; unlock_journal(p_s_sb) ; return 0 ; } - if (SB_JOURNAL(p_s_sb)->j_start > JOURNAL_BLOCK_COUNT) { + if (SB_JOURNAL(p_s_sb)->j_start > SB_JOURNAL_SIZE(p_s_sb)) { reiserfs_panic(p_s_sb, "journal-003: journal_end: j_start (%ld) is too high\n", SB_JOURNAL(p_s_sb)->j_start) ; } return 1 ; @@ -2749,6 +2766,7 @@ int commit_now = flags & COMMIT_NOW ; int wait_on_commit = flags & WAIT ; struct reiserfs_super_block *rs ; + int trans_half ; if (reiserfs_dont_log(th->t_super)) { return 0 ; @@ -2793,19 +2811,20 @@ rs = SB_DISK_SUPER_BLOCK(p_s_sb) ; /* setup description block */ - d_bh = sb_getblk(p_s_sb, reiserfs_get_journal_block(p_s_sb) + SB_JOURNAL(p_s_sb)->j_start) ; + d_bh = sb_getblk(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL(p_s_sb)->j_start) ; mark_buffer_uptodate(d_bh, 1) ; desc = (struct reiserfs_journal_desc *)(d_bh)->b_data ; - memset(desc, 0, sizeof(struct reiserfs_journal_desc)) ; - memcpy(desc->j_magic, JOURNAL_DESC_MAGIC, 8) ; - desc->j_trans_id = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_trans_id) ; + memset(d_bh->b_data, 0, d_bh->b_size) ; + memcpy(get_journal_desc_magic (d_bh), JOURNAL_DESC_MAGIC, 8) ; + set_desc_trans_id(desc, SB_JOURNAL(p_s_sb)->j_trans_id) ; + mark_buffer_uptodate(d_bh, 1) ; /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */ - c_bh = sb_getblk(p_s_sb, reiserfs_get_journal_block(p_s_sb) + - ((SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL(p_s_sb)->j_len + 1) % JOURNAL_BLOCK_COUNT)) ; + c_bh = sb_getblk(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + + ((SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL(p_s_sb)->j_len + 1) % SB_JOURNAL_SIZE(p_s_sb))) ; commit = (struct reiserfs_journal_commit *)c_bh->b_data ; - memset(commit, 0, sizeof(struct reiserfs_journal_commit)) ; - commit->j_trans_id = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_trans_id) ; + memset(c_bh->b_data, 0, c_bh->b_size) ; + set_commit_trans_id(commit, SB_JOURNAL(p_s_sb)->j_trans_id) ; mark_buffer_uptodate(c_bh, 1) ; /* init this journal list */ @@ -2830,6 +2849,7 @@ /* for each real block, add it to the journal list hash, ** copy into real block index array in the commit or desc block */ + trans_half = journal_trans_half(p_s_sb->s_blocksize) ; for (i = 0, cn = SB_JOURNAL(p_s_sb)->j_first ; cn ; cn = cn->next, i++) { if (test_bit(BH_JDirty, &cn->bh->b_state) ) { jl_cn = get_cnode(p_s_sb) ; @@ -2845,8 +2865,8 @@ last_cn->next = jl_cn ; } last_cn = jl_cn ; - if (cn->bh->b_blocknr >= reiserfs_get_journal_block(p_s_sb) && - cn->bh->b_blocknr < (reiserfs_get_journal_block(p_s_sb) + JOURNAL_BLOCK_COUNT)) { + if (cn->bh->b_blocknr >= SB_JOURNAL_BLOCK(p_s_sb) && + cn->bh->b_blocknr < (SB_JOURNAL_BLOCK(p_s_sb) + SB_JOURNAL_SIZE(p_s_sb))) { reiserfs_panic(p_s_sb, "journal-2332: Trying to log block %lu, which is a log block\n", cn->bh->b_blocknr) ; } jl_cn->blocknr = cn->bh->b_blocknr ; @@ -2855,27 +2875,27 @@ jl_cn->bh = cn->bh ; jl_cn->jlist = SB_JOURNAL_LIST(p_s_sb) + SB_JOURNAL_LIST_INDEX(p_s_sb) ; insert_journal_hash(SB_JOURNAL(p_s_sb)->j_list_hash_table, jl_cn) ; - if (i < JOURNAL_TRANS_HALF) { + if (i < trans_half) { desc->j_realblock[i] = cpu_to_le32(cn->bh->b_blocknr) ; } else { - commit->j_realblock[i - JOURNAL_TRANS_HALF] = cpu_to_le32(cn->bh->b_blocknr) ; + commit->j_realblock[i - trans_half] = cpu_to_le32(cn->bh->b_blocknr) ; } } else { i-- ; } } - - desc->j_len = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_len) ; - desc->j_mount_id = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_mount_id) ; - desc->j_trans_id = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_trans_id) ; - commit->j_len = cpu_to_le32(SB_JOURNAL(p_s_sb)->j_len) ; + + set_desc_trans_len(desc, SB_JOURNAL(p_s_sb)->j_len) ; + set_desc_mount_id(desc, SB_JOURNAL(p_s_sb)->j_mount_id) ; + set_desc_trans_id(desc, SB_JOURNAL(p_s_sb)->j_trans_id) ; + set_commit_trans_len(commit, SB_JOURNAL(p_s_sb)->j_len); /* special check in case all buffers in the journal were marked for not logging */ if (SB_JOURNAL(p_s_sb)->j_len == 0) { brelse(d_bh) ; brelse(c_bh) ; unlock_journal(p_s_sb) ; -printk("journal-2020: do_journal_end: BAD desc->j_len is ZERO\n") ; + printk("journal-2020: do_journal_end: BAD desc->j_len is ZERO\n") ; atomic_set(&(SB_JOURNAL(p_s_sb)->j_jlock), 0) ; wake_up(&(SB_JOURNAL(p_s_sb)->j_join_wait)) ; return 0 ; @@ -2890,8 +2910,8 @@ /* copy all the real blocks into log area. dirty log blocks */ if (test_bit(BH_JDirty, &cn->bh->b_state)) { struct buffer_head *tmp_bh ; - tmp_bh = sb_getblk(p_s_sb, reiserfs_get_journal_block(p_s_sb) + - ((cur_write_start + jindex) % JOURNAL_BLOCK_COUNT)) ; + tmp_bh = sb_getblk(p_s_sb, SB_JOURNAL_BLOCK(p_s_sb) + + ((cur_write_start + jindex) % SB_JOURNAL_SIZE(p_s_sb))) ; mark_buffer_uptodate(tmp_bh, 1) ; memcpy(tmp_bh->b_data, cn->bh->b_data, cn->bh->b_size) ; jindex++ ; @@ -2952,7 +2972,7 @@ /* reset journal values for the next transaction */ old_start = SB_JOURNAL(p_s_sb)->j_start ; - SB_JOURNAL(p_s_sb)->j_start = (SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL(p_s_sb)->j_len + 2) % JOURNAL_BLOCK_COUNT; + SB_JOURNAL(p_s_sb)->j_start = (SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL(p_s_sb)->j_len + 2) % SB_JOURNAL_SIZE(p_s_sb); atomic_set(&(SB_JOURNAL(p_s_sb)->j_wcount), 0) ; SB_JOURNAL(p_s_sb)->j_bcount = 0 ; SB_JOURNAL(p_s_sb)->j_last = NULL ; @@ -2973,12 +2993,12 @@ for (i = 0 ; i < JOURNAL_LIST_COUNT ; i++) { jindex = i ; if (SB_JOURNAL_LIST(p_s_sb)[jindex].j_len > 0 && SB_JOURNAL(p_s_sb)->j_start <= SB_JOURNAL_LIST(p_s_sb)[jindex].j_start) { - if ((SB_JOURNAL(p_s_sb)->j_start + JOURNAL_TRANS_MAX + 1) >= SB_JOURNAL_LIST(p_s_sb)[jindex].j_start) { + if ((SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL_TRANS_MAX(p_s_sb) + 1) >= SB_JOURNAL_LIST(p_s_sb)[jindex].j_start) { flush_journal_list(p_s_sb, SB_JOURNAL_LIST(p_s_sb) + jindex, 1) ; } } else if (SB_JOURNAL_LIST(p_s_sb)[jindex].j_len > 0 && - (SB_JOURNAL(p_s_sb)->j_start + JOURNAL_TRANS_MAX + 1) > JOURNAL_BLOCK_COUNT) { - if (((SB_JOURNAL(p_s_sb)->j_start + JOURNAL_TRANS_MAX + 1) % JOURNAL_BLOCK_COUNT) >= + (SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL_TRANS_MAX(p_s_sb) + 1) > SB_JOURNAL_SIZE(p_s_sb)) { + if (((SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL_TRANS_MAX(p_s_sb) + 1) % SB_JOURNAL_SIZE(p_s_sb)) >= SB_JOURNAL_LIST(p_s_sb)[jindex].j_start) { flush_journal_list(p_s_sb, SB_JOURNAL_LIST(p_s_sb) + jindex, 1 ) ; } diff -uNr linux-2.4.18.o1/fs/reiserfs/prints.c linux-2.4.18.o/fs/reiserfs/prints.c --- linux-2.4.18.o1/fs/reiserfs/prints.c Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/fs/reiserfs/prints.c Thu Feb 28 18:48:51 2002 @@ -541,12 +541,13 @@ { struct reiserfs_journal_desc * desc; - desc = (struct reiserfs_journal_desc *)(bh->b_data); - if (memcmp(desc->j_magic, JOURNAL_DESC_MAGIC, 8)) + if (memcmp(get_journal_desc_magic (bh), JOURNAL_DESC_MAGIC, 8)) return 1; + desc = (struct reiserfs_journal_desc *)(bh->b_data); printk ("Desc block %lu (j_trans_id %d, j_mount_id %d, j_len %d)", - bh->b_blocknr, desc->j_trans_id, desc->j_mount_id, desc->j_len); + bh->b_blocknr, get_desc_trans_id (desc), get_desc_mount_id (desc), + get_desc_trans_len (desc)); return 0; } diff -uNr linux-2.4.18.o1/fs/reiserfs/super.c linux-2.4.18.o/fs/reiserfs/super.c --- linux-2.4.18.o1/fs/reiserfs/super.c Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/fs/reiserfs/super.c Thu Feb 28 18:48:51 2002 @@ -20,9 +20,6 @@ #include #include -#define REISERFS_OLD_BLOCKSIZE 4096 -#define REISERFS_SUPER_MAGIC_STRING_OFFSET_NJ 20 - char reiserfs_super_magic_string[] = REISERFS_SUPER_MAGIC_STRING; char reiser2fs_super_magic_string[] = REISER2FS_SUPER_MAGIC_STRING; @@ -422,7 +419,7 @@ }; -/* this was (ext2)parse_options */ + static int parse_options (char * options, unsigned long * mount_options, unsigned long * blocks) { char * this_char; @@ -703,6 +700,14 @@ // // ok, reiserfs signature (old or new) found in at the given offset // + if ( sb_blocksize(rs) > PAGE_SIZE ) { + printk("reiserfs: Filesystem on device %s has a blocksize of %d bytes " + "which is bigger than page size. Currently you cannot mount " + "such filesystems in Linux\n", + kdevname(s->s_dev), sb_blocksize(rs)); + brelse (bh); + return 1; + } s->s_blocksize = sb_blocksize(rs); s->s_blocksize_bits = 0; while ((1 << s->s_blocksize_bits) != s->s_blocksize) @@ -737,7 +742,7 @@ ** journal for that super, it can't be valid. */ if (bh->b_blocknr >= sb_journal_block(rs) && - bh->b_blocknr < (sb_journal_block(rs) + JOURNAL_BLOCK_COUNT)) { + bh->b_blocknr < (sb_journal_block(rs) + SB_JOURNAL_SIZE(s))) { brelse(bh) ; printk("super-459: read_super_block: " "super found at block %lu is within its own log. " diff -uNr linux-2.4.18.o1/include/linux/reiserfs_fs.h linux-2.4.18.o/include/linux/reiserfs_fs.h --- linux-2.4.18.o1/include/linux/reiserfs_fs.h Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/include/linux/reiserfs_fs.h Thu Feb 28 18:48:51 2002 @@ -1465,29 +1465,43 @@ /***************************************************************************/ /*#ifdef __KERNEL__*/ +#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12) -/* journal.c see journal.c for all the comments here */ - -#define JOURNAL_TRANS_HALF 1018 /* must be correct to keep the desc and commit structs at 4k */ +#define journal_trans_half(blocksize) \ + ((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32)) +/* journal.c see journal.c for all the comments here */ /* first block written in a commit. */ struct reiserfs_journal_desc { __u32 j_trans_id ; /* id of commit */ __u32 j_len ; /* length of commit. len +1 is the commit block */ __u32 j_mount_id ; /* mount id of this trans*/ - __u32 j_realblock[JOURNAL_TRANS_HALF] ; /* real locations for each block */ - char j_magic[12] ; + __u32 j_realblock[1] ; /* real locations for each block */ } ; +#define get_desc_trans_id(d) le32_to_cpu((d)->j_trans_id) +#define get_desc_trans_len(d) le32_to_cpu((d)->j_len) +#define get_desc_mount_id(d) le32_to_cpu((d)->j_mount_id) + +#define set_desc_trans_id(d,val) do { (d)->j_trans_id = cpu_to_le32 (val); } while (0) +#define set_desc_trans_len(d,val) do { (d)->j_len = cpu_to_le32 (val); } while (0) +#define set_desc_mount_id(d,val) do { (d)->j_mount_id = cpu_to_le32 (val); } while (0) + /* last block written in a commit */ struct reiserfs_journal_commit { __u32 j_trans_id ; /* must match j_trans_id from the desc block */ __u32 j_len ; /* ditto */ - __u32 j_realblock[JOURNAL_TRANS_HALF] ; /* real locations for each block */ - char j_digest[16] ; /* md5 sum of all the blocks involved, including desc and commit. not used, kill it */ + __u32 j_realblock[1] ; /* real locations for each block */ } ; +#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id) +#define get_commit_trans_len(c) le32_to_cpu((c)->j_len) +#define get_commit_mount_id(c) le32_to_cpu((c)->j_mount_id) + +#define set_commit_trans_id(c,val) do { (c)->j_trans_id = cpu_to_le32 (val); } while (0) +#define set_commit_trans_len(c,val) do { (c)->j_len = cpu_to_le32 (val); } while (0) + /* this header block gets written whenever a transaction is considered fully flushed, and is more recent than the ** last fully flushed transaction. fully flushed means all the log blocks and all the real blocks are on disk, ** and this transaction does not need to be replayed. @@ -1502,8 +1516,8 @@ extern wait_queue_head_t reiserfs_commit_thread_wait ; /* biggest tunable defines are right here */ -#define JOURNAL_BLOCK_COUNT 8192 /* number of blocks in the journal */ -#define JOURNAL_MAX_BATCH 900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */ +#define JOURNAL_TRANS_MAX_DEFAULT 1024 /* biggest possible single transaction, don't change for now (8/3/99) */ +#define JOURNAL_MAX_BATCH_DEFAULT 900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */ #define JOURNAL_MAX_COMMIT_AGE 30 #define JOURNAL_MAX_TRANS_AGE 30 #define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9) diff -uNr linux-2.4.18.o1/include/linux/reiserfs_fs_sb.h linux-2.4.18.o/include/linux/reiserfs_fs_sb.h --- linux-2.4.18.o1/include/linux/reiserfs_fs_sb.h Thu Feb 28 18:52:05 2002 +++ linux-2.4.18.o/include/linux/reiserfs_fs_sb.h Thu Feb 28 18:48:51 2002 @@ -180,7 +180,6 @@ /* we have a node size define somewhere in reiserfs_fs.h. -Hans */ #define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */ #define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */ -#define JOURNAL_TRANS_MAX 1024 /* biggest possible single transaction, don't change for now (8/3/99) */ #define JOURNAL_HASH_SIZE 8192 #define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating. Must be >= 2 */ #define JOURNAL_LIST_COUNT 64 @@ -317,6 +316,8 @@ struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for all the real buffer heads in all the transactions */ struct list_head j_prealloc_list; /* list of inodes which have preallocated blocks */ + unsigned long j_max_trans_size ; + unsigned long j_max_batch_size ; }; #define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick. magic string to find desc blocks in the journal */ @@ -523,6 +524,8 @@ #define SB_JOURNAL_LIST(s) (SB_JOURNAL(s)->j_journal_list) #define SB_JOURNAL_LIST_INDEX(s) (SB_JOURNAL(s)->j_journal_list_index) #define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) +#define SB_JOURNAL_TRANS_MAX(s) (SB_JOURNAL(s)->j_max_trans_size) +#define SB_JOURNAL_MAX_BATCH(s) (SB_JOURNAL(s)->j_max_batch_size) #define SB_AP_BITMAP(s) ((s)->u.reiserfs_sb.s_ap_bitmap) @@ -536,6 +539,8 @@ #define SB_REISERFS_STATE(s) sb_state (SB_DISK_SUPER_BLOCK(s)) #define SB_VERSION(s) sb_version (SB_DISK_SUPER_BLOCK(s)) #define SB_BMAP_NR(s) sb_bmap_nr(SB_DISK_SUPER_BLOCK(s)) +#define SB_JOURNAL_SIZE(s) le16_to_cpu ((SB_DISK_SUPER_BLOCK(s)->s_orig_journal_size)) +#define SB_JOURNAL_BLOCK(s) le16_to_cpu ((SB_DISK_SUPER_BLOCK(s)->s_journal_block)) #define PUT_SB_BLOCK_COUNT(s, val) do { set_sb_block_count( SB_DISK_SUPER_BLOCK(s), val); } while (0) #define PUT_SB_FREE_BLOCKS(s, val) do { set_sb_free_blocks( SB_DISK_SUPER_BLOCK(s), val); } while (0)