diff -uNr linux-2.5.6.1/fs/reiserfs/bitmap.c linux-2.5.6/fs/reiserfs/bitmap.c --- linux-2.5.6.1/fs/reiserfs/bitmap.c Wed Mar 13 12:06:49 2002 +++ linux-2.5.6/fs/reiserfs/bitmap.c Wed Mar 13 11:52:23 2002 @@ -526,7 +526,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.5.6.1/fs/reiserfs/inode.c linux-2.5.6/fs/reiserfs/inode.c --- linux-2.5.6.1/fs/reiserfs/inode.c Wed Mar 13 12:06:49 2002 +++ linux-2.5.6/fs/reiserfs/inode.c Wed Mar 13 11:52:23 2002 @@ -1927,14 +1927,21 @@ static inline void submit_bh_for_writepage(struct buffer_head **bhp, int nr) { struct buffer_head *bh ; int i; + + /* lock them all first so the end_io handler doesn't unlock the page + ** too early + */ for(i = 0 ; i < nr ; i++) { bh = bhp[i] ; lock_buffer(bh) ; set_buffer_async_io(bh) ; + } + for(i = 0 ; i < nr ; i++) { /* submit_bh doesn't care if the buffer is dirty, but nobody ** later on in the call chain will be cleaning it. So, we ** clean the buffer here, it still gets written either way. */ + bh = bhp[i] ; clear_bit(BH_Dirty, &bh->b_state) ; set_bit(BH_Uptodate, &bh->b_state) ; submit_bh(WRITE, bh) ; diff -uNr linux-2.5.6.1/fs/reiserfs/journal.c linux-2.5.6/fs/reiserfs/journal.c --- linux-2.5.6.1/fs/reiserfs/journal.c Wed Mar 13 12:06:49 2002 +++ linux-2.5.6/fs/reiserfs/journal.c Wed Mar 13 12:02:40 2002 @@ -1369,10 +1369,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) > SB_JOURNAL_TRANS_MAX(p_s_sb) || - 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 ; } @@ -1392,18 +1392,18 @@ 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 ; } @@ -1411,7 +1411,7 @@ /* ok, we have a journal description block, lets see if the transaction was valid */ c_bh = bread(SB_JOURNAL_DEV(p_s_sb), SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + - ((offset + le32_to_cpu(desc->j_len) + 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)), + ((offset + get_desc_trans_len(desc) + 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)), p_s_sb->s_blocksize) ; if (!c_bh) return 0 ; @@ -1421,21 +1421,21 @@ "journal_transaction_is_valid, commit offset %ld had bad " "time %d or length %d\n", c_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), - le32_to_cpu(commit->j_trans_id), - le32_to_cpu(commit->j_len)); + 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 - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), - le32_to_cpu(desc->j_len), le32_to_cpu(desc->j_trans_id)) ; + get_desc_trans_len(desc), get_desc_trans_id(desc)) ; return 1 ; } else { return 0 ; @@ -1465,6 +1465,7 @@ struct buffer_head **real_blocks = NULL ; unsigned long trans_offset ; int i; + int trans_half; d_bh = bread(SB_JOURNAL_DEV(p_s_sb), cur_dblock, p_s_sb->s_blocksize) ; if (!d_bh) @@ -1474,24 +1475,24 @@ 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 - SB_ONDISK_JOURNAL_1st_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) { + 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 - SB_ONDISK_JOURNAL_1st_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 = bread(SB_JOURNAL_DEV(p_s_sb), SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + - ((trans_offset + le32_to_cpu(desc->j_len) + 1) % + ((trans_offset + get_desc_trans_len(desc) + 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)), p_s_sb->s_blocksize) ; if (!c_bh) { brelse(d_bh) ; @@ -1502,30 +1503,31 @@ reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal_read_transaction, " "commit offset %ld had bad time %d or length %d\n", c_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), - le32_to_cpu(commit->j_trans_id), le32_to_cpu(commit->j_len)); + get_commit_trans_id(commit), get_commit_trans_len(commit)); brelse(c_bh) ; brelse(d_bh) ; return 1; } - trans_id = le32_to_cpu(desc->j_trans_id) ; + trans_id = get_desc_trans_id(desc) ; /* 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++) { + trans_half = journal_trans_half (p_s_sb->s_blocksize) ; + for(i = 0 ; i < get_desc_trans_len(desc) ; i++) { log_blocks[i] = getblk(SB_JOURNAL_DEV(p_s_sb), SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + (trans_offset + 1 + i) % SB_ONDISK_JOURNAL_SIZE(p_s_sb), p_s_sb->s_blocksize); - if (i < JOURNAL_TRANS_HALF) { + 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])) ; } /* make sure we don't try to replay onto log or reserved area */ if (is_block_in_log_or_reserved_area(p_s_sb, real_blocks[i]->b_blocknr)) { @@ -1534,23 +1536,23 @@ 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_id(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) ; @@ -1558,24 +1560,24 @@ 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 = SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + ((trans_offset + le32_to_cpu(desc->j_len) + 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)) ; + cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + ((trans_offset + get_desc_trans_len(desc) + 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)) ; reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1095: setting journal " "start to offset %ld\n", cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb)) ; @@ -1586,8 +1588,8 @@ 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 ; } @@ -1711,28 +1713,28 @@ 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 - SB_ONDISK_JOURNAL_1st_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 - SB_ONDISK_JOURNAL_1st_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++ ; @@ -1993,6 +1995,18 @@ return result; } +/* 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 */ @@ -2003,14 +2017,6 @@ struct reiserfs_journal_header *jh; struct reiserfs_journal *journal; - 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 ; - } - journal = SB_JOURNAL(p_s_sb) = vmalloc(sizeof (struct reiserfs_journal)) ; if (!journal) { printk("journal-1256: unable to get memory for journal structure\n") ; @@ -2149,6 +2155,8 @@ 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)) { @@ -2928,6 +2936,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 ; @@ -2973,19 +2982,19 @@ rs = SB_DISK_SUPER_BLOCK(p_s_sb) ; /* setup description block */ d_bh = getblk(SB_JOURNAL_DEV(p_s_sb), SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + SB_JOURNAL(p_s_sb)->j_start, p_s_sb->s_blocksize) ; - 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 = getblk(SB_JOURNAL_DEV(p_s_sb), SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + ((SB_JOURNAL(p_s_sb)->j_start + SB_JOURNAL(p_s_sb)->j_len + 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)), p_s_sb->s_blocksize) ; 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 */ @@ -3010,6 +3019,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) ; @@ -3037,27 +3047,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 ; diff -uNr linux-2.5.6.1/fs/reiserfs/prints.c linux-2.5.6/fs/reiserfs/prints.c --- linux-2.5.6.1/fs/reiserfs/prints.c Tue Mar 12 15:25:21 2002 +++ linux-2.5.6/fs/reiserfs/prints.c Wed Mar 13 11:52:23 2002 @@ -540,12 +540,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.5.6.1/fs/reiserfs/super.c linux-2.5.6/fs/reiserfs/super.c --- linux-2.5.6.1/fs/reiserfs/super.c Tue Mar 12 15:25:27 2002 +++ linux-2.5.6/fs/reiserfs/super.c Wed Mar 13 11:52:23 2002 @@ -21,9 +21,6 @@ #include #include -#define REISERFS_OLD_BLOCKSIZE 4096 -#define REISERFS_SUPER_MAGIC_STRING_OFFSET_NJ 20 - const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING; const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING; const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING; @@ -497,7 +494,7 @@ }; -/* this was (ext2)parse_options */ + static int parse_options (char * options, unsigned long * mount_options, unsigned long * blocks, char **jdev_name) { char * this_char; diff -uNr linux-2.5.6.1/include/linux/reiserfs_fs.h linux-2.5.6/include/linux/reiserfs_fs.h --- linux-2.5.6.1/include/linux/reiserfs_fs.h Wed Mar 13 10:57:48 2002 +++ linux-2.5.6/include/linux/reiserfs_fs.h Wed Mar 13 11:52:23 2002 @@ -1566,28 +1566,42 @@ /***************************************************************************/ /*#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,