aboutsummaryrefslogtreecommitdiffstats
path: root/fs/reiserfs/journal.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/reiserfs/journal.c')
-rw-r--r--fs/reiserfs/journal.c1077
1 files changed, 537 insertions, 540 deletions
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 9643c3bbeb3b..77f5bb746bf0 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -1,36 +1,36 @@
1/* 1/*
2** Write ahead logging implementation copyright Chris Mason 2000 2** Write ahead logging implementation copyright Chris Mason 2000
3** 3**
4** The background commits make this code very interelated, and 4** The background commits make this code very interelated, and
5** overly complex. I need to rethink things a bit....The major players: 5** overly complex. I need to rethink things a bit....The major players:
6** 6**
7** journal_begin -- call with the number of blocks you expect to log. 7** journal_begin -- call with the number of blocks you expect to log.
8** If the current transaction is too 8** If the current transaction is too
9** old, it will block until the current transaction is 9** old, it will block until the current transaction is
10** finished, and then start a new one. 10** finished, and then start a new one.
11** Usually, your transaction will get joined in with 11** Usually, your transaction will get joined in with
12** previous ones for speed. 12** previous ones for speed.
13** 13**
14** journal_join -- same as journal_begin, but won't block on the current 14** journal_join -- same as journal_begin, but won't block on the current
15** transaction regardless of age. Don't ever call 15** transaction regardless of age. Don't ever call
16** this. Ever. There are only two places it should be 16** this. Ever. There are only two places it should be
17** called from, and they are both inside this file. 17** called from, and they are both inside this file.
18** 18**
19** journal_mark_dirty -- adds blocks into this transaction. clears any flags 19** journal_mark_dirty -- adds blocks into this transaction. clears any flags
20** that might make them get sent to disk 20** that might make them get sent to disk
21** and then marks them BH_JDirty. Puts the buffer head 21** and then marks them BH_JDirty. Puts the buffer head
22** into the current transaction hash. 22** into the current transaction hash.
23** 23**
24** journal_end -- if the current transaction is batchable, it does nothing 24** journal_end -- if the current transaction is batchable, it does nothing
25** otherwise, it could do an async/synchronous commit, or 25** otherwise, it could do an async/synchronous commit, or
26** a full flush of all log and real blocks in the 26** a full flush of all log and real blocks in the
27** transaction. 27** transaction.
28** 28**
29** flush_old_commits -- if the current transaction is too old, it is ended and 29** flush_old_commits -- if the current transaction is too old, it is ended and
30** commit blocks are sent to disk. Forces commit blocks 30** commit blocks are sent to disk. Forces commit blocks
31** to disk for all backgrounded commits that have been 31** to disk for all backgrounded commits that have been
32** around too long. 32** around too long.
33** -- Note, if you call this as an immediate flush from 33** -- Note, if you call this as an immediate flush from
34** from within kupdate, it will ignore the immediate flag 34** from within kupdate, it will ignore the immediate flag
35*/ 35*/
36 36
@@ -97,7 +97,7 @@ static int flush_commit_list(struct super_block *s,
97 struct reiserfs_journal_list *jl, int flushall); 97 struct reiserfs_journal_list *jl, int flushall);
98static int can_dirty(struct reiserfs_journal_cnode *cn); 98static int can_dirty(struct reiserfs_journal_cnode *cn);
99static int journal_join(struct reiserfs_transaction_handle *th, 99static int journal_join(struct reiserfs_transaction_handle *th,
100 struct super_block *p_s_sb, unsigned long nblocks); 100 struct super_block *sb, unsigned long nblocks);
101static int release_journal_dev(struct super_block *super, 101static int release_journal_dev(struct super_block *super,
102 struct reiserfs_journal *journal); 102 struct reiserfs_journal *journal);
103static int dirty_one_transaction(struct super_block *s, 103static int dirty_one_transaction(struct super_block *s,
@@ -113,12 +113,12 @@ enum {
113}; 113};
114 114
115static int do_journal_begin_r(struct reiserfs_transaction_handle *th, 115static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
116 struct super_block *p_s_sb, 116 struct super_block *sb,
117 unsigned long nblocks, int join); 117 unsigned long nblocks, int join);
118 118
119static void init_journal_hash(struct super_block *p_s_sb) 119static void init_journal_hash(struct super_block *sb)
120{ 120{
121 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 121 struct reiserfs_journal *journal = SB_JOURNAL(sb);
122 memset(journal->j_hash_table, 0, 122 memset(journal->j_hash_table, 0,
123 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *)); 123 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
124} 124}
@@ -145,7 +145,7 @@ static void disable_barrier(struct super_block *s)
145} 145}
146 146
147static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block 147static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
148 *p_s_sb) 148 *sb)
149{ 149{
150 struct reiserfs_bitmap_node *bn; 150 struct reiserfs_bitmap_node *bn;
151 static int id; 151 static int id;
@@ -154,7 +154,7 @@ static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
154 if (!bn) { 154 if (!bn) {
155 return NULL; 155 return NULL;
156 } 156 }
157 bn->data = kzalloc(p_s_sb->s_blocksize, GFP_NOFS); 157 bn->data = kzalloc(sb->s_blocksize, GFP_NOFS);
158 if (!bn->data) { 158 if (!bn->data) {
159 kfree(bn); 159 kfree(bn);
160 return NULL; 160 return NULL;
@@ -164,9 +164,9 @@ static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
164 return bn; 164 return bn;
165} 165}
166 166
167static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *p_s_sb) 167static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *sb)
168{ 168{
169 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 169 struct reiserfs_journal *journal = SB_JOURNAL(sb);
170 struct reiserfs_bitmap_node *bn = NULL; 170 struct reiserfs_bitmap_node *bn = NULL;
171 struct list_head *entry = journal->j_bitmap_nodes.next; 171 struct list_head *entry = journal->j_bitmap_nodes.next;
172 172
@@ -176,21 +176,21 @@ static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *p_s_sb)
176 if (entry != &journal->j_bitmap_nodes) { 176 if (entry != &journal->j_bitmap_nodes) {
177 bn = list_entry(entry, struct reiserfs_bitmap_node, list); 177 bn = list_entry(entry, struct reiserfs_bitmap_node, list);
178 list_del(entry); 178 list_del(entry);
179 memset(bn->data, 0, p_s_sb->s_blocksize); 179 memset(bn->data, 0, sb->s_blocksize);
180 journal->j_free_bitmap_nodes--; 180 journal->j_free_bitmap_nodes--;
181 return bn; 181 return bn;
182 } 182 }
183 bn = allocate_bitmap_node(p_s_sb); 183 bn = allocate_bitmap_node(sb);
184 if (!bn) { 184 if (!bn) {
185 yield(); 185 yield();
186 goto repeat; 186 goto repeat;
187 } 187 }
188 return bn; 188 return bn;
189} 189}
190static inline void free_bitmap_node(struct super_block *p_s_sb, 190static inline void free_bitmap_node(struct super_block *sb,
191 struct reiserfs_bitmap_node *bn) 191 struct reiserfs_bitmap_node *bn)
192{ 192{
193 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 193 struct reiserfs_journal *journal = SB_JOURNAL(sb);
194 journal->j_used_bitmap_nodes--; 194 journal->j_used_bitmap_nodes--;
195 if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) { 195 if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) {
196 kfree(bn->data); 196 kfree(bn->data);
@@ -201,46 +201,46 @@ static inline void free_bitmap_node(struct super_block *p_s_sb,
201 } 201 }
202} 202}
203 203
204static void allocate_bitmap_nodes(struct super_block *p_s_sb) 204static void allocate_bitmap_nodes(struct super_block *sb)
205{ 205{
206 int i; 206 int i;
207 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 207 struct reiserfs_journal *journal = SB_JOURNAL(sb);
208 struct reiserfs_bitmap_node *bn = NULL; 208 struct reiserfs_bitmap_node *bn = NULL;
209 for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) { 209 for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) {
210 bn = allocate_bitmap_node(p_s_sb); 210 bn = allocate_bitmap_node(sb);
211 if (bn) { 211 if (bn) {
212 list_add(&bn->list, &journal->j_bitmap_nodes); 212 list_add(&bn->list, &journal->j_bitmap_nodes);
213 journal->j_free_bitmap_nodes++; 213 journal->j_free_bitmap_nodes++;
214 } else { 214 } else {
215 break; // this is ok, we'll try again when more are needed 215 break; /* this is ok, we'll try again when more are needed */
216 } 216 }
217 } 217 }
218} 218}
219 219
220static int set_bit_in_list_bitmap(struct super_block *p_s_sb, 220static int set_bit_in_list_bitmap(struct super_block *sb,
221 b_blocknr_t block, 221 b_blocknr_t block,
222 struct reiserfs_list_bitmap *jb) 222 struct reiserfs_list_bitmap *jb)
223{ 223{
224 unsigned int bmap_nr = block / (p_s_sb->s_blocksize << 3); 224 unsigned int bmap_nr = block / (sb->s_blocksize << 3);
225 unsigned int bit_nr = block % (p_s_sb->s_blocksize << 3); 225 unsigned int bit_nr = block % (sb->s_blocksize << 3);
226 226
227 if (!jb->bitmaps[bmap_nr]) { 227 if (!jb->bitmaps[bmap_nr]) {
228 jb->bitmaps[bmap_nr] = get_bitmap_node(p_s_sb); 228 jb->bitmaps[bmap_nr] = get_bitmap_node(sb);
229 } 229 }
230 set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data); 230 set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data);
231 return 0; 231 return 0;
232} 232}
233 233
234static void cleanup_bitmap_list(struct super_block *p_s_sb, 234static void cleanup_bitmap_list(struct super_block *sb,
235 struct reiserfs_list_bitmap *jb) 235 struct reiserfs_list_bitmap *jb)
236{ 236{
237 int i; 237 int i;
238 if (jb->bitmaps == NULL) 238 if (jb->bitmaps == NULL)
239 return; 239 return;
240 240
241 for (i = 0; i < reiserfs_bmap_count(p_s_sb); i++) { 241 for (i = 0; i < reiserfs_bmap_count(sb); i++) {
242 if (jb->bitmaps[i]) { 242 if (jb->bitmaps[i]) {
243 free_bitmap_node(p_s_sb, jb->bitmaps[i]); 243 free_bitmap_node(sb, jb->bitmaps[i]);
244 jb->bitmaps[i] = NULL; 244 jb->bitmaps[i] = NULL;
245 } 245 }
246 } 246 }
@@ -249,7 +249,7 @@ static void cleanup_bitmap_list(struct super_block *p_s_sb,
249/* 249/*
250** only call this on FS unmount. 250** only call this on FS unmount.
251*/ 251*/
252static int free_list_bitmaps(struct super_block *p_s_sb, 252static int free_list_bitmaps(struct super_block *sb,
253 struct reiserfs_list_bitmap *jb_array) 253 struct reiserfs_list_bitmap *jb_array)
254{ 254{
255 int i; 255 int i;
@@ -257,16 +257,16 @@ static int free_list_bitmaps(struct super_block *p_s_sb,
257 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 257 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
258 jb = jb_array + i; 258 jb = jb_array + i;
259 jb->journal_list = NULL; 259 jb->journal_list = NULL;
260 cleanup_bitmap_list(p_s_sb, jb); 260 cleanup_bitmap_list(sb, jb);
261 vfree(jb->bitmaps); 261 vfree(jb->bitmaps);
262 jb->bitmaps = NULL; 262 jb->bitmaps = NULL;
263 } 263 }
264 return 0; 264 return 0;
265} 265}
266 266
267static int free_bitmap_nodes(struct super_block *p_s_sb) 267static int free_bitmap_nodes(struct super_block *sb)
268{ 268{
269 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 269 struct reiserfs_journal *journal = SB_JOURNAL(sb);
270 struct list_head *next = journal->j_bitmap_nodes.next; 270 struct list_head *next = journal->j_bitmap_nodes.next;
271 struct reiserfs_bitmap_node *bn; 271 struct reiserfs_bitmap_node *bn;
272 272
@@ -283,10 +283,10 @@ static int free_bitmap_nodes(struct super_block *p_s_sb)
283} 283}
284 284
285/* 285/*
286** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps. 286** get memory for JOURNAL_NUM_BITMAPS worth of bitmaps.
287** jb_array is the array to be filled in. 287** jb_array is the array to be filled in.
288*/ 288*/
289int reiserfs_allocate_list_bitmaps(struct super_block *p_s_sb, 289int reiserfs_allocate_list_bitmaps(struct super_block *sb,
290 struct reiserfs_list_bitmap *jb_array, 290 struct reiserfs_list_bitmap *jb_array,
291 unsigned int bmap_nr) 291 unsigned int bmap_nr)
292{ 292{
@@ -300,30 +300,30 @@ int reiserfs_allocate_list_bitmaps(struct super_block *p_s_sb,
300 jb->journal_list = NULL; 300 jb->journal_list = NULL;
301 jb->bitmaps = vmalloc(mem); 301 jb->bitmaps = vmalloc(mem);
302 if (!jb->bitmaps) { 302 if (!jb->bitmaps) {
303 reiserfs_warning(p_s_sb, 303 reiserfs_warning(sb, "clm-2000", "unable to "
304 "clm-2000, unable to allocate bitmaps for journal lists"); 304 "allocate bitmaps for journal lists");
305 failed = 1; 305 failed = 1;
306 break; 306 break;
307 } 307 }
308 memset(jb->bitmaps, 0, mem); 308 memset(jb->bitmaps, 0, mem);
309 } 309 }
310 if (failed) { 310 if (failed) {
311 free_list_bitmaps(p_s_sb, jb_array); 311 free_list_bitmaps(sb, jb_array);
312 return -1; 312 return -1;
313 } 313 }
314 return 0; 314 return 0;
315} 315}
316 316
317/* 317/*
318** find an available list bitmap. If you can't find one, flush a commit list 318** find an available list bitmap. If you can't find one, flush a commit list
319** and try again 319** and try again
320*/ 320*/
321static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *p_s_sb, 321static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb,
322 struct reiserfs_journal_list 322 struct reiserfs_journal_list
323 *jl) 323 *jl)
324{ 324{
325 int i, j; 325 int i, j;
326 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 326 struct reiserfs_journal *journal = SB_JOURNAL(sb);
327 struct reiserfs_list_bitmap *jb = NULL; 327 struct reiserfs_list_bitmap *jb = NULL;
328 328
329 for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) { 329 for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) {
@@ -331,7 +331,7 @@ static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *p_s_sb,
331 journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS; 331 journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS;
332 jb = journal->j_list_bitmap + i; 332 jb = journal->j_list_bitmap + i;
333 if (journal->j_list_bitmap[i].journal_list) { 333 if (journal->j_list_bitmap[i].journal_list) {
334 flush_commit_list(p_s_sb, 334 flush_commit_list(sb,
335 journal->j_list_bitmap[i]. 335 journal->j_list_bitmap[i].
336 journal_list, 1); 336 journal_list, 1);
337 if (!journal->j_list_bitmap[i].journal_list) { 337 if (!journal->j_list_bitmap[i].journal_list) {
@@ -348,7 +348,7 @@ static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *p_s_sb,
348 return jb; 348 return jb;
349} 349}
350 350
351/* 351/*
352** allocates a new chunk of X nodes, and links them all together as a list. 352** allocates a new chunk of X nodes, and links them all together as a list.
353** Uses the cnode->next and cnode->prev pointers 353** Uses the cnode->next and cnode->prev pointers
354** returns NULL on failure 354** returns NULL on failure
@@ -376,14 +376,14 @@ static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes)
376} 376}
377 377
378/* 378/*
379** pulls a cnode off the free list, or returns NULL on failure 379** pulls a cnode off the free list, or returns NULL on failure
380*/ 380*/
381static struct reiserfs_journal_cnode *get_cnode(struct super_block *p_s_sb) 381static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb)
382{ 382{
383 struct reiserfs_journal_cnode *cn; 383 struct reiserfs_journal_cnode *cn;
384 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 384 struct reiserfs_journal *journal = SB_JOURNAL(sb);
385 385
386 reiserfs_check_lock_depth(p_s_sb, "get_cnode"); 386 reiserfs_check_lock_depth(sb, "get_cnode");
387 387
388 if (journal->j_cnode_free <= 0) { 388 if (journal->j_cnode_free <= 0) {
389 return NULL; 389 return NULL;
@@ -403,14 +403,14 @@ static struct reiserfs_journal_cnode *get_cnode(struct super_block *p_s_sb)
403} 403}
404 404
405/* 405/*
406** returns a cnode to the free list 406** returns a cnode to the free list
407*/ 407*/
408static void free_cnode(struct super_block *p_s_sb, 408static void free_cnode(struct super_block *sb,
409 struct reiserfs_journal_cnode *cn) 409 struct reiserfs_journal_cnode *cn)
410{ 410{
411 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 411 struct reiserfs_journal *journal = SB_JOURNAL(sb);
412 412
413 reiserfs_check_lock_depth(p_s_sb, "free_cnode"); 413 reiserfs_check_lock_depth(sb, "free_cnode");
414 414
415 journal->j_cnode_used--; 415 journal->j_cnode_used--;
416 journal->j_cnode_free++; 416 journal->j_cnode_free++;
@@ -436,8 +436,8 @@ void reiserfs_check_lock_depth(struct super_block *sb, char *caller)
436{ 436{
437#ifdef CONFIG_SMP 437#ifdef CONFIG_SMP
438 if (current->lock_depth < 0) { 438 if (current->lock_depth < 0) {
439 reiserfs_panic(sb, "%s called without kernel lock held", 439 reiserfs_panic(sb, "journal-1", "%s called without kernel "
440 caller); 440 "lock held", caller);
441 } 441 }
442#else 442#else
443 ; 443 ;
@@ -481,11 +481,11 @@ static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct
481** reject it on the next call to reiserfs_in_journal 481** reject it on the next call to reiserfs_in_journal
482** 482**
483*/ 483*/
484int reiserfs_in_journal(struct super_block *p_s_sb, 484int reiserfs_in_journal(struct super_block *sb,
485 unsigned int bmap_nr, int bit_nr, int search_all, 485 unsigned int bmap_nr, int bit_nr, int search_all,
486 b_blocknr_t * next_zero_bit) 486 b_blocknr_t * next_zero_bit)
487{ 487{
488 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 488 struct reiserfs_journal *journal = SB_JOURNAL(sb);
489 struct reiserfs_journal_cnode *cn; 489 struct reiserfs_journal_cnode *cn;
490 struct reiserfs_list_bitmap *jb; 490 struct reiserfs_list_bitmap *jb;
491 int i; 491 int i;
@@ -493,14 +493,14 @@ int reiserfs_in_journal(struct super_block *p_s_sb,
493 493
494 *next_zero_bit = 0; /* always start this at zero. */ 494 *next_zero_bit = 0; /* always start this at zero. */
495 495
496 PROC_INFO_INC(p_s_sb, journal.in_journal); 496 PROC_INFO_INC(sb, journal.in_journal);
497 /* If we aren't doing a search_all, this is a metablock, and it will be logged before use. 497 /* If we aren't doing a search_all, this is a metablock, and it will be logged before use.
498 ** if we crash before the transaction that freed it commits, this transaction won't 498 ** if we crash before the transaction that freed it commits, this transaction won't
499 ** have committed either, and the block will never be written 499 ** have committed either, and the block will never be written
500 */ 500 */
501 if (search_all) { 501 if (search_all) {
502 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) { 502 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
503 PROC_INFO_INC(p_s_sb, journal.in_journal_bitmap); 503 PROC_INFO_INC(sb, journal.in_journal_bitmap);
504 jb = journal->j_list_bitmap + i; 504 jb = journal->j_list_bitmap + i;
505 if (jb->journal_list && jb->bitmaps[bmap_nr] && 505 if (jb->journal_list && jb->bitmaps[bmap_nr] &&
506 test_bit(bit_nr, 506 test_bit(bit_nr,
@@ -510,28 +510,28 @@ int reiserfs_in_journal(struct super_block *p_s_sb,
510 find_next_zero_bit((unsigned long *) 510 find_next_zero_bit((unsigned long *)
511 (jb->bitmaps[bmap_nr]-> 511 (jb->bitmaps[bmap_nr]->
512 data), 512 data),
513 p_s_sb->s_blocksize << 3, 513 sb->s_blocksize << 3,
514 bit_nr + 1); 514 bit_nr + 1);
515 return 1; 515 return 1;
516 } 516 }
517 } 517 }
518 } 518 }
519 519
520 bl = bmap_nr * (p_s_sb->s_blocksize << 3) + bit_nr; 520 bl = bmap_nr * (sb->s_blocksize << 3) + bit_nr;
521 /* is it in any old transactions? */ 521 /* is it in any old transactions? */
522 if (search_all 522 if (search_all
523 && (cn = 523 && (cn =
524 get_journal_hash_dev(p_s_sb, journal->j_list_hash_table, bl))) { 524 get_journal_hash_dev(sb, journal->j_list_hash_table, bl))) {
525 return 1; 525 return 1;
526 } 526 }
527 527
528 /* is it in the current transaction. This should never happen */ 528 /* is it in the current transaction. This should never happen */
529 if ((cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, bl))) { 529 if ((cn = get_journal_hash_dev(sb, journal->j_hash_table, bl))) {
530 BUG(); 530 BUG();
531 return 1; 531 return 1;
532 } 532 }
533 533
534 PROC_INFO_INC(p_s_sb, journal.in_journal_reusable); 534 PROC_INFO_INC(sb, journal.in_journal_reusable);
535 /* safe for reuse */ 535 /* safe for reuse */
536 return 0; 536 return 0;
537} 537}
@@ -553,16 +553,16 @@ static inline void insert_journal_hash(struct reiserfs_journal_cnode **table,
553} 553}
554 554
555/* lock the current transaction */ 555/* lock the current transaction */
556static inline void lock_journal(struct super_block *p_s_sb) 556static inline void lock_journal(struct super_block *sb)
557{ 557{
558 PROC_INFO_INC(p_s_sb, journal.lock_journal); 558 PROC_INFO_INC(sb, journal.lock_journal);
559 mutex_lock(&SB_JOURNAL(p_s_sb)->j_mutex); 559 mutex_lock(&SB_JOURNAL(sb)->j_mutex);
560} 560}
561 561
562/* unlock the current transaction */ 562/* unlock the current transaction */
563static inline void unlock_journal(struct super_block *p_s_sb) 563static inline void unlock_journal(struct super_block *sb)
564{ 564{
565 mutex_unlock(&SB_JOURNAL(p_s_sb)->j_mutex); 565 mutex_unlock(&SB_JOURNAL(sb)->j_mutex);
566} 566}
567 567
568static inline void get_journal_list(struct reiserfs_journal_list *jl) 568static inline void get_journal_list(struct reiserfs_journal_list *jl)
@@ -574,7 +574,7 @@ static inline void put_journal_list(struct super_block *s,
574 struct reiserfs_journal_list *jl) 574 struct reiserfs_journal_list *jl)
575{ 575{
576 if (jl->j_refcount < 1) { 576 if (jl->j_refcount < 1) {
577 reiserfs_panic(s, "trans id %lu, refcount at %d", 577 reiserfs_panic(s, "journal-2", "trans id %u, refcount at %d",
578 jl->j_trans_id, jl->j_refcount); 578 jl->j_trans_id, jl->j_refcount);
579 } 579 }
580 if (--jl->j_refcount == 0) 580 if (--jl->j_refcount == 0)
@@ -586,20 +586,20 @@ static inline void put_journal_list(struct super_block *s,
586** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a 586** it gets called by flush_commit_list, and cleans up any data stored about blocks freed during a
587** transaction. 587** transaction.
588*/ 588*/
589static void cleanup_freed_for_journal_list(struct super_block *p_s_sb, 589static void cleanup_freed_for_journal_list(struct super_block *sb,
590 struct reiserfs_journal_list *jl) 590 struct reiserfs_journal_list *jl)
591{ 591{
592 592
593 struct reiserfs_list_bitmap *jb = jl->j_list_bitmap; 593 struct reiserfs_list_bitmap *jb = jl->j_list_bitmap;
594 if (jb) { 594 if (jb) {
595 cleanup_bitmap_list(p_s_sb, jb); 595 cleanup_bitmap_list(sb, jb);
596 } 596 }
597 jl->j_list_bitmap->journal_list = NULL; 597 jl->j_list_bitmap->journal_list = NULL;
598 jl->j_list_bitmap = NULL; 598 jl->j_list_bitmap = NULL;
599} 599}
600 600
601static int journal_list_still_alive(struct super_block *s, 601static int journal_list_still_alive(struct super_block *s,
602 unsigned long trans_id) 602 unsigned int trans_id)
603{ 603{
604 struct reiserfs_journal *journal = SB_JOURNAL(s); 604 struct reiserfs_journal *journal = SB_JOURNAL(s);
605 struct list_head *entry = &journal->j_journal_list; 605 struct list_head *entry = &journal->j_journal_list;
@@ -644,8 +644,8 @@ static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
644 char b[BDEVNAME_SIZE]; 644 char b[BDEVNAME_SIZE];
645 645
646 if (buffer_journaled(bh)) { 646 if (buffer_journaled(bh)) {
647 reiserfs_warning(NULL, 647 reiserfs_warning(NULL, "clm-2084",
648 "clm-2084: pinned buffer %lu:%s sent to disk", 648 "pinned buffer %lu:%s sent to disk",
649 bh->b_blocknr, bdevname(bh->b_bdev, b)); 649 bh->b_blocknr, bdevname(bh->b_bdev, b));
650 } 650 }
651 if (uptodate) 651 if (uptodate)
@@ -933,9 +933,9 @@ static int flush_older_commits(struct super_block *s,
933 struct reiserfs_journal_list *other_jl; 933 struct reiserfs_journal_list *other_jl;
934 struct reiserfs_journal_list *first_jl; 934 struct reiserfs_journal_list *first_jl;
935 struct list_head *entry; 935 struct list_head *entry;
936 unsigned long trans_id = jl->j_trans_id; 936 unsigned int trans_id = jl->j_trans_id;
937 unsigned long other_trans_id; 937 unsigned int other_trans_id;
938 unsigned long first_trans_id; 938 unsigned int first_trans_id;
939 939
940 find_first: 940 find_first:
941 /* 941 /*
@@ -1014,7 +1014,7 @@ static int flush_commit_list(struct super_block *s,
1014 int i; 1014 int i;
1015 b_blocknr_t bn; 1015 b_blocknr_t bn;
1016 struct buffer_head *tbh = NULL; 1016 struct buffer_head *tbh = NULL;
1017 unsigned long trans_id = jl->j_trans_id; 1017 unsigned int trans_id = jl->j_trans_id;
1018 struct reiserfs_journal *journal = SB_JOURNAL(s); 1018 struct reiserfs_journal *journal = SB_JOURNAL(s);
1019 int barrier = 0; 1019 int barrier = 0;
1020 int retval = 0; 1020 int retval = 0;
@@ -1122,7 +1122,8 @@ static int flush_commit_list(struct super_block *s,
1122 sync_dirty_buffer(tbh); 1122 sync_dirty_buffer(tbh);
1123 if (unlikely(!buffer_uptodate(tbh))) { 1123 if (unlikely(!buffer_uptodate(tbh))) {
1124#ifdef CONFIG_REISERFS_CHECK 1124#ifdef CONFIG_REISERFS_CHECK
1125 reiserfs_warning(s, "journal-601, buffer write failed"); 1125 reiserfs_warning(s, "journal-601",
1126 "buffer write failed");
1126#endif 1127#endif
1127 retval = -EIO; 1128 retval = -EIO;
1128 } 1129 }
@@ -1154,14 +1155,14 @@ static int flush_commit_list(struct super_block *s,
1154 * up propagating the write error out to the filesystem. */ 1155 * up propagating the write error out to the filesystem. */
1155 if (unlikely(!buffer_uptodate(jl->j_commit_bh))) { 1156 if (unlikely(!buffer_uptodate(jl->j_commit_bh))) {
1156#ifdef CONFIG_REISERFS_CHECK 1157#ifdef CONFIG_REISERFS_CHECK
1157 reiserfs_warning(s, "journal-615: buffer write failed"); 1158 reiserfs_warning(s, "journal-615", "buffer write failed");
1158#endif 1159#endif
1159 retval = -EIO; 1160 retval = -EIO;
1160 } 1161 }
1161 bforget(jl->j_commit_bh); 1162 bforget(jl->j_commit_bh);
1162 if (journal->j_last_commit_id != 0 && 1163 if (journal->j_last_commit_id != 0 &&
1163 (jl->j_trans_id - journal->j_last_commit_id) != 1) { 1164 (jl->j_trans_id - journal->j_last_commit_id) != 1) {
1164 reiserfs_warning(s, "clm-2200: last commit %lu, current %lu", 1165 reiserfs_warning(s, "clm-2200", "last commit %lu, current %lu",
1165 journal->j_last_commit_id, jl->j_trans_id); 1166 journal->j_last_commit_id, jl->j_trans_id);
1166 } 1167 }
1167 journal->j_last_commit_id = jl->j_trans_id; 1168 journal->j_last_commit_id = jl->j_trans_id;
@@ -1191,8 +1192,8 @@ static int flush_commit_list(struct super_block *s,
1191} 1192}
1192 1193
1193/* 1194/*
1194** flush_journal_list frequently needs to find a newer transaction for a given block. This does that, or 1195** flush_journal_list frequently needs to find a newer transaction for a given block. This does that, or
1195** returns NULL if it can't find anything 1196** returns NULL if it can't find anything
1196*/ 1197*/
1197static struct reiserfs_journal_list *find_newer_jl_for_cn(struct 1198static struct reiserfs_journal_list *find_newer_jl_for_cn(struct
1198 reiserfs_journal_cnode 1199 reiserfs_journal_cnode
@@ -1236,11 +1237,11 @@ static void remove_journal_hash(struct super_block *,
1236** journal list for this transaction. Aside from freeing the cnode, this also allows the 1237** journal list for this transaction. Aside from freeing the cnode, this also allows the
1237** block to be reallocated for data blocks if it had been deleted. 1238** block to be reallocated for data blocks if it had been deleted.
1238*/ 1239*/
1239static void remove_all_from_journal_list(struct super_block *p_s_sb, 1240static void remove_all_from_journal_list(struct super_block *sb,
1240 struct reiserfs_journal_list *jl, 1241 struct reiserfs_journal_list *jl,
1241 int debug) 1242 int debug)
1242{ 1243{
1243 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 1244 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1244 struct reiserfs_journal_cnode *cn, *last; 1245 struct reiserfs_journal_cnode *cn, *last;
1245 cn = jl->j_realblock; 1246 cn = jl->j_realblock;
1246 1247
@@ -1250,18 +1251,18 @@ static void remove_all_from_journal_list(struct super_block *p_s_sb,
1250 while (cn) { 1251 while (cn) {
1251 if (cn->blocknr != 0) { 1252 if (cn->blocknr != 0) {
1252 if (debug) { 1253 if (debug) {
1253 reiserfs_warning(p_s_sb, 1254 reiserfs_warning(sb, "reiserfs-2201",
1254 "block %u, bh is %d, state %ld", 1255 "block %u, bh is %d, state %ld",
1255 cn->blocknr, cn->bh ? 1 : 0, 1256 cn->blocknr, cn->bh ? 1 : 0,
1256 cn->state); 1257 cn->state);
1257 } 1258 }
1258 cn->state = 0; 1259 cn->state = 0;
1259 remove_journal_hash(p_s_sb, journal->j_list_hash_table, 1260 remove_journal_hash(sb, journal->j_list_hash_table,
1260 jl, cn->blocknr, 1); 1261 jl, cn->blocknr, 1);
1261 } 1262 }
1262 last = cn; 1263 last = cn;
1263 cn = cn->next; 1264 cn = cn->next;
1264 free_cnode(p_s_sb, last); 1265 free_cnode(sb, last);
1265 } 1266 }
1266 jl->j_realblock = NULL; 1267 jl->j_realblock = NULL;
1267} 1268}
@@ -1273,12 +1274,12 @@ static void remove_all_from_journal_list(struct super_block *p_s_sb,
1273** called by flush_journal_list, before it calls remove_all_from_journal_list 1274** called by flush_journal_list, before it calls remove_all_from_journal_list
1274** 1275**
1275*/ 1276*/
1276static int _update_journal_header_block(struct super_block *p_s_sb, 1277static int _update_journal_header_block(struct super_block *sb,
1277 unsigned long offset, 1278 unsigned long offset,
1278 unsigned long trans_id) 1279 unsigned int trans_id)
1279{ 1280{
1280 struct reiserfs_journal_header *jh; 1281 struct reiserfs_journal_header *jh;
1281 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 1282 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1282 1283
1283 if (reiserfs_is_journal_aborted(journal)) 1284 if (reiserfs_is_journal_aborted(journal))
1284 return -EIO; 1285 return -EIO;
@@ -1288,8 +1289,8 @@ static int _update_journal_header_block(struct super_block *p_s_sb,
1288 wait_on_buffer((journal->j_header_bh)); 1289 wait_on_buffer((journal->j_header_bh));
1289 if (unlikely(!buffer_uptodate(journal->j_header_bh))) { 1290 if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
1290#ifdef CONFIG_REISERFS_CHECK 1291#ifdef CONFIG_REISERFS_CHECK
1291 reiserfs_warning(p_s_sb, 1292 reiserfs_warning(sb, "journal-699",
1292 "journal-699: buffer write failed"); 1293 "buffer write failed");
1293#endif 1294#endif
1294 return -EIO; 1295 return -EIO;
1295 } 1296 }
@@ -1302,49 +1303,49 @@ static int _update_journal_header_block(struct super_block *p_s_sb,
1302 jh->j_first_unflushed_offset = cpu_to_le32(offset); 1303 jh->j_first_unflushed_offset = cpu_to_le32(offset);
1303 jh->j_mount_id = cpu_to_le32(journal->j_mount_id); 1304 jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
1304 1305
1305 if (reiserfs_barrier_flush(p_s_sb)) { 1306 if (reiserfs_barrier_flush(sb)) {
1306 int ret; 1307 int ret;
1307 lock_buffer(journal->j_header_bh); 1308 lock_buffer(journal->j_header_bh);
1308 ret = submit_barrier_buffer(journal->j_header_bh); 1309 ret = submit_barrier_buffer(journal->j_header_bh);
1309 if (ret == -EOPNOTSUPP) { 1310 if (ret == -EOPNOTSUPP) {
1310 set_buffer_uptodate(journal->j_header_bh); 1311 set_buffer_uptodate(journal->j_header_bh);
1311 disable_barrier(p_s_sb); 1312 disable_barrier(sb);
1312 goto sync; 1313 goto sync;
1313 } 1314 }
1314 wait_on_buffer(journal->j_header_bh); 1315 wait_on_buffer(journal->j_header_bh);
1315 check_barrier_completion(p_s_sb, journal->j_header_bh); 1316 check_barrier_completion(sb, journal->j_header_bh);
1316 } else { 1317 } else {
1317 sync: 1318 sync:
1318 set_buffer_dirty(journal->j_header_bh); 1319 set_buffer_dirty(journal->j_header_bh);
1319 sync_dirty_buffer(journal->j_header_bh); 1320 sync_dirty_buffer(journal->j_header_bh);
1320 } 1321 }
1321 if (!buffer_uptodate(journal->j_header_bh)) { 1322 if (!buffer_uptodate(journal->j_header_bh)) {
1322 reiserfs_warning(p_s_sb, 1323 reiserfs_warning(sb, "journal-837",
1323 "journal-837: IO error during journal replay"); 1324 "IO error during journal replay");
1324 return -EIO; 1325 return -EIO;
1325 } 1326 }
1326 } 1327 }
1327 return 0; 1328 return 0;
1328} 1329}
1329 1330
1330static int update_journal_header_block(struct super_block *p_s_sb, 1331static int update_journal_header_block(struct super_block *sb,
1331 unsigned long offset, 1332 unsigned long offset,
1332 unsigned long trans_id) 1333 unsigned int trans_id)
1333{ 1334{
1334 return _update_journal_header_block(p_s_sb, offset, trans_id); 1335 return _update_journal_header_block(sb, offset, trans_id);
1335} 1336}
1336 1337
1337/* 1338/*
1338** flush any and all journal lists older than you are 1339** flush any and all journal lists older than you are
1339** can only be called from flush_journal_list 1340** can only be called from flush_journal_list
1340*/ 1341*/
1341static int flush_older_journal_lists(struct super_block *p_s_sb, 1342static int flush_older_journal_lists(struct super_block *sb,
1342 struct reiserfs_journal_list *jl) 1343 struct reiserfs_journal_list *jl)
1343{ 1344{
1344 struct list_head *entry; 1345 struct list_head *entry;
1345 struct reiserfs_journal_list *other_jl; 1346 struct reiserfs_journal_list *other_jl;
1346 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 1347 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1347 unsigned long trans_id = jl->j_trans_id; 1348 unsigned int trans_id = jl->j_trans_id;
1348 1349
1349 /* we know we are the only ones flushing things, no extra race 1350 /* we know we are the only ones flushing things, no extra race
1350 * protection is required. 1351 * protection is required.
@@ -1358,7 +1359,7 @@ static int flush_older_journal_lists(struct super_block *p_s_sb,
1358 if (other_jl->j_trans_id < trans_id) { 1359 if (other_jl->j_trans_id < trans_id) {
1359 BUG_ON(other_jl->j_refcount <= 0); 1360 BUG_ON(other_jl->j_refcount <= 0);
1360 /* do not flush all */ 1361 /* do not flush all */
1361 flush_journal_list(p_s_sb, other_jl, 0); 1362 flush_journal_list(sb, other_jl, 0);
1362 1363
1363 /* other_jl is now deleted from the list */ 1364 /* other_jl is now deleted from the list */
1364 goto restart; 1365 goto restart;
@@ -1381,8 +1382,8 @@ static void del_from_work_list(struct super_block *s,
1381** always set flushall to 1, unless you are calling from inside 1382** always set flushall to 1, unless you are calling from inside
1382** flush_journal_list 1383** flush_journal_list
1383** 1384**
1384** IMPORTANT. This can only be called while there are no journal writers, 1385** IMPORTANT. This can only be called while there are no journal writers,
1385** and the journal is locked. That means it can only be called from 1386** and the journal is locked. That means it can only be called from
1386** do_journal_end, or by journal_release 1387** do_journal_end, or by journal_release
1387*/ 1388*/
1388static int flush_journal_list(struct super_block *s, 1389static int flush_journal_list(struct super_block *s,
@@ -1401,8 +1402,7 @@ static int flush_journal_list(struct super_block *s,
1401 BUG_ON(j_len_saved <= 0); 1402 BUG_ON(j_len_saved <= 0);
1402 1403
1403 if (atomic_read(&journal->j_wcount) != 0) { 1404 if (atomic_read(&journal->j_wcount) != 0) {
1404 reiserfs_warning(s, 1405 reiserfs_warning(s, "clm-2048", "called with wcount %d",
1405 "clm-2048: flush_journal_list called with wcount %d",
1406 atomic_read(&journal->j_wcount)); 1406 atomic_read(&journal->j_wcount));
1407 } 1407 }
1408 BUG_ON(jl->j_trans_id == 0); 1408 BUG_ON(jl->j_trans_id == 0);
@@ -1416,8 +1416,7 @@ static int flush_journal_list(struct super_block *s,
1416 1416
1417 count = 0; 1417 count = 0;
1418 if (j_len_saved > journal->j_trans_max) { 1418 if (j_len_saved > journal->j_trans_max) {
1419 reiserfs_panic(s, 1419 reiserfs_panic(s, "journal-715", "length is %lu, trans id %lu",
1420 "journal-715: flush_journal_list, length is %lu, trans id %lu\n",
1421 j_len_saved, jl->j_trans_id); 1420 j_len_saved, jl->j_trans_id);
1422 return 0; 1421 return 0;
1423 } 1422 }
@@ -1430,7 +1429,7 @@ static int flush_journal_list(struct super_block *s,
1430 goto flush_older_and_return; 1429 goto flush_older_and_return;
1431 } 1430 }
1432 1431
1433 /* start by putting the commit list on disk. This will also flush 1432 /* start by putting the commit list on disk. This will also flush
1434 ** the commit lists of any olders transactions 1433 ** the commit lists of any olders transactions
1435 */ 1434 */
1436 flush_commit_list(s, jl, 1); 1435 flush_commit_list(s, jl, 1);
@@ -1445,12 +1444,12 @@ static int flush_journal_list(struct super_block *s,
1445 goto flush_older_and_return; 1444 goto flush_older_and_return;
1446 } 1445 }
1447 1446
1448 /* loop through each cnode, see if we need to write it, 1447 /* loop through each cnode, see if we need to write it,
1449 ** or wait on a more recent transaction, or just ignore it 1448 ** or wait on a more recent transaction, or just ignore it
1450 */ 1449 */
1451 if (atomic_read(&(journal->j_wcount)) != 0) { 1450 if (atomic_read(&(journal->j_wcount)) != 0) {
1452 reiserfs_panic(s, 1451 reiserfs_panic(s, "journal-844", "journal list is flushing, "
1453 "journal-844: panic journal list is flushing, wcount is not 0\n"); 1452 "wcount is not 0");
1454 } 1453 }
1455 cn = jl->j_realblock; 1454 cn = jl->j_realblock;
1456 while (cn) { 1455 while (cn) {
@@ -1474,8 +1473,8 @@ static int flush_journal_list(struct super_block *s,
1474 if (!pjl && cn->bh) { 1473 if (!pjl && cn->bh) {
1475 saved_bh = cn->bh; 1474 saved_bh = cn->bh;
1476 1475
1477 /* we do this to make sure nobody releases the buffer while 1476 /* we do this to make sure nobody releases the buffer while
1478 ** we are working with it 1477 ** we are working with it
1479 */ 1478 */
1480 get_bh(saved_bh); 1479 get_bh(saved_bh);
1481 1480
@@ -1498,8 +1497,8 @@ static int flush_journal_list(struct super_block *s,
1498 goto free_cnode; 1497 goto free_cnode;
1499 } 1498 }
1500 1499
1501 /* bh == NULL when the block got to disk on its own, OR, 1500 /* bh == NULL when the block got to disk on its own, OR,
1502 ** the block got freed in a future transaction 1501 ** the block got freed in a future transaction
1503 */ 1502 */
1504 if (saved_bh == NULL) { 1503 if (saved_bh == NULL) {
1505 goto free_cnode; 1504 goto free_cnode;
@@ -1510,8 +1509,8 @@ static int flush_journal_list(struct super_block *s,
1510 ** is not marked JDirty_wait 1509 ** is not marked JDirty_wait
1511 */ 1510 */
1512 if ((!was_jwait) && !buffer_locked(saved_bh)) { 1511 if ((!was_jwait) && !buffer_locked(saved_bh)) {
1513 reiserfs_warning(s, 1512 reiserfs_warning(s, "journal-813",
1514 "journal-813: BAD! buffer %llu %cdirty %cjwait, " 1513 "BAD! buffer %llu %cdirty %cjwait, "
1515 "not in a newer tranasction", 1514 "not in a newer tranasction",
1516 (unsigned long long)saved_bh-> 1515 (unsigned long long)saved_bh->
1517 b_blocknr, was_dirty ? ' ' : '!', 1516 b_blocknr, was_dirty ? ' ' : '!',
@@ -1529,8 +1528,8 @@ static int flush_journal_list(struct super_block *s,
1529 unlock_buffer(saved_bh); 1528 unlock_buffer(saved_bh);
1530 count++; 1529 count++;
1531 } else { 1530 } else {
1532 reiserfs_warning(s, 1531 reiserfs_warning(s, "clm-2082",
1533 "clm-2082: Unable to flush buffer %llu in %s", 1532 "Unable to flush buffer %llu in %s",
1534 (unsigned long long)saved_bh-> 1533 (unsigned long long)saved_bh->
1535 b_blocknr, __func__); 1534 b_blocknr, __func__);
1536 } 1535 }
@@ -1541,8 +1540,8 @@ static int flush_journal_list(struct super_block *s,
1541 /* we incremented this to keep others from taking the buffer head away */ 1540 /* we incremented this to keep others from taking the buffer head away */
1542 put_bh(saved_bh); 1541 put_bh(saved_bh);
1543 if (atomic_read(&(saved_bh->b_count)) < 0) { 1542 if (atomic_read(&(saved_bh->b_count)) < 0) {
1544 reiserfs_warning(s, 1543 reiserfs_warning(s, "journal-945",
1545 "journal-945: saved_bh->b_count < 0"); 1544 "saved_bh->b_count < 0");
1546 } 1545 }
1547 } 1546 }
1548 } 1547 }
@@ -1551,18 +1550,18 @@ static int flush_journal_list(struct super_block *s,
1551 while (cn) { 1550 while (cn) {
1552 if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) { 1551 if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) {
1553 if (!cn->bh) { 1552 if (!cn->bh) {
1554 reiserfs_panic(s, 1553 reiserfs_panic(s, "journal-1011",
1555 "journal-1011: cn->bh is NULL\n"); 1554 "cn->bh is NULL");
1556 } 1555 }
1557 wait_on_buffer(cn->bh); 1556 wait_on_buffer(cn->bh);
1558 if (!cn->bh) { 1557 if (!cn->bh) {
1559 reiserfs_panic(s, 1558 reiserfs_panic(s, "journal-1012",
1560 "journal-1012: cn->bh is NULL\n"); 1559 "cn->bh is NULL");
1561 } 1560 }
1562 if (unlikely(!buffer_uptodate(cn->bh))) { 1561 if (unlikely(!buffer_uptodate(cn->bh))) {
1563#ifdef CONFIG_REISERFS_CHECK 1562#ifdef CONFIG_REISERFS_CHECK
1564 reiserfs_warning(s, 1563 reiserfs_warning(s, "journal-949",
1565 "journal-949: buffer write failed\n"); 1564 "buffer write failed");
1566#endif 1565#endif
1567 err = -EIO; 1566 err = -EIO;
1568 } 1567 }
@@ -1587,7 +1586,7 @@ static int flush_journal_list(struct super_block *s,
1587 __func__); 1586 __func__);
1588 flush_older_and_return: 1587 flush_older_and_return:
1589 1588
1590 /* before we can update the journal header block, we _must_ flush all 1589 /* before we can update the journal header block, we _must_ flush all
1591 ** real blocks from all older transactions to disk. This is because 1590 ** real blocks from all older transactions to disk. This is because
1592 ** once the header block is updated, this transaction will not be 1591 ** once the header block is updated, this transaction will not be
1593 ** replayed after a crash 1592 ** replayed after a crash
@@ -1597,7 +1596,7 @@ static int flush_journal_list(struct super_block *s,
1597 } 1596 }
1598 1597
1599 err = journal->j_errno; 1598 err = journal->j_errno;
1600 /* before we can remove everything from the hash tables for this 1599 /* before we can remove everything from the hash tables for this
1601 ** transaction, we must make sure it can never be replayed 1600 ** transaction, we must make sure it can never be replayed
1602 ** 1601 **
1603 ** since we are only called from do_journal_end, we know for sure there 1602 ** since we are only called from do_journal_end, we know for sure there
@@ -1623,7 +1622,7 @@ static int flush_journal_list(struct super_block *s,
1623 1622
1624 if (journal->j_last_flush_id != 0 && 1623 if (journal->j_last_flush_id != 0 &&
1625 (jl->j_trans_id - journal->j_last_flush_id) != 1) { 1624 (jl->j_trans_id - journal->j_last_flush_id) != 1) {
1626 reiserfs_warning(s, "clm-2201: last flush %lu, current %lu", 1625 reiserfs_warning(s, "clm-2201", "last flush %lu, current %lu",
1627 journal->j_last_flush_id, jl->j_trans_id); 1626 journal->j_last_flush_id, jl->j_trans_id);
1628 } 1627 }
1629 journal->j_last_flush_id = jl->j_trans_id; 1628 journal->j_last_flush_id = jl->j_trans_id;
@@ -1758,13 +1757,13 @@ static int dirty_one_transaction(struct super_block *s,
1758static int kupdate_transactions(struct super_block *s, 1757static int kupdate_transactions(struct super_block *s,
1759 struct reiserfs_journal_list *jl, 1758 struct reiserfs_journal_list *jl,
1760 struct reiserfs_journal_list **next_jl, 1759 struct reiserfs_journal_list **next_jl,
1761 unsigned long *next_trans_id, 1760 unsigned int *next_trans_id,
1762 int num_blocks, int num_trans) 1761 int num_blocks, int num_trans)
1763{ 1762{
1764 int ret = 0; 1763 int ret = 0;
1765 int written = 0; 1764 int written = 0;
1766 int transactions_flushed = 0; 1765 int transactions_flushed = 0;
1767 unsigned long orig_trans_id = jl->j_trans_id; 1766 unsigned int orig_trans_id = jl->j_trans_id;
1768 struct buffer_chunk chunk; 1767 struct buffer_chunk chunk;
1769 struct list_head *entry; 1768 struct list_head *entry;
1770 struct reiserfs_journal *journal = SB_JOURNAL(s); 1769 struct reiserfs_journal *journal = SB_JOURNAL(s);
@@ -1833,7 +1832,7 @@ static int flush_used_journal_lists(struct super_block *s,
1833 int limit = 256; 1832 int limit = 256;
1834 struct reiserfs_journal_list *tjl; 1833 struct reiserfs_journal_list *tjl;
1835 struct reiserfs_journal_list *flush_jl; 1834 struct reiserfs_journal_list *flush_jl;
1836 unsigned long trans_id; 1835 unsigned int trans_id;
1837 struct reiserfs_journal *journal = SB_JOURNAL(s); 1836 struct reiserfs_journal *journal = SB_JOURNAL(s);
1838 1837
1839 flush_jl = tjl = jl; 1838 flush_jl = tjl = jl;
@@ -1909,22 +1908,22 @@ void remove_journal_hash(struct super_block *sb,
1909 } 1908 }
1910} 1909}
1911 1910
1912static void free_journal_ram(struct super_block *p_s_sb) 1911static void free_journal_ram(struct super_block *sb)
1913{ 1912{
1914 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 1913 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1915 kfree(journal->j_current_jl); 1914 kfree(journal->j_current_jl);
1916 journal->j_num_lists--; 1915 journal->j_num_lists--;
1917 1916
1918 vfree(journal->j_cnode_free_orig); 1917 vfree(journal->j_cnode_free_orig);
1919 free_list_bitmaps(p_s_sb, journal->j_list_bitmap); 1918 free_list_bitmaps(sb, journal->j_list_bitmap);
1920 free_bitmap_nodes(p_s_sb); /* must be after free_list_bitmaps */ 1919 free_bitmap_nodes(sb); /* must be after free_list_bitmaps */
1921 if (journal->j_header_bh) { 1920 if (journal->j_header_bh) {
1922 brelse(journal->j_header_bh); 1921 brelse(journal->j_header_bh);
1923 } 1922 }
1924 /* j_header_bh is on the journal dev, make sure not to release the journal 1923 /* j_header_bh is on the journal dev, make sure not to release the journal
1925 * dev until we brelse j_header_bh 1924 * dev until we brelse j_header_bh
1926 */ 1925 */
1927 release_journal_dev(p_s_sb, journal); 1926 release_journal_dev(sb, journal);
1928 vfree(journal); 1927 vfree(journal);
1929} 1928}
1930 1929
@@ -1933,27 +1932,27 @@ static void free_journal_ram(struct super_block *p_s_sb)
1933** of read_super() yet. Any other caller must keep error at 0. 1932** of read_super() yet. Any other caller must keep error at 0.
1934*/ 1933*/
1935static int do_journal_release(struct reiserfs_transaction_handle *th, 1934static int do_journal_release(struct reiserfs_transaction_handle *th,
1936 struct super_block *p_s_sb, int error) 1935 struct super_block *sb, int error)
1937{ 1936{
1938 struct reiserfs_transaction_handle myth; 1937 struct reiserfs_transaction_handle myth;
1939 int flushed = 0; 1938 int flushed = 0;
1940 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 1939 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1941 1940
1942 /* we only want to flush out transactions if we were called with error == 0 1941 /* we only want to flush out transactions if we were called with error == 0
1943 */ 1942 */
1944 if (!error && !(p_s_sb->s_flags & MS_RDONLY)) { 1943 if (!error && !(sb->s_flags & MS_RDONLY)) {
1945 /* end the current trans */ 1944 /* end the current trans */
1946 BUG_ON(!th->t_trans_id); 1945 BUG_ON(!th->t_trans_id);
1947 do_journal_end(th, p_s_sb, 10, FLUSH_ALL); 1946 do_journal_end(th, sb, 10, FLUSH_ALL);
1948 1947
1949 /* make sure something gets logged to force our way into the flush code */ 1948 /* make sure something gets logged to force our way into the flush code */
1950 if (!journal_join(&myth, p_s_sb, 1)) { 1949 if (!journal_join(&myth, sb, 1)) {
1951 reiserfs_prepare_for_journal(p_s_sb, 1950 reiserfs_prepare_for_journal(sb,
1952 SB_BUFFER_WITH_SB(p_s_sb), 1951 SB_BUFFER_WITH_SB(sb),
1953 1); 1952 1);
1954 journal_mark_dirty(&myth, p_s_sb, 1953 journal_mark_dirty(&myth, sb,
1955 SB_BUFFER_WITH_SB(p_s_sb)); 1954 SB_BUFFER_WITH_SB(sb));
1956 do_journal_end(&myth, p_s_sb, 1, FLUSH_ALL); 1955 do_journal_end(&myth, sb, 1, FLUSH_ALL);
1957 flushed = 1; 1956 flushed = 1;
1958 } 1957 }
1959 } 1958 }
@@ -1961,26 +1960,26 @@ static int do_journal_release(struct reiserfs_transaction_handle *th,
1961 /* this also catches errors during the do_journal_end above */ 1960 /* this also catches errors during the do_journal_end above */
1962 if (!error && reiserfs_is_journal_aborted(journal)) { 1961 if (!error && reiserfs_is_journal_aborted(journal)) {
1963 memset(&myth, 0, sizeof(myth)); 1962 memset(&myth, 0, sizeof(myth));
1964 if (!journal_join_abort(&myth, p_s_sb, 1)) { 1963 if (!journal_join_abort(&myth, sb, 1)) {
1965 reiserfs_prepare_for_journal(p_s_sb, 1964 reiserfs_prepare_for_journal(sb,
1966 SB_BUFFER_WITH_SB(p_s_sb), 1965 SB_BUFFER_WITH_SB(sb),
1967 1); 1966 1);
1968 journal_mark_dirty(&myth, p_s_sb, 1967 journal_mark_dirty(&myth, sb,
1969 SB_BUFFER_WITH_SB(p_s_sb)); 1968 SB_BUFFER_WITH_SB(sb));
1970 do_journal_end(&myth, p_s_sb, 1, FLUSH_ALL); 1969 do_journal_end(&myth, sb, 1, FLUSH_ALL);
1971 } 1970 }
1972 } 1971 }
1973 1972
1974 reiserfs_mounted_fs_count--; 1973 reiserfs_mounted_fs_count--;
1975 /* wait for all commits to finish */ 1974 /* wait for all commits to finish */
1976 cancel_delayed_work(&SB_JOURNAL(p_s_sb)->j_work); 1975 cancel_delayed_work(&SB_JOURNAL(sb)->j_work);
1977 flush_workqueue(commit_wq); 1976 flush_workqueue(commit_wq);
1978 if (!reiserfs_mounted_fs_count) { 1977 if (!reiserfs_mounted_fs_count) {
1979 destroy_workqueue(commit_wq); 1978 destroy_workqueue(commit_wq);
1980 commit_wq = NULL; 1979 commit_wq = NULL;
1981 } 1980 }
1982 1981
1983 free_journal_ram(p_s_sb); 1982 free_journal_ram(sb);
1984 1983
1985 return 0; 1984 return 0;
1986} 1985}
@@ -1989,41 +1988,41 @@ static int do_journal_release(struct reiserfs_transaction_handle *th,
1989** call on unmount. flush all journal trans, release all alloc'd ram 1988** call on unmount. flush all journal trans, release all alloc'd ram
1990*/ 1989*/
1991int journal_release(struct reiserfs_transaction_handle *th, 1990int journal_release(struct reiserfs_transaction_handle *th,
1992 struct super_block *p_s_sb) 1991 struct super_block *sb)
1993{ 1992{
1994 return do_journal_release(th, p_s_sb, 0); 1993 return do_journal_release(th, sb, 0);
1995} 1994}
1996 1995
1997/* 1996/*
1998** only call from an error condition inside reiserfs_read_super! 1997** only call from an error condition inside reiserfs_read_super!
1999*/ 1998*/
2000int journal_release_error(struct reiserfs_transaction_handle *th, 1999int journal_release_error(struct reiserfs_transaction_handle *th,
2001 struct super_block *p_s_sb) 2000 struct super_block *sb)
2002{ 2001{
2003 return do_journal_release(th, p_s_sb, 1); 2002 return do_journal_release(th, sb, 1);
2004} 2003}
2005 2004
2006/* compares description block with commit block. returns 1 if they differ, 0 if they are the same */ 2005/* compares description block with commit block. returns 1 if they differ, 0 if they are the same */
2007static int journal_compare_desc_commit(struct super_block *p_s_sb, 2006static int journal_compare_desc_commit(struct super_block *sb,
2008 struct reiserfs_journal_desc *desc, 2007 struct reiserfs_journal_desc *desc,
2009 struct reiserfs_journal_commit *commit) 2008 struct reiserfs_journal_commit *commit)
2010{ 2009{
2011 if (get_commit_trans_id(commit) != get_desc_trans_id(desc) || 2010 if (get_commit_trans_id(commit) != get_desc_trans_id(desc) ||
2012 get_commit_trans_len(commit) != get_desc_trans_len(desc) || 2011 get_commit_trans_len(commit) != get_desc_trans_len(desc) ||
2013 get_commit_trans_len(commit) > SB_JOURNAL(p_s_sb)->j_trans_max || 2012 get_commit_trans_len(commit) > SB_JOURNAL(sb)->j_trans_max ||
2014 get_commit_trans_len(commit) <= 0) { 2013 get_commit_trans_len(commit) <= 0) {
2015 return 1; 2014 return 1;
2016 } 2015 }
2017 return 0; 2016 return 0;
2018} 2017}
2019 2018
2020/* returns 0 if it did not find a description block 2019/* returns 0 if it did not find a description block
2021** returns -1 if it found a corrupt commit block 2020** returns -1 if it found a corrupt commit block
2022** returns 1 if both desc and commit were valid 2021** returns 1 if both desc and commit were valid
2023*/ 2022*/
2024static int journal_transaction_is_valid(struct super_block *p_s_sb, 2023static int journal_transaction_is_valid(struct super_block *sb,
2025 struct buffer_head *d_bh, 2024 struct buffer_head *d_bh,
2026 unsigned long *oldest_invalid_trans_id, 2025 unsigned int *oldest_invalid_trans_id,
2027 unsigned long *newest_mount_id) 2026 unsigned long *newest_mount_id)
2028{ 2027{
2029 struct reiserfs_journal_desc *desc; 2028 struct reiserfs_journal_desc *desc;
@@ -2039,7 +2038,7 @@ static int journal_transaction_is_valid(struct super_block *p_s_sb,
2039 && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) { 2038 && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) {
2040 if (oldest_invalid_trans_id && *oldest_invalid_trans_id 2039 if (oldest_invalid_trans_id && *oldest_invalid_trans_id
2041 && get_desc_trans_id(desc) > *oldest_invalid_trans_id) { 2040 && get_desc_trans_id(desc) > *oldest_invalid_trans_id) {
2042 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2041 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2043 "journal-986: transaction " 2042 "journal-986: transaction "
2044 "is valid returning because trans_id %d is greater than " 2043 "is valid returning because trans_id %d is greater than "
2045 "oldest_invalid %lu", 2044 "oldest_invalid %lu",
@@ -2049,7 +2048,7 @@ static int journal_transaction_is_valid(struct super_block *p_s_sb,
2049 } 2048 }
2050 if (newest_mount_id 2049 if (newest_mount_id
2051 && *newest_mount_id > get_desc_mount_id(desc)) { 2050 && *newest_mount_id > get_desc_mount_id(desc)) {
2052 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2051 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2053 "journal-1087: transaction " 2052 "journal-1087: transaction "
2054 "is valid returning because mount_id %d is less than " 2053 "is valid returning because mount_id %d is less than "
2055 "newest_mount_id %lu", 2054 "newest_mount_id %lu",
@@ -2057,36 +2056,37 @@ static int journal_transaction_is_valid(struct super_block *p_s_sb,
2057 *newest_mount_id); 2056 *newest_mount_id);
2058 return -1; 2057 return -1;
2059 } 2058 }
2060 if (get_desc_trans_len(desc) > SB_JOURNAL(p_s_sb)->j_trans_max) { 2059 if (get_desc_trans_len(desc) > SB_JOURNAL(sb)->j_trans_max) {
2061 reiserfs_warning(p_s_sb, 2060 reiserfs_warning(sb, "journal-2018",
2062 "journal-2018: Bad transaction length %d encountered, ignoring transaction", 2061 "Bad transaction length %d "
2062 "encountered, ignoring transaction",
2063 get_desc_trans_len(desc)); 2063 get_desc_trans_len(desc));
2064 return -1; 2064 return -1;
2065 } 2065 }
2066 offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb); 2066 offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2067 2067
2068 /* ok, we have a journal description block, lets see if the transaction was valid */ 2068 /* ok, we have a journal description block, lets see if the transaction was valid */
2069 c_bh = 2069 c_bh =
2070 journal_bread(p_s_sb, 2070 journal_bread(sb,
2071 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2071 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2072 ((offset + get_desc_trans_len(desc) + 2072 ((offset + get_desc_trans_len(desc) +
2073 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb))); 2073 1) % SB_ONDISK_JOURNAL_SIZE(sb)));
2074 if (!c_bh) 2074 if (!c_bh)
2075 return 0; 2075 return 0;
2076 commit = (struct reiserfs_journal_commit *)c_bh->b_data; 2076 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2077 if (journal_compare_desc_commit(p_s_sb, desc, commit)) { 2077 if (journal_compare_desc_commit(sb, desc, commit)) {
2078 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2078 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2079 "journal_transaction_is_valid, commit offset %ld had bad " 2079 "journal_transaction_is_valid, commit offset %ld had bad "
2080 "time %d or length %d", 2080 "time %d or length %d",
2081 c_bh->b_blocknr - 2081 c_bh->b_blocknr -
2082 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2082 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2083 get_commit_trans_id(commit), 2083 get_commit_trans_id(commit),
2084 get_commit_trans_len(commit)); 2084 get_commit_trans_len(commit));
2085 brelse(c_bh); 2085 brelse(c_bh);
2086 if (oldest_invalid_trans_id) { 2086 if (oldest_invalid_trans_id) {
2087 *oldest_invalid_trans_id = 2087 *oldest_invalid_trans_id =
2088 get_desc_trans_id(desc); 2088 get_desc_trans_id(desc);
2089 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2089 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2090 "journal-1004: " 2090 "journal-1004: "
2091 "transaction_is_valid setting oldest invalid trans_id " 2091 "transaction_is_valid setting oldest invalid trans_id "
2092 "to %d", 2092 "to %d",
@@ -2095,11 +2095,11 @@ static int journal_transaction_is_valid(struct super_block *p_s_sb,
2095 return -1; 2095 return -1;
2096 } 2096 }
2097 brelse(c_bh); 2097 brelse(c_bh);
2098 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2098 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2099 "journal-1006: found valid " 2099 "journal-1006: found valid "
2100 "transaction start offset %llu, len %d id %d", 2100 "transaction start offset %llu, len %d id %d",
2101 d_bh->b_blocknr - 2101 d_bh->b_blocknr -
2102 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2102 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2103 get_desc_trans_len(desc), 2103 get_desc_trans_len(desc),
2104 get_desc_trans_id(desc)); 2104 get_desc_trans_id(desc));
2105 return 1; 2105 return 1;
@@ -2121,63 +2121,63 @@ static void brelse_array(struct buffer_head **heads, int num)
2121** this either reads in a replays a transaction, or returns because the transaction 2121** this either reads in a replays a transaction, or returns because the transaction
2122** is invalid, or too old. 2122** is invalid, or too old.
2123*/ 2123*/
2124static int journal_read_transaction(struct super_block *p_s_sb, 2124static int journal_read_transaction(struct super_block *sb,
2125 unsigned long cur_dblock, 2125 unsigned long cur_dblock,
2126 unsigned long oldest_start, 2126 unsigned long oldest_start,
2127 unsigned long oldest_trans_id, 2127 unsigned int oldest_trans_id,
2128 unsigned long newest_mount_id) 2128 unsigned long newest_mount_id)
2129{ 2129{
2130 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 2130 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2131 struct reiserfs_journal_desc *desc; 2131 struct reiserfs_journal_desc *desc;
2132 struct reiserfs_journal_commit *commit; 2132 struct reiserfs_journal_commit *commit;
2133 unsigned long trans_id = 0; 2133 unsigned int trans_id = 0;
2134 struct buffer_head *c_bh; 2134 struct buffer_head *c_bh;
2135 struct buffer_head *d_bh; 2135 struct buffer_head *d_bh;
2136 struct buffer_head **log_blocks = NULL; 2136 struct buffer_head **log_blocks = NULL;
2137 struct buffer_head **real_blocks = NULL; 2137 struct buffer_head **real_blocks = NULL;
2138 unsigned long trans_offset; 2138 unsigned int trans_offset;
2139 int i; 2139 int i;
2140 int trans_half; 2140 int trans_half;
2141 2141
2142 d_bh = journal_bread(p_s_sb, cur_dblock); 2142 d_bh = journal_bread(sb, cur_dblock);
2143 if (!d_bh) 2143 if (!d_bh)
2144 return 1; 2144 return 1;
2145 desc = (struct reiserfs_journal_desc *)d_bh->b_data; 2145 desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2146 trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb); 2146 trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2147 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1037: " 2147 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1037: "
2148 "journal_read_transaction, offset %llu, len %d mount_id %d", 2148 "journal_read_transaction, offset %llu, len %d mount_id %d",
2149 d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2149 d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2150 get_desc_trans_len(desc), get_desc_mount_id(desc)); 2150 get_desc_trans_len(desc), get_desc_mount_id(desc));
2151 if (get_desc_trans_id(desc) < oldest_trans_id) { 2151 if (get_desc_trans_id(desc) < oldest_trans_id) {
2152 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1039: " 2152 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1039: "
2153 "journal_read_trans skipping because %lu is too old", 2153 "journal_read_trans skipping because %lu is too old",
2154 cur_dblock - 2154 cur_dblock -
2155 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb)); 2155 SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2156 brelse(d_bh); 2156 brelse(d_bh);
2157 return 1; 2157 return 1;
2158 } 2158 }
2159 if (get_desc_mount_id(desc) != newest_mount_id) { 2159 if (get_desc_mount_id(desc) != newest_mount_id) {
2160 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1146: " 2160 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1146: "
2161 "journal_read_trans skipping because %d is != " 2161 "journal_read_trans skipping because %d is != "
2162 "newest_mount_id %lu", get_desc_mount_id(desc), 2162 "newest_mount_id %lu", get_desc_mount_id(desc),
2163 newest_mount_id); 2163 newest_mount_id);
2164 brelse(d_bh); 2164 brelse(d_bh);
2165 return 1; 2165 return 1;
2166 } 2166 }
2167 c_bh = journal_bread(p_s_sb, SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2167 c_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2168 ((trans_offset + get_desc_trans_len(desc) + 1) % 2168 ((trans_offset + get_desc_trans_len(desc) + 1) %
2169 SB_ONDISK_JOURNAL_SIZE(p_s_sb))); 2169 SB_ONDISK_JOURNAL_SIZE(sb)));
2170 if (!c_bh) { 2170 if (!c_bh) {
2171 brelse(d_bh); 2171 brelse(d_bh);
2172 return 1; 2172 return 1;
2173 } 2173 }
2174 commit = (struct reiserfs_journal_commit *)c_bh->b_data; 2174 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2175 if (journal_compare_desc_commit(p_s_sb, desc, commit)) { 2175 if (journal_compare_desc_commit(sb, desc, commit)) {
2176 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2176 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2177 "journal_read_transaction, " 2177 "journal_read_transaction, "
2178 "commit offset %llu had bad time %d or length %d", 2178 "commit offset %llu had bad time %d or length %d",
2179 c_bh->b_blocknr - 2179 c_bh->b_blocknr -
2180 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2180 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2181 get_commit_trans_id(commit), 2181 get_commit_trans_id(commit),
2182 get_commit_trans_len(commit)); 2182 get_commit_trans_len(commit));
2183 brelse(c_bh); 2183 brelse(c_bh);
@@ -2195,38 +2195,41 @@ static int journal_read_transaction(struct super_block *p_s_sb,
2195 brelse(d_bh); 2195 brelse(d_bh);
2196 kfree(log_blocks); 2196 kfree(log_blocks);
2197 kfree(real_blocks); 2197 kfree(real_blocks);
2198 reiserfs_warning(p_s_sb, 2198 reiserfs_warning(sb, "journal-1169",
2199 "journal-1169: kmalloc failed, unable to mount FS"); 2199 "kmalloc failed, unable to mount FS");
2200 return -1; 2200 return -1;
2201 } 2201 }
2202 /* get all the buffer heads */ 2202 /* get all the buffer heads */
2203 trans_half = journal_trans_half(p_s_sb->s_blocksize); 2203 trans_half = journal_trans_half(sb->s_blocksize);
2204 for (i = 0; i < get_desc_trans_len(desc); i++) { 2204 for (i = 0; i < get_desc_trans_len(desc); i++) {
2205 log_blocks[i] = 2205 log_blocks[i] =
2206 journal_getblk(p_s_sb, 2206 journal_getblk(sb,
2207 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2207 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2208 (trans_offset + 1 + 2208 (trans_offset + 1 +
2209 i) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)); 2209 i) % SB_ONDISK_JOURNAL_SIZE(sb));
2210 if (i < trans_half) { 2210 if (i < trans_half) {
2211 real_blocks[i] = 2211 real_blocks[i] =
2212 sb_getblk(p_s_sb, 2212 sb_getblk(sb,
2213 le32_to_cpu(desc->j_realblock[i])); 2213 le32_to_cpu(desc->j_realblock[i]));
2214 } else { 2214 } else {
2215 real_blocks[i] = 2215 real_blocks[i] =
2216 sb_getblk(p_s_sb, 2216 sb_getblk(sb,
2217 le32_to_cpu(commit-> 2217 le32_to_cpu(commit->
2218 j_realblock[i - trans_half])); 2218 j_realblock[i - trans_half]));
2219 } 2219 }
2220 if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(p_s_sb)) { 2220 if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(sb)) {
2221 reiserfs_warning(p_s_sb, 2221 reiserfs_warning(sb, "journal-1207",
2222 "journal-1207: REPLAY FAILURE fsck required! Block to replay is outside of filesystem"); 2222 "REPLAY FAILURE fsck required! "
2223 "Block to replay is outside of "
2224 "filesystem");
2223 goto abort_replay; 2225 goto abort_replay;
2224 } 2226 }
2225 /* make sure we don't try to replay onto log or reserved area */ 2227 /* make sure we don't try to replay onto log or reserved area */
2226 if (is_block_in_log_or_reserved_area 2228 if (is_block_in_log_or_reserved_area
2227 (p_s_sb, real_blocks[i]->b_blocknr)) { 2229 (sb, real_blocks[i]->b_blocknr)) {
2228 reiserfs_warning(p_s_sb, 2230 reiserfs_warning(sb, "journal-1204",
2229 "journal-1204: REPLAY FAILURE fsck required! Trying to replay onto a log block"); 2231 "REPLAY FAILURE fsck required! "
2232 "Trying to replay onto a log block");
2230 abort_replay: 2233 abort_replay:
2231 brelse_array(log_blocks, i); 2234 brelse_array(log_blocks, i);
2232 brelse_array(real_blocks, i); 2235 brelse_array(real_blocks, i);
@@ -2242,8 +2245,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
2242 for (i = 0; i < get_desc_trans_len(desc); i++) { 2245 for (i = 0; i < get_desc_trans_len(desc); i++) {
2243 wait_on_buffer(log_blocks[i]); 2246 wait_on_buffer(log_blocks[i]);
2244 if (!buffer_uptodate(log_blocks[i])) { 2247 if (!buffer_uptodate(log_blocks[i])) {
2245 reiserfs_warning(p_s_sb, 2248 reiserfs_warning(sb, "journal-1212",
2246 "journal-1212: REPLAY FAILURE fsck required! buffer write failed"); 2249 "REPLAY FAILURE fsck required! "
2250 "buffer write failed");
2247 brelse_array(log_blocks + i, 2251 brelse_array(log_blocks + i,
2248 get_desc_trans_len(desc) - i); 2252 get_desc_trans_len(desc) - i);
2249 brelse_array(real_blocks, get_desc_trans_len(desc)); 2253 brelse_array(real_blocks, get_desc_trans_len(desc));
@@ -2266,8 +2270,9 @@ static int journal_read_transaction(struct super_block *p_s_sb,
2266 for (i = 0; i < get_desc_trans_len(desc); i++) { 2270 for (i = 0; i < get_desc_trans_len(desc); i++) {
2267 wait_on_buffer(real_blocks[i]); 2271 wait_on_buffer(real_blocks[i]);
2268 if (!buffer_uptodate(real_blocks[i])) { 2272 if (!buffer_uptodate(real_blocks[i])) {
2269 reiserfs_warning(p_s_sb, 2273 reiserfs_warning(sb, "journal-1226",
2270 "journal-1226: REPLAY FAILURE, fsck required! buffer write failed"); 2274 "REPLAY FAILURE, fsck required! "
2275 "buffer write failed");
2271 brelse_array(real_blocks + i, 2276 brelse_array(real_blocks + i,
2272 get_desc_trans_len(desc) - i); 2277 get_desc_trans_len(desc) - i);
2273 brelse(c_bh); 2278 brelse(c_bh);
@@ -2279,15 +2284,15 @@ static int journal_read_transaction(struct super_block *p_s_sb,
2279 brelse(real_blocks[i]); 2284 brelse(real_blocks[i]);
2280 } 2285 }
2281 cur_dblock = 2286 cur_dblock =
2282 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2287 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2283 ((trans_offset + get_desc_trans_len(desc) + 2288 ((trans_offset + get_desc_trans_len(desc) +
2284 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb)); 2289 2) % SB_ONDISK_JOURNAL_SIZE(sb));
2285 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2290 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2286 "journal-1095: setting journal " "start to offset %ld", 2291 "journal-1095: setting journal " "start to offset %ld",
2287 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb)); 2292 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2288 2293
2289 /* init starting values for the first transaction, in case this is the last transaction to be replayed. */ 2294 /* init starting values for the first transaction, in case this is the last transaction to be replayed. */
2290 journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb); 2295 journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2291 journal->j_last_flush_trans_id = trans_id; 2296 journal->j_last_flush_trans_id = trans_id;
2292 journal->j_trans_id = trans_id + 1; 2297 journal->j_trans_id = trans_id + 1;
2293 /* check for trans_id overflow */ 2298 /* check for trans_id overflow */
@@ -2352,12 +2357,12 @@ static struct buffer_head *reiserfs_breada(struct block_device *dev,
2352** 2357**
2353** On exit, it sets things up so the first transaction will work correctly. 2358** On exit, it sets things up so the first transaction will work correctly.
2354*/ 2359*/
2355static int journal_read(struct super_block *p_s_sb) 2360static int journal_read(struct super_block *sb)
2356{ 2361{
2357 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 2362 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2358 struct reiserfs_journal_desc *desc; 2363 struct reiserfs_journal_desc *desc;
2359 unsigned long oldest_trans_id = 0; 2364 unsigned int oldest_trans_id = 0;
2360 unsigned long oldest_invalid_trans_id = 0; 2365 unsigned int oldest_invalid_trans_id = 0;
2361 time_t start; 2366 time_t start;
2362 unsigned long oldest_start = 0; 2367 unsigned long oldest_start = 0;
2363 unsigned long cur_dblock = 0; 2368 unsigned long cur_dblock = 0;
@@ -2370,46 +2375,46 @@ static int journal_read(struct super_block *p_s_sb)
2370 int ret; 2375 int ret;
2371 char b[BDEVNAME_SIZE]; 2376 char b[BDEVNAME_SIZE];
2372 2377
2373 cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb); 2378 cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2374 reiserfs_info(p_s_sb, "checking transaction log (%s)\n", 2379 reiserfs_info(sb, "checking transaction log (%s)\n",
2375 bdevname(journal->j_dev_bd, b)); 2380 bdevname(journal->j_dev_bd, b));
2376 start = get_seconds(); 2381 start = get_seconds();
2377 2382
2378 /* step 1, read in the journal header block. Check the transaction it says 2383 /* step 1, read in the journal header block. Check the transaction it says
2379 ** is the first unflushed, and if that transaction is not valid, 2384 ** is the first unflushed, and if that transaction is not valid,
2380 ** replay is done 2385 ** replay is done
2381 */ 2386 */
2382 journal->j_header_bh = journal_bread(p_s_sb, 2387 journal->j_header_bh = journal_bread(sb,
2383 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) 2388 SB_ONDISK_JOURNAL_1st_BLOCK(sb)
2384 + SB_ONDISK_JOURNAL_SIZE(p_s_sb)); 2389 + SB_ONDISK_JOURNAL_SIZE(sb));
2385 if (!journal->j_header_bh) { 2390 if (!journal->j_header_bh) {
2386 return 1; 2391 return 1;
2387 } 2392 }
2388 jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data); 2393 jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data);
2389 if (le32_to_cpu(jh->j_first_unflushed_offset) < 2394 if (le32_to_cpu(jh->j_first_unflushed_offset) <
2390 SB_ONDISK_JOURNAL_SIZE(p_s_sb) 2395 SB_ONDISK_JOURNAL_SIZE(sb)
2391 && le32_to_cpu(jh->j_last_flush_trans_id) > 0) { 2396 && le32_to_cpu(jh->j_last_flush_trans_id) > 0) {
2392 oldest_start = 2397 oldest_start =
2393 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2398 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2394 le32_to_cpu(jh->j_first_unflushed_offset); 2399 le32_to_cpu(jh->j_first_unflushed_offset);
2395 oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1; 2400 oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1;
2396 newest_mount_id = le32_to_cpu(jh->j_mount_id); 2401 newest_mount_id = le32_to_cpu(jh->j_mount_id);
2397 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2402 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2398 "journal-1153: found in " 2403 "journal-1153: found in "
2399 "header: first_unflushed_offset %d, last_flushed_trans_id " 2404 "header: first_unflushed_offset %d, last_flushed_trans_id "
2400 "%lu", le32_to_cpu(jh->j_first_unflushed_offset), 2405 "%lu", le32_to_cpu(jh->j_first_unflushed_offset),
2401 le32_to_cpu(jh->j_last_flush_trans_id)); 2406 le32_to_cpu(jh->j_last_flush_trans_id));
2402 valid_journal_header = 1; 2407 valid_journal_header = 1;
2403 2408
2404 /* now, we try to read the first unflushed offset. If it is not valid, 2409 /* now, we try to read the first unflushed offset. If it is not valid,
2405 ** there is nothing more we can do, and it makes no sense to read 2410 ** there is nothing more we can do, and it makes no sense to read
2406 ** through the whole log. 2411 ** through the whole log.
2407 */ 2412 */
2408 d_bh = 2413 d_bh =
2409 journal_bread(p_s_sb, 2414 journal_bread(sb,
2410 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2415 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2411 le32_to_cpu(jh->j_first_unflushed_offset)); 2416 le32_to_cpu(jh->j_first_unflushed_offset));
2412 ret = journal_transaction_is_valid(p_s_sb, d_bh, NULL, NULL); 2417 ret = journal_transaction_is_valid(sb, d_bh, NULL, NULL);
2413 if (!ret) { 2418 if (!ret) {
2414 continue_replay = 0; 2419 continue_replay = 0;
2415 } 2420 }
@@ -2417,9 +2422,9 @@ static int journal_read(struct super_block *p_s_sb)
2417 goto start_log_replay; 2422 goto start_log_replay;
2418 } 2423 }
2419 2424
2420 if (continue_replay && bdev_read_only(p_s_sb->s_bdev)) { 2425 if (continue_replay && bdev_read_only(sb->s_bdev)) {
2421 reiserfs_warning(p_s_sb, 2426 reiserfs_warning(sb, "clm-2076",
2422 "clm-2076: device is readonly, unable to replay log"); 2427 "device is readonly, unable to replay log");
2423 return -1; 2428 return -1;
2424 } 2429 }
2425 2430
@@ -2428,17 +2433,17 @@ static int journal_read(struct super_block *p_s_sb)
2428 */ 2433 */
2429 while (continue_replay 2434 while (continue_replay
2430 && cur_dblock < 2435 && cur_dblock <
2431 (SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2436 (SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2432 SB_ONDISK_JOURNAL_SIZE(p_s_sb))) { 2437 SB_ONDISK_JOURNAL_SIZE(sb))) {
2433 /* Note that it is required for blocksize of primary fs device and journal 2438 /* Note that it is required for blocksize of primary fs device and journal
2434 device to be the same */ 2439 device to be the same */
2435 d_bh = 2440 d_bh =
2436 reiserfs_breada(journal->j_dev_bd, cur_dblock, 2441 reiserfs_breada(journal->j_dev_bd, cur_dblock,
2437 p_s_sb->s_blocksize, 2442 sb->s_blocksize,
2438 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2443 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2439 SB_ONDISK_JOURNAL_SIZE(p_s_sb)); 2444 SB_ONDISK_JOURNAL_SIZE(sb));
2440 ret = 2445 ret =
2441 journal_transaction_is_valid(p_s_sb, d_bh, 2446 journal_transaction_is_valid(sb, d_bh,
2442 &oldest_invalid_trans_id, 2447 &oldest_invalid_trans_id,
2443 &newest_mount_id); 2448 &newest_mount_id);
2444 if (ret == 1) { 2449 if (ret == 1) {
@@ -2447,26 +2452,26 @@ static int journal_read(struct super_block *p_s_sb)
2447 oldest_trans_id = get_desc_trans_id(desc); 2452 oldest_trans_id = get_desc_trans_id(desc);
2448 oldest_start = d_bh->b_blocknr; 2453 oldest_start = d_bh->b_blocknr;
2449 newest_mount_id = get_desc_mount_id(desc); 2454 newest_mount_id = get_desc_mount_id(desc);
2450 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2455 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2451 "journal-1179: Setting " 2456 "journal-1179: Setting "
2452 "oldest_start to offset %llu, trans_id %lu", 2457 "oldest_start to offset %llu, trans_id %lu",
2453 oldest_start - 2458 oldest_start -
2454 SB_ONDISK_JOURNAL_1st_BLOCK 2459 SB_ONDISK_JOURNAL_1st_BLOCK
2455 (p_s_sb), oldest_trans_id); 2460 (sb), oldest_trans_id);
2456 } else if (oldest_trans_id > get_desc_trans_id(desc)) { 2461 } else if (oldest_trans_id > get_desc_trans_id(desc)) {
2457 /* one we just read was older */ 2462 /* one we just read was older */
2458 oldest_trans_id = get_desc_trans_id(desc); 2463 oldest_trans_id = get_desc_trans_id(desc);
2459 oldest_start = d_bh->b_blocknr; 2464 oldest_start = d_bh->b_blocknr;
2460 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2465 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2461 "journal-1180: Resetting " 2466 "journal-1180: Resetting "
2462 "oldest_start to offset %lu, trans_id %lu", 2467 "oldest_start to offset %lu, trans_id %lu",
2463 oldest_start - 2468 oldest_start -
2464 SB_ONDISK_JOURNAL_1st_BLOCK 2469 SB_ONDISK_JOURNAL_1st_BLOCK
2465 (p_s_sb), oldest_trans_id); 2470 (sb), oldest_trans_id);
2466 } 2471 }
2467 if (newest_mount_id < get_desc_mount_id(desc)) { 2472 if (newest_mount_id < get_desc_mount_id(desc)) {
2468 newest_mount_id = get_desc_mount_id(desc); 2473 newest_mount_id = get_desc_mount_id(desc);
2469 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2474 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2470 "journal-1299: Setting " 2475 "journal-1299: Setting "
2471 "newest_mount_id to %d", 2476 "newest_mount_id to %d",
2472 get_desc_mount_id(desc)); 2477 get_desc_mount_id(desc));
@@ -2481,17 +2486,17 @@ static int journal_read(struct super_block *p_s_sb)
2481 start_log_replay: 2486 start_log_replay:
2482 cur_dblock = oldest_start; 2487 cur_dblock = oldest_start;
2483 if (oldest_trans_id) { 2488 if (oldest_trans_id) {
2484 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2489 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2485 "journal-1206: Starting replay " 2490 "journal-1206: Starting replay "
2486 "from offset %llu, trans_id %lu", 2491 "from offset %llu, trans_id %lu",
2487 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2492 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2488 oldest_trans_id); 2493 oldest_trans_id);
2489 2494
2490 } 2495 }
2491 replay_count = 0; 2496 replay_count = 0;
2492 while (continue_replay && oldest_trans_id > 0) { 2497 while (continue_replay && oldest_trans_id > 0) {
2493 ret = 2498 ret =
2494 journal_read_transaction(p_s_sb, cur_dblock, oldest_start, 2499 journal_read_transaction(sb, cur_dblock, oldest_start,
2495 oldest_trans_id, newest_mount_id); 2500 oldest_trans_id, newest_mount_id);
2496 if (ret < 0) { 2501 if (ret < 0) {
2497 return ret; 2502 return ret;
@@ -2499,14 +2504,14 @@ static int journal_read(struct super_block *p_s_sb)
2499 break; 2504 break;
2500 } 2505 }
2501 cur_dblock = 2506 cur_dblock =
2502 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + journal->j_start; 2507 SB_ONDISK_JOURNAL_1st_BLOCK(sb) + journal->j_start;
2503 replay_count++; 2508 replay_count++;
2504 if (cur_dblock == oldest_start) 2509 if (cur_dblock == oldest_start)
2505 break; 2510 break;
2506 } 2511 }
2507 2512
2508 if (oldest_trans_id == 0) { 2513 if (oldest_trans_id == 0) {
2509 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, 2514 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2510 "journal-1225: No valid " "transactions found"); 2515 "journal-1225: No valid " "transactions found");
2511 } 2516 }
2512 /* j_start does not get set correctly if we don't replay any transactions. 2517 /* j_start does not get set correctly if we don't replay any transactions.
@@ -2526,16 +2531,16 @@ static int journal_read(struct super_block *p_s_sb)
2526 } else { 2531 } else {
2527 journal->j_mount_id = newest_mount_id + 1; 2532 journal->j_mount_id = newest_mount_id + 1;
2528 } 2533 }
2529 reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, "journal-1299: Setting " 2534 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1299: Setting "
2530 "newest_mount_id to %lu", journal->j_mount_id); 2535 "newest_mount_id to %lu", journal->j_mount_id);
2531 journal->j_first_unflushed_offset = journal->j_start; 2536 journal->j_first_unflushed_offset = journal->j_start;
2532 if (replay_count > 0) { 2537 if (replay_count > 0) {
2533 reiserfs_info(p_s_sb, 2538 reiserfs_info(sb,
2534 "replayed %d transactions in %lu seconds\n", 2539 "replayed %d transactions in %lu seconds\n",
2535 replay_count, get_seconds() - start); 2540 replay_count, get_seconds() - start);
2536 } 2541 }
2537 if (!bdev_read_only(p_s_sb->s_bdev) && 2542 if (!bdev_read_only(sb->s_bdev) &&
2538 _update_journal_header_block(p_s_sb, journal->j_start, 2543 _update_journal_header_block(sb, journal->j_start,
2539 journal->j_last_flush_trans_id)) { 2544 journal->j_last_flush_trans_id)) {
2540 /* replay failed, caller must call free_journal_ram and abort 2545 /* replay failed, caller must call free_journal_ram and abort
2541 ** the mount 2546 ** the mount
@@ -2560,9 +2565,9 @@ static struct reiserfs_journal_list *alloc_journal_list(struct super_block *s)
2560 return jl; 2565 return jl;
2561} 2566}
2562 2567
2563static void journal_list_init(struct super_block *p_s_sb) 2568static void journal_list_init(struct super_block *sb)
2564{ 2569{
2565 SB_JOURNAL(p_s_sb)->j_current_jl = alloc_journal_list(p_s_sb); 2570 SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb);
2566} 2571}
2567 2572
2568static int release_journal_dev(struct super_block *super, 2573static int release_journal_dev(struct super_block *super,
@@ -2580,9 +2585,8 @@ static int release_journal_dev(struct super_block *super,
2580 } 2585 }
2581 2586
2582 if (result != 0) { 2587 if (result != 0) {
2583 reiserfs_warning(super, 2588 reiserfs_warning(super, "sh-457",
2584 "sh-457: release_journal_dev: Cannot release journal device: %i", 2589 "Cannot release journal device: %i", result);
2585 result);
2586 } 2590 }
2587 return result; 2591 return result;
2588} 2592}
@@ -2612,7 +2616,7 @@ static int journal_init_dev(struct super_block *super,
2612 if (IS_ERR(journal->j_dev_bd)) { 2616 if (IS_ERR(journal->j_dev_bd)) {
2613 result = PTR_ERR(journal->j_dev_bd); 2617 result = PTR_ERR(journal->j_dev_bd);
2614 journal->j_dev_bd = NULL; 2618 journal->j_dev_bd = NULL;
2615 reiserfs_warning(super, "sh-458: journal_init_dev: " 2619 reiserfs_warning(super, "sh-458",
2616 "cannot init journal device '%s': %i", 2620 "cannot init journal device '%s': %i",
2617 __bdevname(jdev, b), result); 2621 __bdevname(jdev, b), result);
2618 return result; 2622 return result;
@@ -2662,30 +2666,30 @@ static int journal_init_dev(struct super_block *super,
2662 */ 2666 */
2663#define REISERFS_STANDARD_BLKSIZE (4096) 2667#define REISERFS_STANDARD_BLKSIZE (4096)
2664 2668
2665static int check_advise_trans_params(struct super_block *p_s_sb, 2669static int check_advise_trans_params(struct super_block *sb,
2666 struct reiserfs_journal *journal) 2670 struct reiserfs_journal *journal)
2667{ 2671{
2668 if (journal->j_trans_max) { 2672 if (journal->j_trans_max) {
2669 /* Non-default journal params. 2673 /* Non-default journal params.
2670 Do sanity check for them. */ 2674 Do sanity check for them. */
2671 int ratio = 1; 2675 int ratio = 1;
2672 if (p_s_sb->s_blocksize < REISERFS_STANDARD_BLKSIZE) 2676 if (sb->s_blocksize < REISERFS_STANDARD_BLKSIZE)
2673 ratio = REISERFS_STANDARD_BLKSIZE / p_s_sb->s_blocksize; 2677 ratio = REISERFS_STANDARD_BLKSIZE / sb->s_blocksize;
2674 2678
2675 if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio || 2679 if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio ||
2676 journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio || 2680 journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio ||
2677 SB_ONDISK_JOURNAL_SIZE(p_s_sb) / journal->j_trans_max < 2681 SB_ONDISK_JOURNAL_SIZE(sb) / journal->j_trans_max <
2678 JOURNAL_MIN_RATIO) { 2682 JOURNAL_MIN_RATIO) {
2679 reiserfs_warning(p_s_sb, 2683 reiserfs_warning(sb, "sh-462",
2680 "sh-462: bad transaction max size (%u). FSCK?", 2684 "bad transaction max size (%u). "
2681 journal->j_trans_max); 2685 "FSCK?", journal->j_trans_max);
2682 return 1; 2686 return 1;
2683 } 2687 }
2684 if (journal->j_max_batch != (journal->j_trans_max) * 2688 if (journal->j_max_batch != (journal->j_trans_max) *
2685 JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) { 2689 JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) {
2686 reiserfs_warning(p_s_sb, 2690 reiserfs_warning(sb, "sh-463",
2687 "sh-463: bad transaction max batch (%u). FSCK?", 2691 "bad transaction max batch (%u). "
2688 journal->j_max_batch); 2692 "FSCK?", journal->j_max_batch);
2689 return 1; 2693 return 1;
2690 } 2694 }
2691 } else { 2695 } else {
@@ -2693,9 +2697,11 @@ static int check_advise_trans_params(struct super_block *p_s_sb,
2693 The file system was created by old version 2697 The file system was created by old version
2694 of mkreiserfs, so some fields contain zeros, 2698 of mkreiserfs, so some fields contain zeros,
2695 and we need to advise proper values for them */ 2699 and we need to advise proper values for them */
2696 if (p_s_sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) 2700 if (sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) {
2697 reiserfs_panic(p_s_sb, "sh-464: bad blocksize (%u)", 2701 reiserfs_warning(sb, "sh-464", "bad blocksize (%u)",
2698 p_s_sb->s_blocksize); 2702 sb->s_blocksize);
2703 return 1;
2704 }
2699 journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT; 2705 journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
2700 journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT; 2706 journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
2701 journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE; 2707 journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
@@ -2706,10 +2712,10 @@ static int check_advise_trans_params(struct super_block *p_s_sb,
2706/* 2712/*
2707** must be called once on fs mount. calls journal_read for you 2713** must be called once on fs mount. calls journal_read for you
2708*/ 2714*/
2709int journal_init(struct super_block *p_s_sb, const char *j_dev_name, 2715int journal_init(struct super_block *sb, const char *j_dev_name,
2710 int old_format, unsigned int commit_max_age) 2716 int old_format, unsigned int commit_max_age)
2711{ 2717{
2712 int num_cnodes = SB_ONDISK_JOURNAL_SIZE(p_s_sb) * 2; 2718 int num_cnodes = SB_ONDISK_JOURNAL_SIZE(sb) * 2;
2713 struct buffer_head *bhjh; 2719 struct buffer_head *bhjh;
2714 struct reiserfs_super_block *rs; 2720 struct reiserfs_super_block *rs;
2715 struct reiserfs_journal_header *jh; 2721 struct reiserfs_journal_header *jh;
@@ -2717,10 +2723,10 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2717 struct reiserfs_journal_list *jl; 2723 struct reiserfs_journal_list *jl;
2718 char b[BDEVNAME_SIZE]; 2724 char b[BDEVNAME_SIZE];
2719 2725
2720 journal = SB_JOURNAL(p_s_sb) = vmalloc(sizeof(struct reiserfs_journal)); 2726 journal = SB_JOURNAL(sb) = vmalloc(sizeof(struct reiserfs_journal));
2721 if (!journal) { 2727 if (!journal) {
2722 reiserfs_warning(p_s_sb, 2728 reiserfs_warning(sb, "journal-1256",
2723 "journal-1256: unable to get memory for journal structure"); 2729 "unable to get memory for journal structure");
2724 return 1; 2730 return 1;
2725 } 2731 }
2726 memset(journal, 0, sizeof(struct reiserfs_journal)); 2732 memset(journal, 0, sizeof(struct reiserfs_journal));
@@ -2729,51 +2735,51 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2729 INIT_LIST_HEAD(&journal->j_working_list); 2735 INIT_LIST_HEAD(&journal->j_working_list);
2730 INIT_LIST_HEAD(&journal->j_journal_list); 2736 INIT_LIST_HEAD(&journal->j_journal_list);
2731 journal->j_persistent_trans = 0; 2737 journal->j_persistent_trans = 0;
2732 if (reiserfs_allocate_list_bitmaps(p_s_sb, 2738 if (reiserfs_allocate_list_bitmaps(sb,
2733 journal->j_list_bitmap, 2739 journal->j_list_bitmap,
2734 reiserfs_bmap_count(p_s_sb))) 2740 reiserfs_bmap_count(sb)))
2735 goto free_and_return; 2741 goto free_and_return;
2736 allocate_bitmap_nodes(p_s_sb); 2742 allocate_bitmap_nodes(sb);
2737 2743
2738 /* reserved for journal area support */ 2744 /* reserved for journal area support */
2739 SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb) = (old_format ? 2745 SB_JOURNAL_1st_RESERVED_BLOCK(sb) = (old_format ?
2740 REISERFS_OLD_DISK_OFFSET_IN_BYTES 2746 REISERFS_OLD_DISK_OFFSET_IN_BYTES
2741 / p_s_sb->s_blocksize + 2747 / sb->s_blocksize +
2742 reiserfs_bmap_count(p_s_sb) + 2748 reiserfs_bmap_count(sb) +
2743 1 : 2749 1 :
2744 REISERFS_DISK_OFFSET_IN_BYTES / 2750 REISERFS_DISK_OFFSET_IN_BYTES /
2745 p_s_sb->s_blocksize + 2); 2751 sb->s_blocksize + 2);
2746 2752
2747 /* Sanity check to see is the standard journal fitting withing first bitmap 2753 /* Sanity check to see is the standard journal fitting withing first bitmap
2748 (actual for small blocksizes) */ 2754 (actual for small blocksizes) */
2749 if (!SB_ONDISK_JOURNAL_DEVICE(p_s_sb) && 2755 if (!SB_ONDISK_JOURNAL_DEVICE(sb) &&
2750 (SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb) + 2756 (SB_JOURNAL_1st_RESERVED_BLOCK(sb) +
2751 SB_ONDISK_JOURNAL_SIZE(p_s_sb) > p_s_sb->s_blocksize * 8)) { 2757 SB_ONDISK_JOURNAL_SIZE(sb) > sb->s_blocksize * 8)) {
2752 reiserfs_warning(p_s_sb, 2758 reiserfs_warning(sb, "journal-1393",
2753 "journal-1393: journal does not fit for area " 2759 "journal does not fit for area addressed "
2754 "addressed by first of bitmap blocks. It starts at " 2760 "by first of bitmap blocks. It starts at "
2755 "%u and its size is %u. Block size %ld", 2761 "%u and its size is %u. Block size %ld",
2756 SB_JOURNAL_1st_RESERVED_BLOCK(p_s_sb), 2762 SB_JOURNAL_1st_RESERVED_BLOCK(sb),
2757 SB_ONDISK_JOURNAL_SIZE(p_s_sb), 2763 SB_ONDISK_JOURNAL_SIZE(sb),
2758 p_s_sb->s_blocksize); 2764 sb->s_blocksize);
2759 goto free_and_return; 2765 goto free_and_return;
2760 } 2766 }
2761 2767
2762 if (journal_init_dev(p_s_sb, journal, j_dev_name) != 0) { 2768 if (journal_init_dev(sb, journal, j_dev_name) != 0) {
2763 reiserfs_warning(p_s_sb, 2769 reiserfs_warning(sb, "sh-462",
2764 "sh-462: unable to initialize jornal device"); 2770 "unable to initialize jornal device");
2765 goto free_and_return; 2771 goto free_and_return;
2766 } 2772 }
2767 2773
2768 rs = SB_DISK_SUPER_BLOCK(p_s_sb); 2774 rs = SB_DISK_SUPER_BLOCK(sb);
2769 2775
2770 /* read journal header */ 2776 /* read journal header */
2771 bhjh = journal_bread(p_s_sb, 2777 bhjh = journal_bread(sb,
2772 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 2778 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2773 SB_ONDISK_JOURNAL_SIZE(p_s_sb)); 2779 SB_ONDISK_JOURNAL_SIZE(sb));
2774 if (!bhjh) { 2780 if (!bhjh) {
2775 reiserfs_warning(p_s_sb, 2781 reiserfs_warning(sb, "sh-459",
2776 "sh-459: unable to read journal header"); 2782 "unable to read journal header");
2777 goto free_and_return; 2783 goto free_and_return;
2778 } 2784 }
2779 jh = (struct reiserfs_journal_header *)(bhjh->b_data); 2785 jh = (struct reiserfs_journal_header *)(bhjh->b_data);
@@ -2782,10 +2788,10 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2782 if (is_reiserfs_jr(rs) 2788 if (is_reiserfs_jr(rs)
2783 && (le32_to_cpu(jh->jh_journal.jp_journal_magic) != 2789 && (le32_to_cpu(jh->jh_journal.jp_journal_magic) !=
2784 sb_jp_journal_magic(rs))) { 2790 sb_jp_journal_magic(rs))) {
2785 reiserfs_warning(p_s_sb, 2791 reiserfs_warning(sb, "sh-460",
2786 "sh-460: journal header magic %x " 2792 "journal header magic %x (device %s) does "
2787 "(device %s) does not match to magic found in super " 2793 "not match to magic found in super block %x",
2788 "block %x", jh->jh_journal.jp_journal_magic, 2794 jh->jh_journal.jp_journal_magic,
2789 bdevname(journal->j_dev_bd, b), 2795 bdevname(journal->j_dev_bd, b),
2790 sb_jp_journal_magic(rs)); 2796 sb_jp_journal_magic(rs));
2791 brelse(bhjh); 2797 brelse(bhjh);
@@ -2798,7 +2804,7 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2798 le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age); 2804 le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age);
2799 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE; 2805 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
2800 2806
2801 if (check_advise_trans_params(p_s_sb, journal) != 0) 2807 if (check_advise_trans_params(sb, journal) != 0)
2802 goto free_and_return; 2808 goto free_and_return;
2803 journal->j_default_max_commit_age = journal->j_max_commit_age; 2809 journal->j_default_max_commit_age = journal->j_max_commit_age;
2804 2810
@@ -2807,12 +2813,12 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2807 journal->j_max_trans_age = commit_max_age; 2813 journal->j_max_trans_age = commit_max_age;
2808 } 2814 }
2809 2815
2810 reiserfs_info(p_s_sb, "journal params: device %s, size %u, " 2816 reiserfs_info(sb, "journal params: device %s, size %u, "
2811 "journal first block %u, max trans len %u, max batch %u, " 2817 "journal first block %u, max trans len %u, max batch %u, "
2812 "max commit age %u, max trans age %u\n", 2818 "max commit age %u, max trans age %u\n",
2813 bdevname(journal->j_dev_bd, b), 2819 bdevname(journal->j_dev_bd, b),
2814 SB_ONDISK_JOURNAL_SIZE(p_s_sb), 2820 SB_ONDISK_JOURNAL_SIZE(sb),
2815 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb), 2821 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2816 journal->j_trans_max, 2822 journal->j_trans_max,
2817 journal->j_max_batch, 2823 journal->j_max_batch,
2818 journal->j_max_commit_age, journal->j_max_trans_age); 2824 journal->j_max_commit_age, journal->j_max_trans_age);
@@ -2820,7 +2826,7 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2820 brelse(bhjh); 2826 brelse(bhjh);
2821 2827
2822 journal->j_list_bitmap_index = 0; 2828 journal->j_list_bitmap_index = 0;
2823 journal_list_init(p_s_sb); 2829 journal_list_init(sb);
2824 2830
2825 memset(journal->j_list_hash_table, 0, 2831 memset(journal->j_list_hash_table, 0,
2826 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *)); 2832 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
@@ -2852,7 +2858,7 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2852 journal->j_must_wait = 0; 2858 journal->j_must_wait = 0;
2853 2859
2854 if (journal->j_cnode_free == 0) { 2860 if (journal->j_cnode_free == 0) {
2855 reiserfs_warning(p_s_sb, "journal-2004: Journal cnode memory " 2861 reiserfs_warning(sb, "journal-2004", "Journal cnode memory "
2856 "allocation failed (%ld bytes). Journal is " 2862 "allocation failed (%ld bytes). Journal is "
2857 "too large for available memory. Usually " 2863 "too large for available memory. Usually "
2858 "this is due to a journal that is too large.", 2864 "this is due to a journal that is too large.",
@@ -2860,16 +2866,17 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2860 goto free_and_return; 2866 goto free_and_return;
2861 } 2867 }
2862 2868
2863 init_journal_hash(p_s_sb); 2869 init_journal_hash(sb);
2864 jl = journal->j_current_jl; 2870 jl = journal->j_current_jl;
2865 jl->j_list_bitmap = get_list_bitmap(p_s_sb, jl); 2871 jl->j_list_bitmap = get_list_bitmap(sb, jl);
2866 if (!jl->j_list_bitmap) { 2872 if (!jl->j_list_bitmap) {
2867 reiserfs_warning(p_s_sb, 2873 reiserfs_warning(sb, "journal-2005",
2868 "journal-2005, get_list_bitmap failed for journal list 0"); 2874 "get_list_bitmap failed for journal list 0");
2869 goto free_and_return; 2875 goto free_and_return;
2870 } 2876 }
2871 if (journal_read(p_s_sb) < 0) { 2877 if (journal_read(sb) < 0) {
2872 reiserfs_warning(p_s_sb, "Replay Failure, unable to mount"); 2878 reiserfs_warning(sb, "reiserfs-2006",
2879 "Replay Failure, unable to mount");
2873 goto free_and_return; 2880 goto free_and_return;
2874 } 2881 }
2875 2882
@@ -2878,10 +2885,10 @@ int journal_init(struct super_block *p_s_sb, const char *j_dev_name,
2878 commit_wq = create_workqueue("reiserfs"); 2885 commit_wq = create_workqueue("reiserfs");
2879 2886
2880 INIT_DELAYED_WORK(&journal->j_work, flush_async_commits); 2887 INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
2881 journal->j_work_sb = p_s_sb; 2888 journal->j_work_sb = sb;
2882 return 0; 2889 return 0;
2883 free_and_return: 2890 free_and_return:
2884 free_journal_ram(p_s_sb); 2891 free_journal_ram(sb);
2885 return 1; 2892 return 1;
2886} 2893}
2887 2894
@@ -2912,7 +2919,7 @@ int journal_transaction_should_end(struct reiserfs_transaction_handle *th,
2912 return 0; 2919 return 0;
2913} 2920}
2914 2921
2915/* this must be called inside a transaction, and requires the 2922/* this must be called inside a transaction, and requires the
2916** kernel_lock to be held 2923** kernel_lock to be held
2917*/ 2924*/
2918void reiserfs_block_writes(struct reiserfs_transaction_handle *th) 2925void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
@@ -2970,7 +2977,7 @@ static void wake_queued_writers(struct super_block *s)
2970 wake_up(&journal->j_join_wait); 2977 wake_up(&journal->j_join_wait);
2971} 2978}
2972 2979
2973static void let_transaction_grow(struct super_block *sb, unsigned long trans_id) 2980static void let_transaction_grow(struct super_block *sb, unsigned int trans_id)
2974{ 2981{
2975 struct reiserfs_journal *journal = SB_JOURNAL(sb); 2982 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2976 unsigned long bcount = journal->j_bcount; 2983 unsigned long bcount = journal->j_bcount;
@@ -2997,43 +3004,43 @@ static void let_transaction_grow(struct super_block *sb, unsigned long trans_id)
2997** expect to use in nblocks. 3004** expect to use in nblocks.
2998*/ 3005*/
2999static int do_journal_begin_r(struct reiserfs_transaction_handle *th, 3006static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3000 struct super_block *p_s_sb, unsigned long nblocks, 3007 struct super_block *sb, unsigned long nblocks,
3001 int join) 3008 int join)
3002{ 3009{
3003 time_t now = get_seconds(); 3010 time_t now = get_seconds();
3004 int old_trans_id; 3011 unsigned int old_trans_id;
3005 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3012 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3006 struct reiserfs_transaction_handle myth; 3013 struct reiserfs_transaction_handle myth;
3007 int sched_count = 0; 3014 int sched_count = 0;
3008 int retval; 3015 int retval;
3009 3016
3010 reiserfs_check_lock_depth(p_s_sb, "journal_begin"); 3017 reiserfs_check_lock_depth(sb, "journal_begin");
3011 BUG_ON(nblocks > journal->j_trans_max); 3018 BUG_ON(nblocks > journal->j_trans_max);
3012 3019
3013 PROC_INFO_INC(p_s_sb, journal.journal_being); 3020 PROC_INFO_INC(sb, journal.journal_being);
3014 /* set here for journal_join */ 3021 /* set here for journal_join */
3015 th->t_refcount = 1; 3022 th->t_refcount = 1;
3016 th->t_super = p_s_sb; 3023 th->t_super = sb;
3017 3024
3018 relock: 3025 relock:
3019 lock_journal(p_s_sb); 3026 lock_journal(sb);
3020 if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) { 3027 if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
3021 unlock_journal(p_s_sb); 3028 unlock_journal(sb);
3022 retval = journal->j_errno; 3029 retval = journal->j_errno;
3023 goto out_fail; 3030 goto out_fail;
3024 } 3031 }
3025 journal->j_bcount++; 3032 journal->j_bcount++;
3026 3033
3027 if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) { 3034 if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
3028 unlock_journal(p_s_sb); 3035 unlock_journal(sb);
3029 reiserfs_wait_on_write_block(p_s_sb); 3036 reiserfs_wait_on_write_block(sb);
3030 PROC_INFO_INC(p_s_sb, journal.journal_relock_writers); 3037 PROC_INFO_INC(sb, journal.journal_relock_writers);
3031 goto relock; 3038 goto relock;
3032 } 3039 }
3033 now = get_seconds(); 3040 now = get_seconds();
3034 3041
3035 /* if there is no room in the journal OR 3042 /* if there is no room in the journal OR
3036 ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning 3043 ** if this transaction is too old, and we weren't called joinable, wait for it to finish before beginning
3037 ** we don't sleep if there aren't other writers 3044 ** we don't sleep if there aren't other writers
3038 */ 3045 */
3039 3046
@@ -3048,7 +3055,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3048 || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) { 3055 || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
3049 3056
3050 old_trans_id = journal->j_trans_id; 3057 old_trans_id = journal->j_trans_id;
3051 unlock_journal(p_s_sb); /* allow others to finish this transaction */ 3058 unlock_journal(sb); /* allow others to finish this transaction */
3052 3059
3053 if (!join && (journal->j_len_alloc + nblocks + 2) >= 3060 if (!join && (journal->j_len_alloc + nblocks + 2) >=
3054 journal->j_max_batch && 3061 journal->j_max_batch &&
@@ -3056,7 +3063,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3056 (journal->j_len_alloc * 75)) { 3063 (journal->j_len_alloc * 75)) {
3057 if (atomic_read(&journal->j_wcount) > 10) { 3064 if (atomic_read(&journal->j_wcount) > 10) {
3058 sched_count++; 3065 sched_count++;
3059 queue_log_writer(p_s_sb); 3066 queue_log_writer(sb);
3060 goto relock; 3067 goto relock;
3061 } 3068 }
3062 } 3069 }
@@ -3066,25 +3073,25 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3066 if (atomic_read(&journal->j_jlock)) { 3073 if (atomic_read(&journal->j_jlock)) {
3067 while (journal->j_trans_id == old_trans_id && 3074 while (journal->j_trans_id == old_trans_id &&
3068 atomic_read(&journal->j_jlock)) { 3075 atomic_read(&journal->j_jlock)) {
3069 queue_log_writer(p_s_sb); 3076 queue_log_writer(sb);
3070 } 3077 }
3071 goto relock; 3078 goto relock;
3072 } 3079 }
3073 retval = journal_join(&myth, p_s_sb, 1); 3080 retval = journal_join(&myth, sb, 1);
3074 if (retval) 3081 if (retval)
3075 goto out_fail; 3082 goto out_fail;
3076 3083
3077 /* someone might have ended the transaction while we joined */ 3084 /* someone might have ended the transaction while we joined */
3078 if (old_trans_id != journal->j_trans_id) { 3085 if (old_trans_id != journal->j_trans_id) {
3079 retval = do_journal_end(&myth, p_s_sb, 1, 0); 3086 retval = do_journal_end(&myth, sb, 1, 0);
3080 } else { 3087 } else {
3081 retval = do_journal_end(&myth, p_s_sb, 1, COMMIT_NOW); 3088 retval = do_journal_end(&myth, sb, 1, COMMIT_NOW);
3082 } 3089 }
3083 3090
3084 if (retval) 3091 if (retval)
3085 goto out_fail; 3092 goto out_fail;
3086 3093
3087 PROC_INFO_INC(p_s_sb, journal.journal_relock_wcount); 3094 PROC_INFO_INC(sb, journal.journal_relock_wcount);
3088 goto relock; 3095 goto relock;
3089 } 3096 }
3090 /* we are the first writer, set trans_id */ 3097 /* we are the first writer, set trans_id */
@@ -3096,7 +3103,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3096 th->t_blocks_logged = 0; 3103 th->t_blocks_logged = 0;
3097 th->t_blocks_allocated = nblocks; 3104 th->t_blocks_allocated = nblocks;
3098 th->t_trans_id = journal->j_trans_id; 3105 th->t_trans_id = journal->j_trans_id;
3099 unlock_journal(p_s_sb); 3106 unlock_journal(sb);
3100 INIT_LIST_HEAD(&th->t_list); 3107 INIT_LIST_HEAD(&th->t_list);
3101 get_fs_excl(); 3108 get_fs_excl();
3102 return 0; 3109 return 0;
@@ -3106,7 +3113,7 @@ static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3106 /* Re-set th->t_super, so we can properly keep track of how many 3113 /* Re-set th->t_super, so we can properly keep track of how many
3107 * persistent transactions there are. We need to do this so if this 3114 * persistent transactions there are. We need to do this so if this
3108 * call is part of a failed restart_transaction, we can free it later */ 3115 * call is part of a failed restart_transaction, we can free it later */
3109 th->t_super = p_s_sb; 3116 th->t_super = sb;
3110 return retval; 3117 return retval;
3111} 3118}
3112 3119
@@ -3157,7 +3164,7 @@ int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th)
3157} 3164}
3158 3165
3159static int journal_join(struct reiserfs_transaction_handle *th, 3166static int journal_join(struct reiserfs_transaction_handle *th,
3160 struct super_block *p_s_sb, unsigned long nblocks) 3167 struct super_block *sb, unsigned long nblocks)
3161{ 3168{
3162 struct reiserfs_transaction_handle *cur_th = current->journal_info; 3169 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3163 3170
@@ -3166,11 +3173,11 @@ static int journal_join(struct reiserfs_transaction_handle *th,
3166 */ 3173 */
3167 th->t_handle_save = cur_th; 3174 th->t_handle_save = cur_th;
3168 BUG_ON(cur_th && cur_th->t_refcount > 1); 3175 BUG_ON(cur_th && cur_th->t_refcount > 1);
3169 return do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_JOIN); 3176 return do_journal_begin_r(th, sb, nblocks, JBEGIN_JOIN);
3170} 3177}
3171 3178
3172int journal_join_abort(struct reiserfs_transaction_handle *th, 3179int journal_join_abort(struct reiserfs_transaction_handle *th,
3173 struct super_block *p_s_sb, unsigned long nblocks) 3180 struct super_block *sb, unsigned long nblocks)
3174{ 3181{
3175 struct reiserfs_transaction_handle *cur_th = current->journal_info; 3182 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3176 3183
@@ -3179,11 +3186,11 @@ int journal_join_abort(struct reiserfs_transaction_handle *th,
3179 */ 3186 */
3180 th->t_handle_save = cur_th; 3187 th->t_handle_save = cur_th;
3181 BUG_ON(cur_th && cur_th->t_refcount > 1); 3188 BUG_ON(cur_th && cur_th->t_refcount > 1);
3182 return do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_ABORT); 3189 return do_journal_begin_r(th, sb, nblocks, JBEGIN_ABORT);
3183} 3190}
3184 3191
3185int journal_begin(struct reiserfs_transaction_handle *th, 3192int journal_begin(struct reiserfs_transaction_handle *th,
3186 struct super_block *p_s_sb, unsigned long nblocks) 3193 struct super_block *sb, unsigned long nblocks)
3187{ 3194{
3188 struct reiserfs_transaction_handle *cur_th = current->journal_info; 3195 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3189 int ret; 3196 int ret;
@@ -3191,28 +3198,29 @@ int journal_begin(struct reiserfs_transaction_handle *th,
3191 th->t_handle_save = NULL; 3198 th->t_handle_save = NULL;
3192 if (cur_th) { 3199 if (cur_th) {
3193 /* we are nesting into the current transaction */ 3200 /* we are nesting into the current transaction */
3194 if (cur_th->t_super == p_s_sb) { 3201 if (cur_th->t_super == sb) {
3195 BUG_ON(!cur_th->t_refcount); 3202 BUG_ON(!cur_th->t_refcount);
3196 cur_th->t_refcount++; 3203 cur_th->t_refcount++;
3197 memcpy(th, cur_th, sizeof(*th)); 3204 memcpy(th, cur_th, sizeof(*th));
3198 if (th->t_refcount <= 1) 3205 if (th->t_refcount <= 1)
3199 reiserfs_warning(p_s_sb, 3206 reiserfs_warning(sb, "reiserfs-2005",
3200 "BAD: refcount <= 1, but journal_info != 0"); 3207 "BAD: refcount <= 1, but "
3208 "journal_info != 0");
3201 return 0; 3209 return 0;
3202 } else { 3210 } else {
3203 /* we've ended up with a handle from a different filesystem. 3211 /* we've ended up with a handle from a different filesystem.
3204 ** save it and restore on journal_end. This should never 3212 ** save it and restore on journal_end. This should never
3205 ** really happen... 3213 ** really happen...
3206 */ 3214 */
3207 reiserfs_warning(p_s_sb, 3215 reiserfs_warning(sb, "clm-2100",
3208 "clm-2100: nesting info a different FS"); 3216 "nesting info a different FS");
3209 th->t_handle_save = current->journal_info; 3217 th->t_handle_save = current->journal_info;
3210 current->journal_info = th; 3218 current->journal_info = th;
3211 } 3219 }
3212 } else { 3220 } else {
3213 current->journal_info = th; 3221 current->journal_info = th;
3214 } 3222 }
3215 ret = do_journal_begin_r(th, p_s_sb, nblocks, JBEGIN_REG); 3223 ret = do_journal_begin_r(th, sb, nblocks, JBEGIN_REG);
3216 BUG_ON(current->journal_info != th); 3224 BUG_ON(current->journal_info != th);
3217 3225
3218 /* I guess this boils down to being the reciprocal of clm-2100 above. 3226 /* I guess this boils down to being the reciprocal of clm-2100 above.
@@ -3232,32 +3240,32 @@ int journal_begin(struct reiserfs_transaction_handle *th,
3232** 3240**
3233** if it was dirty, cleans and files onto the clean list. I can't let it be dirty again until the 3241** if it was dirty, cleans and files onto the clean list. I can't let it be dirty again until the
3234** transaction is committed. 3242** transaction is committed.
3235** 3243**
3236** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len. 3244** if j_len, is bigger than j_len_alloc, it pushes j_len_alloc to 10 + j_len.
3237*/ 3245*/
3238int journal_mark_dirty(struct reiserfs_transaction_handle *th, 3246int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3239 struct super_block *p_s_sb, struct buffer_head *bh) 3247 struct super_block *sb, struct buffer_head *bh)
3240{ 3248{
3241 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3249 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3242 struct reiserfs_journal_cnode *cn = NULL; 3250 struct reiserfs_journal_cnode *cn = NULL;
3243 int count_already_incd = 0; 3251 int count_already_incd = 0;
3244 int prepared = 0; 3252 int prepared = 0;
3245 BUG_ON(!th->t_trans_id); 3253 BUG_ON(!th->t_trans_id);
3246 3254
3247 PROC_INFO_INC(p_s_sb, journal.mark_dirty); 3255 PROC_INFO_INC(sb, journal.mark_dirty);
3248 if (th->t_trans_id != journal->j_trans_id) { 3256 if (th->t_trans_id != journal->j_trans_id) {
3249 reiserfs_panic(th->t_super, 3257 reiserfs_panic(th->t_super, "journal-1577",
3250 "journal-1577: handle trans id %ld != current trans id %ld\n", 3258 "handle trans id %ld != current trans id %ld",
3251 th->t_trans_id, journal->j_trans_id); 3259 th->t_trans_id, journal->j_trans_id);
3252 } 3260 }
3253 3261
3254 p_s_sb->s_dirt = 1; 3262 sb->s_dirt = 1;
3255 3263
3256 prepared = test_clear_buffer_journal_prepared(bh); 3264 prepared = test_clear_buffer_journal_prepared(bh);
3257 clear_buffer_journal_restore_dirty(bh); 3265 clear_buffer_journal_restore_dirty(bh);
3258 /* already in this transaction, we are done */ 3266 /* already in this transaction, we are done */
3259 if (buffer_journaled(bh)) { 3267 if (buffer_journaled(bh)) {
3260 PROC_INFO_INC(p_s_sb, journal.mark_dirty_already); 3268 PROC_INFO_INC(sb, journal.mark_dirty_already);
3261 return 0; 3269 return 0;
3262 } 3270 }
3263 3271
@@ -3266,7 +3274,8 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3266 ** could get to disk too early. NOT GOOD. 3274 ** could get to disk too early. NOT GOOD.
3267 */ 3275 */
3268 if (!prepared || buffer_dirty(bh)) { 3276 if (!prepared || buffer_dirty(bh)) {
3269 reiserfs_warning(p_s_sb, "journal-1777: buffer %llu bad state " 3277 reiserfs_warning(sb, "journal-1777",
3278 "buffer %llu bad state "
3270 "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT", 3279 "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT",
3271 (unsigned long long)bh->b_blocknr, 3280 (unsigned long long)bh->b_blocknr,
3272 prepared ? ' ' : '!', 3281 prepared ? ' ' : '!',
@@ -3276,23 +3285,23 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3276 } 3285 }
3277 3286
3278 if (atomic_read(&(journal->j_wcount)) <= 0) { 3287 if (atomic_read(&(journal->j_wcount)) <= 0) {
3279 reiserfs_warning(p_s_sb, 3288 reiserfs_warning(sb, "journal-1409",
3280 "journal-1409: journal_mark_dirty returning because j_wcount was %d", 3289 "returning because j_wcount was %d",
3281 atomic_read(&(journal->j_wcount))); 3290 atomic_read(&(journal->j_wcount)));
3282 return 1; 3291 return 1;
3283 } 3292 }
3284 /* this error means I've screwed up, and we've overflowed the transaction. 3293 /* this error means I've screwed up, and we've overflowed the transaction.
3285 ** Nothing can be done here, except make the FS readonly or panic. 3294 ** Nothing can be done here, except make the FS readonly or panic.
3286 */ 3295 */
3287 if (journal->j_len >= journal->j_trans_max) { 3296 if (journal->j_len >= journal->j_trans_max) {
3288 reiserfs_panic(th->t_super, 3297 reiserfs_panic(th->t_super, "journal-1413",
3289 "journal-1413: journal_mark_dirty: j_len (%lu) is too big\n", 3298 "j_len (%lu) is too big",
3290 journal->j_len); 3299 journal->j_len);
3291 } 3300 }
3292 3301
3293 if (buffer_journal_dirty(bh)) { 3302 if (buffer_journal_dirty(bh)) {
3294 count_already_incd = 1; 3303 count_already_incd = 1;
3295 PROC_INFO_INC(p_s_sb, journal.mark_dirty_notjournal); 3304 PROC_INFO_INC(sb, journal.mark_dirty_notjournal);
3296 clear_buffer_journal_dirty(bh); 3305 clear_buffer_journal_dirty(bh);
3297 } 3306 }
3298 3307
@@ -3304,9 +3313,9 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3304 3313
3305 /* now put this guy on the end */ 3314 /* now put this guy on the end */
3306 if (!cn) { 3315 if (!cn) {
3307 cn = get_cnode(p_s_sb); 3316 cn = get_cnode(sb);
3308 if (!cn) { 3317 if (!cn) {
3309 reiserfs_panic(p_s_sb, "get_cnode failed!\n"); 3318 reiserfs_panic(sb, "journal-4", "get_cnode failed!");
3310 } 3319 }
3311 3320
3312 if (th->t_blocks_logged == th->t_blocks_allocated) { 3321 if (th->t_blocks_logged == th->t_blocks_allocated) {
@@ -3318,7 +3327,7 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3318 3327
3319 cn->bh = bh; 3328 cn->bh = bh;
3320 cn->blocknr = bh->b_blocknr; 3329 cn->blocknr = bh->b_blocknr;
3321 cn->sb = p_s_sb; 3330 cn->sb = sb;
3322 cn->jlist = NULL; 3331 cn->jlist = NULL;
3323 insert_journal_hash(journal->j_hash_table, cn); 3332 insert_journal_hash(journal->j_hash_table, cn);
3324 if (!count_already_incd) { 3333 if (!count_already_incd) {
@@ -3339,11 +3348,11 @@ int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3339} 3348}
3340 3349
3341int journal_end(struct reiserfs_transaction_handle *th, 3350int journal_end(struct reiserfs_transaction_handle *th,
3342 struct super_block *p_s_sb, unsigned long nblocks) 3351 struct super_block *sb, unsigned long nblocks)
3343{ 3352{
3344 if (!current->journal_info && th->t_refcount > 1) 3353 if (!current->journal_info && th->t_refcount > 1)
3345 reiserfs_warning(p_s_sb, "REISER-NESTING: th NULL, refcount %d", 3354 reiserfs_warning(sb, "REISER-NESTING",
3346 th->t_refcount); 3355 "th NULL, refcount %d", th->t_refcount);
3347 3356
3348 if (!th->t_trans_id) { 3357 if (!th->t_trans_id) {
3349 WARN_ON(1); 3358 WARN_ON(1);
@@ -3366,26 +3375,26 @@ int journal_end(struct reiserfs_transaction_handle *th,
3366 } 3375 }
3367 return 0; 3376 return 0;
3368 } else { 3377 } else {
3369 return do_journal_end(th, p_s_sb, nblocks, 0); 3378 return do_journal_end(th, sb, nblocks, 0);
3370 } 3379 }
3371} 3380}
3372 3381
3373/* removes from the current transaction, relsing and descrementing any counters. 3382/* removes from the current transaction, relsing and descrementing any counters.
3374** also files the removed buffer directly onto the clean list 3383** also files the removed buffer directly onto the clean list
3375** 3384**
3376** called by journal_mark_freed when a block has been deleted 3385** called by journal_mark_freed when a block has been deleted
3377** 3386**
3378** returns 1 if it cleaned and relsed the buffer. 0 otherwise 3387** returns 1 if it cleaned and relsed the buffer. 0 otherwise
3379*/ 3388*/
3380static int remove_from_transaction(struct super_block *p_s_sb, 3389static int remove_from_transaction(struct super_block *sb,
3381 b_blocknr_t blocknr, int already_cleaned) 3390 b_blocknr_t blocknr, int already_cleaned)
3382{ 3391{
3383 struct buffer_head *bh; 3392 struct buffer_head *bh;
3384 struct reiserfs_journal_cnode *cn; 3393 struct reiserfs_journal_cnode *cn;
3385 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3394 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3386 int ret = 0; 3395 int ret = 0;
3387 3396
3388 cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, blocknr); 3397 cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3389 if (!cn || !cn->bh) { 3398 if (!cn || !cn->bh) {
3390 return ret; 3399 return ret;
3391 } 3400 }
@@ -3403,7 +3412,7 @@ static int remove_from_transaction(struct super_block *p_s_sb,
3403 journal->j_last = cn->prev; 3412 journal->j_last = cn->prev;
3404 } 3413 }
3405 if (bh) 3414 if (bh)
3406 remove_journal_hash(p_s_sb, journal->j_hash_table, NULL, 3415 remove_journal_hash(sb, journal->j_hash_table, NULL,
3407 bh->b_blocknr, 0); 3416 bh->b_blocknr, 0);
3408 clear_buffer_journaled(bh); /* don't log this one */ 3417 clear_buffer_journaled(bh); /* don't log this one */
3409 3418
@@ -3413,14 +3422,14 @@ static int remove_from_transaction(struct super_block *p_s_sb,
3413 clear_buffer_journal_test(bh); 3422 clear_buffer_journal_test(bh);
3414 put_bh(bh); 3423 put_bh(bh);
3415 if (atomic_read(&(bh->b_count)) < 0) { 3424 if (atomic_read(&(bh->b_count)) < 0) {
3416 reiserfs_warning(p_s_sb, 3425 reiserfs_warning(sb, "journal-1752",
3417 "journal-1752: remove from trans, b_count < 0"); 3426 "b_count < 0");
3418 } 3427 }
3419 ret = 1; 3428 ret = 1;
3420 } 3429 }
3421 journal->j_len--; 3430 journal->j_len--;
3422 journal->j_len_alloc--; 3431 journal->j_len_alloc--;
3423 free_cnode(p_s_sb, cn); 3432 free_cnode(sb, cn);
3424 return ret; 3433 return ret;
3425} 3434}
3426 3435
@@ -3468,22 +3477,22 @@ static int can_dirty(struct reiserfs_journal_cnode *cn)
3468} 3477}
3469 3478
3470/* syncs the commit blocks, but does not force the real buffers to disk 3479/* syncs the commit blocks, but does not force the real buffers to disk
3471** will wait until the current transaction is done/committed before returning 3480** will wait until the current transaction is done/committed before returning
3472*/ 3481*/
3473int journal_end_sync(struct reiserfs_transaction_handle *th, 3482int journal_end_sync(struct reiserfs_transaction_handle *th,
3474 struct super_block *p_s_sb, unsigned long nblocks) 3483 struct super_block *sb, unsigned long nblocks)
3475{ 3484{
3476 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3485 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3477 3486
3478 BUG_ON(!th->t_trans_id); 3487 BUG_ON(!th->t_trans_id);
3479 /* you can sync while nested, very, very bad */ 3488 /* you can sync while nested, very, very bad */
3480 BUG_ON(th->t_refcount > 1); 3489 BUG_ON(th->t_refcount > 1);
3481 if (journal->j_len == 0) { 3490 if (journal->j_len == 0) {
3482 reiserfs_prepare_for_journal(p_s_sb, SB_BUFFER_WITH_SB(p_s_sb), 3491 reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3483 1); 3492 1);
3484 journal_mark_dirty(th, p_s_sb, SB_BUFFER_WITH_SB(p_s_sb)); 3493 journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb));
3485 } 3494 }
3486 return do_journal_end(th, p_s_sb, nblocks, COMMIT_NOW | WAIT); 3495 return do_journal_end(th, sb, nblocks, COMMIT_NOW | WAIT);
3487} 3496}
3488 3497
3489/* 3498/*
@@ -3493,7 +3502,7 @@ static void flush_async_commits(struct work_struct *work)
3493{ 3502{
3494 struct reiserfs_journal *journal = 3503 struct reiserfs_journal *journal =
3495 container_of(work, struct reiserfs_journal, j_work.work); 3504 container_of(work, struct reiserfs_journal, j_work.work);
3496 struct super_block *p_s_sb = journal->j_work_sb; 3505 struct super_block *sb = journal->j_work_sb;
3497 struct reiserfs_journal_list *jl; 3506 struct reiserfs_journal_list *jl;
3498 struct list_head *entry; 3507 struct list_head *entry;
3499 3508
@@ -3502,7 +3511,7 @@ static void flush_async_commits(struct work_struct *work)
3502 /* last entry is the youngest, commit it and you get everything */ 3511 /* last entry is the youngest, commit it and you get everything */
3503 entry = journal->j_journal_list.prev; 3512 entry = journal->j_journal_list.prev;
3504 jl = JOURNAL_LIST_ENTRY(entry); 3513 jl = JOURNAL_LIST_ENTRY(entry);
3505 flush_commit_list(p_s_sb, jl, 1); 3514 flush_commit_list(sb, jl, 1);
3506 } 3515 }
3507 unlock_kernel(); 3516 unlock_kernel();
3508} 3517}
@@ -3511,11 +3520,11 @@ static void flush_async_commits(struct work_struct *work)
3511** flushes any old transactions to disk 3520** flushes any old transactions to disk
3512** ends the current transaction if it is too old 3521** ends the current transaction if it is too old
3513*/ 3522*/
3514int reiserfs_flush_old_commits(struct super_block *p_s_sb) 3523int reiserfs_flush_old_commits(struct super_block *sb)
3515{ 3524{
3516 time_t now; 3525 time_t now;
3517 struct reiserfs_transaction_handle th; 3526 struct reiserfs_transaction_handle th;
3518 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3527 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3519 3528
3520 now = get_seconds(); 3529 now = get_seconds();
3521 /* safety check so we don't flush while we are replaying the log during 3530 /* safety check so we don't flush while we are replaying the log during
@@ -3532,35 +3541,35 @@ int reiserfs_flush_old_commits(struct super_block *p_s_sb)
3532 journal->j_trans_start_time > 0 && 3541 journal->j_trans_start_time > 0 &&
3533 journal->j_len > 0 && 3542 journal->j_len > 0 &&
3534 (now - journal->j_trans_start_time) > journal->j_max_trans_age) { 3543 (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
3535 if (!journal_join(&th, p_s_sb, 1)) { 3544 if (!journal_join(&th, sb, 1)) {
3536 reiserfs_prepare_for_journal(p_s_sb, 3545 reiserfs_prepare_for_journal(sb,
3537 SB_BUFFER_WITH_SB(p_s_sb), 3546 SB_BUFFER_WITH_SB(sb),
3538 1); 3547 1);
3539 journal_mark_dirty(&th, p_s_sb, 3548 journal_mark_dirty(&th, sb,
3540 SB_BUFFER_WITH_SB(p_s_sb)); 3549 SB_BUFFER_WITH_SB(sb));
3541 3550
3542 /* we're only being called from kreiserfsd, it makes no sense to do 3551 /* we're only being called from kreiserfsd, it makes no sense to do
3543 ** an async commit so that kreiserfsd can do it later 3552 ** an async commit so that kreiserfsd can do it later
3544 */ 3553 */
3545 do_journal_end(&th, p_s_sb, 1, COMMIT_NOW | WAIT); 3554 do_journal_end(&th, sb, 1, COMMIT_NOW | WAIT);
3546 } 3555 }
3547 } 3556 }
3548 return p_s_sb->s_dirt; 3557 return sb->s_dirt;
3549} 3558}
3550 3559
3551/* 3560/*
3552** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit 3561** returns 0 if do_journal_end should return right away, returns 1 if do_journal_end should finish the commit
3553** 3562**
3554** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all 3563** if the current transaction is too old, but still has writers, this will wait on j_join_wait until all
3555** the writers are done. By the time it wakes up, the transaction it was called has already ended, so it just 3564** the writers are done. By the time it wakes up, the transaction it was called has already ended, so it just
3556** flushes the commit list and returns 0. 3565** flushes the commit list and returns 0.
3557** 3566**
3558** Won't batch when flush or commit_now is set. Also won't batch when others are waiting on j_join_wait. 3567** Won't batch when flush or commit_now is set. Also won't batch when others are waiting on j_join_wait.
3559** 3568**
3560** Note, we can't allow the journal_end to proceed while there are still writers in the log. 3569** Note, we can't allow the journal_end to proceed while there are still writers in the log.
3561*/ 3570*/
3562static int check_journal_end(struct reiserfs_transaction_handle *th, 3571static int check_journal_end(struct reiserfs_transaction_handle *th,
3563 struct super_block *p_s_sb, unsigned long nblocks, 3572 struct super_block *sb, unsigned long nblocks,
3564 int flags) 3573 int flags)
3565{ 3574{
3566 3575
@@ -3569,13 +3578,13 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3569 int commit_now = flags & COMMIT_NOW; 3578 int commit_now = flags & COMMIT_NOW;
3570 int wait_on_commit = flags & WAIT; 3579 int wait_on_commit = flags & WAIT;
3571 struct reiserfs_journal_list *jl; 3580 struct reiserfs_journal_list *jl;
3572 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3581 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3573 3582
3574 BUG_ON(!th->t_trans_id); 3583 BUG_ON(!th->t_trans_id);
3575 3584
3576 if (th->t_trans_id != journal->j_trans_id) { 3585 if (th->t_trans_id != journal->j_trans_id) {
3577 reiserfs_panic(th->t_super, 3586 reiserfs_panic(th->t_super, "journal-1577",
3578 "journal-1577: handle trans id %ld != current trans id %ld\n", 3587 "handle trans id %ld != current trans id %ld",
3579 th->t_trans_id, journal->j_trans_id); 3588 th->t_trans_id, journal->j_trans_id);
3580 } 3589 }
3581 3590
@@ -3584,7 +3593,7 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3584 atomic_dec(&(journal->j_wcount)); 3593 atomic_dec(&(journal->j_wcount));
3585 } 3594 }
3586 3595
3587 /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released 3596 /* BUG, deal with case where j_len is 0, but people previously freed blocks need to be released
3588 ** will be dealt with by next transaction that actually writes something, but should be taken 3597 ** will be dealt with by next transaction that actually writes something, but should be taken
3589 ** care of in this trans 3598 ** care of in this trans
3590 */ 3599 */
@@ -3593,7 +3602,7 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3593 /* if wcount > 0, and we are called to with flush or commit_now, 3602 /* if wcount > 0, and we are called to with flush or commit_now,
3594 ** we wait on j_join_wait. We will wake up when the last writer has 3603 ** we wait on j_join_wait. We will wake up when the last writer has
3595 ** finished the transaction, and started it on its way to the disk. 3604 ** finished the transaction, and started it on its way to the disk.
3596 ** Then, we flush the commit or journal list, and just return 0 3605 ** Then, we flush the commit or journal list, and just return 0
3597 ** because the rest of journal end was already done for this transaction. 3606 ** because the rest of journal end was already done for this transaction.
3598 */ 3607 */
3599 if (atomic_read(&(journal->j_wcount)) > 0) { 3608 if (atomic_read(&(journal->j_wcount)) > 0) {
@@ -3608,31 +3617,31 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3608 if (flush) { 3617 if (flush) {
3609 journal->j_next_full_flush = 1; 3618 journal->j_next_full_flush = 1;
3610 } 3619 }
3611 unlock_journal(p_s_sb); 3620 unlock_journal(sb);
3612 3621
3613 /* sleep while the current transaction is still j_jlocked */ 3622 /* sleep while the current transaction is still j_jlocked */
3614 while (journal->j_trans_id == trans_id) { 3623 while (journal->j_trans_id == trans_id) {
3615 if (atomic_read(&journal->j_jlock)) { 3624 if (atomic_read(&journal->j_jlock)) {
3616 queue_log_writer(p_s_sb); 3625 queue_log_writer(sb);
3617 } else { 3626 } else {
3618 lock_journal(p_s_sb); 3627 lock_journal(sb);
3619 if (journal->j_trans_id == trans_id) { 3628 if (journal->j_trans_id == trans_id) {
3620 atomic_set(&(journal->j_jlock), 3629 atomic_set(&(journal->j_jlock),
3621 1); 3630 1);
3622 } 3631 }
3623 unlock_journal(p_s_sb); 3632 unlock_journal(sb);
3624 } 3633 }
3625 } 3634 }
3626 BUG_ON(journal->j_trans_id == trans_id); 3635 BUG_ON(journal->j_trans_id == trans_id);
3627 3636
3628 if (commit_now 3637 if (commit_now
3629 && journal_list_still_alive(p_s_sb, trans_id) 3638 && journal_list_still_alive(sb, trans_id)
3630 && wait_on_commit) { 3639 && wait_on_commit) {
3631 flush_commit_list(p_s_sb, jl, 1); 3640 flush_commit_list(sb, jl, 1);
3632 } 3641 }
3633 return 0; 3642 return 0;
3634 } 3643 }
3635 unlock_journal(p_s_sb); 3644 unlock_journal(sb);
3636 return 0; 3645 return 0;
3637 } 3646 }
3638 3647
@@ -3649,13 +3658,13 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3649 && journal->j_len_alloc < journal->j_max_batch 3658 && journal->j_len_alloc < journal->j_max_batch
3650 && journal->j_cnode_free > (journal->j_trans_max * 3)) { 3659 && journal->j_cnode_free > (journal->j_trans_max * 3)) {
3651 journal->j_bcount++; 3660 journal->j_bcount++;
3652 unlock_journal(p_s_sb); 3661 unlock_journal(sb);
3653 return 0; 3662 return 0;
3654 } 3663 }
3655 3664
3656 if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(p_s_sb)) { 3665 if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) {
3657 reiserfs_panic(p_s_sb, 3666 reiserfs_panic(sb, "journal-003",
3658 "journal-003: journal_end: j_start (%ld) is too high\n", 3667 "j_start (%ld) is too high",
3659 journal->j_start); 3668 journal->j_start);
3660 } 3669 }
3661 return 1; 3670 return 1;
@@ -3664,7 +3673,7 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3664/* 3673/*
3665** Does all the work that makes deleting blocks safe. 3674** Does all the work that makes deleting blocks safe.
3666** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on. 3675** when deleting a block mark BH_JNew, just remove it from the current transaction, clean it's buffer_head and move on.
3667** 3676**
3668** otherwise: 3677** otherwise:
3669** set a bit for the block in the journal bitmap. That will prevent it from being allocated for unformatted nodes 3678** set a bit for the block in the journal bitmap. That will prevent it from being allocated for unformatted nodes
3670** before this transaction has finished. 3679** before this transaction has finished.
@@ -3676,16 +3685,16 @@ static int check_journal_end(struct reiserfs_transaction_handle *th,
3676** Then remove it from the current transaction, decrementing any counters and filing it on the clean list. 3685** Then remove it from the current transaction, decrementing any counters and filing it on the clean list.
3677*/ 3686*/
3678int journal_mark_freed(struct reiserfs_transaction_handle *th, 3687int journal_mark_freed(struct reiserfs_transaction_handle *th,
3679 struct super_block *p_s_sb, b_blocknr_t blocknr) 3688 struct super_block *sb, b_blocknr_t blocknr)
3680{ 3689{
3681 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3690 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3682 struct reiserfs_journal_cnode *cn = NULL; 3691 struct reiserfs_journal_cnode *cn = NULL;
3683 struct buffer_head *bh = NULL; 3692 struct buffer_head *bh = NULL;
3684 struct reiserfs_list_bitmap *jb = NULL; 3693 struct reiserfs_list_bitmap *jb = NULL;
3685 int cleaned = 0; 3694 int cleaned = 0;
3686 BUG_ON(!th->t_trans_id); 3695 BUG_ON(!th->t_trans_id);
3687 3696
3688 cn = get_journal_hash_dev(p_s_sb, journal->j_hash_table, blocknr); 3697 cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3689 if (cn && cn->bh) { 3698 if (cn && cn->bh) {
3690 bh = cn->bh; 3699 bh = cn->bh;
3691 get_bh(bh); 3700 get_bh(bh);
@@ -3695,15 +3704,15 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th,
3695 clear_buffer_journal_new(bh); 3704 clear_buffer_journal_new(bh);
3696 clear_prepared_bits(bh); 3705 clear_prepared_bits(bh);
3697 reiserfs_clean_and_file_buffer(bh); 3706 reiserfs_clean_and_file_buffer(bh);
3698 cleaned = remove_from_transaction(p_s_sb, blocknr, cleaned); 3707 cleaned = remove_from_transaction(sb, blocknr, cleaned);
3699 } else { 3708 } else {
3700 /* set the bit for this block in the journal bitmap for this transaction */ 3709 /* set the bit for this block in the journal bitmap for this transaction */
3701 jb = journal->j_current_jl->j_list_bitmap; 3710 jb = journal->j_current_jl->j_list_bitmap;
3702 if (!jb) { 3711 if (!jb) {
3703 reiserfs_panic(p_s_sb, 3712 reiserfs_panic(sb, "journal-1702",
3704 "journal-1702: journal_mark_freed, journal_list_bitmap is NULL\n"); 3713 "journal_list_bitmap is NULL");
3705 } 3714 }
3706 set_bit_in_list_bitmap(p_s_sb, blocknr, jb); 3715 set_bit_in_list_bitmap(sb, blocknr, jb);
3707 3716
3708 /* Note, the entire while loop is not allowed to schedule. */ 3717 /* Note, the entire while loop is not allowed to schedule. */
3709 3718
@@ -3711,13 +3720,13 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th,
3711 clear_prepared_bits(bh); 3720 clear_prepared_bits(bh);
3712 reiserfs_clean_and_file_buffer(bh); 3721 reiserfs_clean_and_file_buffer(bh);
3713 } 3722 }
3714 cleaned = remove_from_transaction(p_s_sb, blocknr, cleaned); 3723 cleaned = remove_from_transaction(sb, blocknr, cleaned);
3715 3724
3716 /* find all older transactions with this block, make sure they don't try to write it out */ 3725 /* find all older transactions with this block, make sure they don't try to write it out */
3717 cn = get_journal_hash_dev(p_s_sb, journal->j_list_hash_table, 3726 cn = get_journal_hash_dev(sb, journal->j_list_hash_table,
3718 blocknr); 3727 blocknr);
3719 while (cn) { 3728 while (cn) {
3720 if (p_s_sb == cn->sb && blocknr == cn->blocknr) { 3729 if (sb == cn->sb && blocknr == cn->blocknr) {
3721 set_bit(BLOCK_FREED, &cn->state); 3730 set_bit(BLOCK_FREED, &cn->state);
3722 if (cn->bh) { 3731 if (cn->bh) {
3723 if (!cleaned) { 3732 if (!cleaned) {
@@ -3733,8 +3742,9 @@ int journal_mark_freed(struct reiserfs_transaction_handle *th,
3733 put_bh(cn->bh); 3742 put_bh(cn->bh);
3734 if (atomic_read 3743 if (atomic_read
3735 (&(cn->bh->b_count)) < 0) { 3744 (&(cn->bh->b_count)) < 0) {
3736 reiserfs_warning(p_s_sb, 3745 reiserfs_warning(sb,
3737 "journal-2138: cn->bh->b_count < 0"); 3746 "journal-2138",
3747 "cn->bh->b_count < 0");
3738 } 3748 }
3739 } 3749 }
3740 if (cn->jlist) { /* since we are clearing the bh, we MUST dec nonzerolen */ 3750 if (cn->jlist) { /* since we are clearing the bh, we MUST dec nonzerolen */
@@ -3824,7 +3834,7 @@ static int __commit_trans_jl(struct inode *inode, unsigned long id,
3824 3834
3825int reiserfs_commit_for_inode(struct inode *inode) 3835int reiserfs_commit_for_inode(struct inode *inode)
3826{ 3836{
3827 unsigned long id = REISERFS_I(inode)->i_trans_id; 3837 unsigned int id = REISERFS_I(inode)->i_trans_id;
3828 struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl; 3838 struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl;
3829 3839
3830 /* for the whole inode, assume unset id means it was 3840 /* for the whole inode, assume unset id means it was
@@ -3839,18 +3849,18 @@ int reiserfs_commit_for_inode(struct inode *inode)
3839 return __commit_trans_jl(inode, id, jl); 3849 return __commit_trans_jl(inode, id, jl);
3840} 3850}
3841 3851
3842void reiserfs_restore_prepared_buffer(struct super_block *p_s_sb, 3852void reiserfs_restore_prepared_buffer(struct super_block *sb,
3843 struct buffer_head *bh) 3853 struct buffer_head *bh)
3844{ 3854{
3845 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3855 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3846 PROC_INFO_INC(p_s_sb, journal.restore_prepared); 3856 PROC_INFO_INC(sb, journal.restore_prepared);
3847 if (!bh) { 3857 if (!bh) {
3848 return; 3858 return;
3849 } 3859 }
3850 if (test_clear_buffer_journal_restore_dirty(bh) && 3860 if (test_clear_buffer_journal_restore_dirty(bh) &&
3851 buffer_journal_dirty(bh)) { 3861 buffer_journal_dirty(bh)) {
3852 struct reiserfs_journal_cnode *cn; 3862 struct reiserfs_journal_cnode *cn;
3853 cn = get_journal_hash_dev(p_s_sb, 3863 cn = get_journal_hash_dev(sb,
3854 journal->j_list_hash_table, 3864 journal->j_list_hash_table,
3855 bh->b_blocknr); 3865 bh->b_blocknr);
3856 if (cn && can_dirty(cn)) { 3866 if (cn && can_dirty(cn)) {
@@ -3867,12 +3877,12 @@ extern struct tree_balance *cur_tb;
3867** be written to disk while we are altering it. So, we must: 3877** be written to disk while we are altering it. So, we must:
3868** clean it 3878** clean it
3869** wait on it. 3879** wait on it.
3870** 3880**
3871*/ 3881*/
3872int reiserfs_prepare_for_journal(struct super_block *p_s_sb, 3882int reiserfs_prepare_for_journal(struct super_block *sb,
3873 struct buffer_head *bh, int wait) 3883 struct buffer_head *bh, int wait)
3874{ 3884{
3875 PROC_INFO_INC(p_s_sb, journal.prepare); 3885 PROC_INFO_INC(sb, journal.prepare);
3876 3886
3877 if (!trylock_buffer(bh)) { 3887 if (!trylock_buffer(bh)) {
3878 if (!wait) 3888 if (!wait)
@@ -3909,7 +3919,7 @@ static void flush_old_journal_lists(struct super_block *s)
3909 } 3919 }
3910} 3920}
3911 3921
3912/* 3922/*
3913** long and ugly. If flush, will not return until all commit 3923** long and ugly. If flush, will not return until all commit
3914** blocks and all real buffers in the trans are on disk. 3924** blocks and all real buffers in the trans are on disk.
3915** If no_async, won't return until all commit blocks are on disk. 3925** If no_async, won't return until all commit blocks are on disk.
@@ -3920,10 +3930,10 @@ static void flush_old_journal_lists(struct super_block *s)
3920** journal lists, etc just won't happen. 3930** journal lists, etc just won't happen.
3921*/ 3931*/
3922static int do_journal_end(struct reiserfs_transaction_handle *th, 3932static int do_journal_end(struct reiserfs_transaction_handle *th,
3923 struct super_block *p_s_sb, unsigned long nblocks, 3933 struct super_block *sb, unsigned long nblocks,
3924 int flags) 3934 int flags)
3925{ 3935{
3926 struct reiserfs_journal *journal = SB_JOURNAL(p_s_sb); 3936 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3927 struct reiserfs_journal_cnode *cn, *next, *jl_cn; 3937 struct reiserfs_journal_cnode *cn, *next, *jl_cn;
3928 struct reiserfs_journal_cnode *last_cn = NULL; 3938 struct reiserfs_journal_cnode *last_cn = NULL;
3929 struct reiserfs_journal_desc *desc; 3939 struct reiserfs_journal_desc *desc;
@@ -3938,7 +3948,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
3938 struct reiserfs_journal_list *jl, *temp_jl; 3948 struct reiserfs_journal_list *jl, *temp_jl;
3939 struct list_head *entry, *safe; 3949 struct list_head *entry, *safe;
3940 unsigned long jindex; 3950 unsigned long jindex;
3941 unsigned long commit_trans_id; 3951 unsigned int commit_trans_id;
3942 int trans_half; 3952 int trans_half;
3943 3953
3944 BUG_ON(th->t_refcount > 1); 3954 BUG_ON(th->t_refcount > 1);
@@ -3946,21 +3956,21 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
3946 3956
3947 /* protect flush_older_commits from doing mistakes if the 3957 /* protect flush_older_commits from doing mistakes if the
3948 transaction ID counter gets overflowed. */ 3958 transaction ID counter gets overflowed. */
3949 if (th->t_trans_id == ~0UL) 3959 if (th->t_trans_id == ~0U)
3950 flags |= FLUSH_ALL | COMMIT_NOW | WAIT; 3960 flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
3951 flush = flags & FLUSH_ALL; 3961 flush = flags & FLUSH_ALL;
3952 wait_on_commit = flags & WAIT; 3962 wait_on_commit = flags & WAIT;
3953 3963
3954 put_fs_excl(); 3964 put_fs_excl();
3955 current->journal_info = th->t_handle_save; 3965 current->journal_info = th->t_handle_save;
3956 reiserfs_check_lock_depth(p_s_sb, "journal end"); 3966 reiserfs_check_lock_depth(sb, "journal end");
3957 if (journal->j_len == 0) { 3967 if (journal->j_len == 0) {
3958 reiserfs_prepare_for_journal(p_s_sb, SB_BUFFER_WITH_SB(p_s_sb), 3968 reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3959 1); 3969 1);
3960 journal_mark_dirty(th, p_s_sb, SB_BUFFER_WITH_SB(p_s_sb)); 3970 journal_mark_dirty(th, sb, SB_BUFFER_WITH_SB(sb));
3961 } 3971 }
3962 3972
3963 lock_journal(p_s_sb); 3973 lock_journal(sb);
3964 if (journal->j_next_full_flush) { 3974 if (journal->j_next_full_flush) {
3965 flags |= FLUSH_ALL; 3975 flags |= FLUSH_ALL;
3966 flush = 1; 3976 flush = 1;
@@ -3970,13 +3980,13 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
3970 wait_on_commit = 1; 3980 wait_on_commit = 1;
3971 } 3981 }
3972 3982
3973 /* check_journal_end locks the journal, and unlocks if it does not return 1 3983 /* check_journal_end locks the journal, and unlocks if it does not return 1
3974 ** it tells us if we should continue with the journal_end, or just return 3984 ** it tells us if we should continue with the journal_end, or just return
3975 */ 3985 */
3976 if (!check_journal_end(th, p_s_sb, nblocks, flags)) { 3986 if (!check_journal_end(th, sb, nblocks, flags)) {
3977 p_s_sb->s_dirt = 1; 3987 sb->s_dirt = 1;
3978 wake_queued_writers(p_s_sb); 3988 wake_queued_writers(sb);
3979 reiserfs_async_progress_wait(p_s_sb); 3989 reiserfs_async_progress_wait(sb);
3980 goto out; 3990 goto out;
3981 } 3991 }
3982 3992
@@ -4005,8 +4015,8 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4005 4015
4006 /* setup description block */ 4016 /* setup description block */
4007 d_bh = 4017 d_bh =
4008 journal_getblk(p_s_sb, 4018 journal_getblk(sb,
4009 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 4019 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4010 journal->j_start); 4020 journal->j_start);
4011 set_buffer_uptodate(d_bh); 4021 set_buffer_uptodate(d_bh);
4012 desc = (struct reiserfs_journal_desc *)(d_bh)->b_data; 4022 desc = (struct reiserfs_journal_desc *)(d_bh)->b_data;
@@ -4015,9 +4025,9 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4015 set_desc_trans_id(desc, journal->j_trans_id); 4025 set_desc_trans_id(desc, journal->j_trans_id);
4016 4026
4017 /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */ 4027 /* setup commit block. Don't write (keep it clean too) this one until after everyone else is written */
4018 c_bh = journal_getblk(p_s_sb, SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 4028 c_bh = journal_getblk(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4019 ((journal->j_start + journal->j_len + 4029 ((journal->j_start + journal->j_len +
4020 1) % SB_ONDISK_JOURNAL_SIZE(p_s_sb))); 4030 1) % SB_ONDISK_JOURNAL_SIZE(sb)));
4021 commit = (struct reiserfs_journal_commit *)c_bh->b_data; 4031 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
4022 memset(c_bh->b_data, 0, c_bh->b_size); 4032 memset(c_bh->b_data, 0, c_bh->b_size);
4023 set_commit_trans_id(commit, journal->j_trans_id); 4033 set_commit_trans_id(commit, journal->j_trans_id);
@@ -4050,13 +4060,13 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4050 ** for each real block, add it to the journal list hash, 4060 ** for each real block, add it to the journal list hash,
4051 ** copy into real block index array in the commit or desc block 4061 ** copy into real block index array in the commit or desc block
4052 */ 4062 */
4053 trans_half = journal_trans_half(p_s_sb->s_blocksize); 4063 trans_half = journal_trans_half(sb->s_blocksize);
4054 for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) { 4064 for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) {
4055 if (buffer_journaled(cn->bh)) { 4065 if (buffer_journaled(cn->bh)) {
4056 jl_cn = get_cnode(p_s_sb); 4066 jl_cn = get_cnode(sb);
4057 if (!jl_cn) { 4067 if (!jl_cn) {
4058 reiserfs_panic(p_s_sb, 4068 reiserfs_panic(sb, "journal-1676",
4059 "journal-1676, get_cnode returned NULL\n"); 4069 "get_cnode returned NULL");
4060 } 4070 }
4061 if (i == 0) { 4071 if (i == 0) {
4062 jl->j_realblock = jl_cn; 4072 jl->j_realblock = jl_cn;
@@ -4067,18 +4077,19 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4067 last_cn->next = jl_cn; 4077 last_cn->next = jl_cn;
4068 } 4078 }
4069 last_cn = jl_cn; 4079 last_cn = jl_cn;
4070 /* make sure the block we are trying to log is not a block 4080 /* make sure the block we are trying to log is not a block
4071 of journal or reserved area */ 4081 of journal or reserved area */
4072 4082
4073 if (is_block_in_log_or_reserved_area 4083 if (is_block_in_log_or_reserved_area
4074 (p_s_sb, cn->bh->b_blocknr)) { 4084 (sb, cn->bh->b_blocknr)) {
4075 reiserfs_panic(p_s_sb, 4085 reiserfs_panic(sb, "journal-2332",
4076 "journal-2332: Trying to log block %lu, which is a log block\n", 4086 "Trying to log block %lu, "
4087 "which is a log block",
4077 cn->bh->b_blocknr); 4088 cn->bh->b_blocknr);
4078 } 4089 }
4079 jl_cn->blocknr = cn->bh->b_blocknr; 4090 jl_cn->blocknr = cn->bh->b_blocknr;
4080 jl_cn->state = 0; 4091 jl_cn->state = 0;
4081 jl_cn->sb = p_s_sb; 4092 jl_cn->sb = sb;
4082 jl_cn->bh = cn->bh; 4093 jl_cn->bh = cn->bh;
4083 jl_cn->jlist = jl; 4094 jl_cn->jlist = jl;
4084 insert_journal_hash(journal->j_list_hash_table, jl_cn); 4095 insert_journal_hash(journal->j_list_hash_table, jl_cn);
@@ -4119,11 +4130,11 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4119 char *addr; 4130 char *addr;
4120 struct page *page; 4131 struct page *page;
4121 tmp_bh = 4132 tmp_bh =
4122 journal_getblk(p_s_sb, 4133 journal_getblk(sb,
4123 SB_ONDISK_JOURNAL_1st_BLOCK(p_s_sb) + 4134 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4124 ((cur_write_start + 4135 ((cur_write_start +
4125 jindex) % 4136 jindex) %
4126 SB_ONDISK_JOURNAL_SIZE(p_s_sb))); 4137 SB_ONDISK_JOURNAL_SIZE(sb)));
4127 set_buffer_uptodate(tmp_bh); 4138 set_buffer_uptodate(tmp_bh);
4128 page = cn->bh->b_page; 4139 page = cn->bh->b_page;
4129 addr = kmap(page); 4140 addr = kmap(page);
@@ -4137,12 +4148,13 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4137 clear_buffer_journaled(cn->bh); 4148 clear_buffer_journaled(cn->bh);
4138 } else { 4149 } else {
4139 /* JDirty cleared sometime during transaction. don't log this one */ 4150 /* JDirty cleared sometime during transaction. don't log this one */
4140 reiserfs_warning(p_s_sb, 4151 reiserfs_warning(sb, "journal-2048",
4141 "journal-2048: do_journal_end: BAD, buffer in journal hash, but not JDirty!"); 4152 "BAD, buffer in journal hash, "
4153 "but not JDirty!");
4142 brelse(cn->bh); 4154 brelse(cn->bh);
4143 } 4155 }
4144 next = cn->next; 4156 next = cn->next;
4145 free_cnode(p_s_sb, cn); 4157 free_cnode(sb, cn);
4146 cn = next; 4158 cn = next;
4147 cond_resched(); 4159 cond_resched();
4148 } 4160 }
@@ -4152,7 +4164,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4152 ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1. 4164 ** so we dirty/relse c_bh in flush_commit_list, with commit_left <= 1.
4153 */ 4165 */
4154 4166
4155 journal->j_current_jl = alloc_journal_list(p_s_sb); 4167 journal->j_current_jl = alloc_journal_list(sb);
4156 4168
4157 /* now it is safe to insert this transaction on the main list */ 4169 /* now it is safe to insert this transaction on the main list */
4158 list_add_tail(&jl->j_list, &journal->j_journal_list); 4170 list_add_tail(&jl->j_list, &journal->j_journal_list);
@@ -4163,7 +4175,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4163 old_start = journal->j_start; 4175 old_start = journal->j_start;
4164 journal->j_start = 4176 journal->j_start =
4165 (journal->j_start + journal->j_len + 4177 (journal->j_start + journal->j_len +
4166 2) % SB_ONDISK_JOURNAL_SIZE(p_s_sb); 4178 2) % SB_ONDISK_JOURNAL_SIZE(sb);
4167 atomic_set(&(journal->j_wcount), 0); 4179 atomic_set(&(journal->j_wcount), 0);
4168 journal->j_bcount = 0; 4180 journal->j_bcount = 0;
4169 journal->j_last = NULL; 4181 journal->j_last = NULL;
@@ -4178,7 +4190,7 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4178 journal->j_len_alloc = 0; 4190 journal->j_len_alloc = 0;
4179 journal->j_next_full_flush = 0; 4191 journal->j_next_full_flush = 0;
4180 journal->j_next_async_flush = 0; 4192 journal->j_next_async_flush = 0;
4181 init_journal_hash(p_s_sb); 4193 init_journal_hash(sb);
4182 4194
4183 // make sure reiserfs_add_jh sees the new current_jl before we 4195 // make sure reiserfs_add_jh sees the new current_jl before we
4184 // write out the tails 4196 // write out the tails
@@ -4207,14 +4219,14 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4207 ** queue don't wait for this proc to flush journal lists and such. 4219 ** queue don't wait for this proc to flush journal lists and such.
4208 */ 4220 */
4209 if (flush) { 4221 if (flush) {
4210 flush_commit_list(p_s_sb, jl, 1); 4222 flush_commit_list(sb, jl, 1);
4211 flush_journal_list(p_s_sb, jl, 1); 4223 flush_journal_list(sb, jl, 1);
4212 } else if (!(jl->j_state & LIST_COMMIT_PENDING)) 4224 } else if (!(jl->j_state & LIST_COMMIT_PENDING))
4213 queue_delayed_work(commit_wq, &journal->j_work, HZ / 10); 4225 queue_delayed_work(commit_wq, &journal->j_work, HZ / 10);
4214 4226
4215 /* if the next transaction has any chance of wrapping, flush 4227 /* if the next transaction has any chance of wrapping, flush
4216 ** transactions that might get overwritten. If any journal lists are very 4228 ** transactions that might get overwritten. If any journal lists are very
4217 ** old flush them as well. 4229 ** old flush them as well.
4218 */ 4230 */
4219 first_jl: 4231 first_jl:
4220 list_for_each_safe(entry, safe, &journal->j_journal_list) { 4232 list_for_each_safe(entry, safe, &journal->j_journal_list) {
@@ -4222,11 +4234,11 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4222 if (journal->j_start <= temp_jl->j_start) { 4234 if (journal->j_start <= temp_jl->j_start) {
4223 if ((journal->j_start + journal->j_trans_max + 1) >= 4235 if ((journal->j_start + journal->j_trans_max + 1) >=
4224 temp_jl->j_start) { 4236 temp_jl->j_start) {
4225 flush_used_journal_lists(p_s_sb, temp_jl); 4237 flush_used_journal_lists(sb, temp_jl);
4226 goto first_jl; 4238 goto first_jl;
4227 } else if ((journal->j_start + 4239 } else if ((journal->j_start +
4228 journal->j_trans_max + 1) < 4240 journal->j_trans_max + 1) <
4229 SB_ONDISK_JOURNAL_SIZE(p_s_sb)) { 4241 SB_ONDISK_JOURNAL_SIZE(sb)) {
4230 /* if we don't cross into the next transaction and we don't 4242 /* if we don't cross into the next transaction and we don't
4231 * wrap, there is no way we can overlap any later transactions 4243 * wrap, there is no way we can overlap any later transactions
4232 * break now 4244 * break now
@@ -4235,11 +4247,11 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4235 } 4247 }
4236 } else if ((journal->j_start + 4248 } else if ((journal->j_start +
4237 journal->j_trans_max + 1) > 4249 journal->j_trans_max + 1) >
4238 SB_ONDISK_JOURNAL_SIZE(p_s_sb)) { 4250 SB_ONDISK_JOURNAL_SIZE(sb)) {
4239 if (((journal->j_start + journal->j_trans_max + 1) % 4251 if (((journal->j_start + journal->j_trans_max + 1) %
4240 SB_ONDISK_JOURNAL_SIZE(p_s_sb)) >= 4252 SB_ONDISK_JOURNAL_SIZE(sb)) >=
4241 temp_jl->j_start) { 4253 temp_jl->j_start) {
4242 flush_used_journal_lists(p_s_sb, temp_jl); 4254 flush_used_journal_lists(sb, temp_jl);
4243 goto first_jl; 4255 goto first_jl;
4244 } else { 4256 } else {
4245 /* we don't overlap anything from out start to the end of the 4257 /* we don't overlap anything from out start to the end of the
@@ -4250,46 +4262,47 @@ static int do_journal_end(struct reiserfs_transaction_handle *th,
4250 } 4262 }
4251 } 4263 }
4252 } 4264 }
4253 flush_old_journal_lists(p_s_sb); 4265 flush_old_journal_lists(sb);
4254 4266
4255 journal->j_current_jl->j_list_bitmap = 4267 journal->j_current_jl->j_list_bitmap =
4256 get_list_bitmap(p_s_sb, journal->j_current_jl); 4268 get_list_bitmap(sb, journal->j_current_jl);
4257 4269
4258 if (!(journal->j_current_jl->j_list_bitmap)) { 4270 if (!(journal->j_current_jl->j_list_bitmap)) {
4259 reiserfs_panic(p_s_sb, 4271 reiserfs_panic(sb, "journal-1996",
4260 "journal-1996: do_journal_end, could not get a list bitmap\n"); 4272 "could not get a list bitmap");
4261 } 4273 }
4262 4274
4263 atomic_set(&(journal->j_jlock), 0); 4275 atomic_set(&(journal->j_jlock), 0);
4264 unlock_journal(p_s_sb); 4276 unlock_journal(sb);
4265 /* wake up any body waiting to join. */ 4277 /* wake up any body waiting to join. */
4266 clear_bit(J_WRITERS_QUEUED, &journal->j_state); 4278 clear_bit(J_WRITERS_QUEUED, &journal->j_state);
4267 wake_up(&(journal->j_join_wait)); 4279 wake_up(&(journal->j_join_wait));
4268 4280
4269 if (!flush && wait_on_commit && 4281 if (!flush && wait_on_commit &&
4270 journal_list_still_alive(p_s_sb, commit_trans_id)) { 4282 journal_list_still_alive(sb, commit_trans_id)) {
4271 flush_commit_list(p_s_sb, jl, 1); 4283 flush_commit_list(sb, jl, 1);
4272 } 4284 }
4273 out: 4285 out:
4274 reiserfs_check_lock_depth(p_s_sb, "journal end2"); 4286 reiserfs_check_lock_depth(sb, "journal end2");
4275 4287
4276 memset(th, 0, sizeof(*th)); 4288 memset(th, 0, sizeof(*th));
4277 /* Re-set th->t_super, so we can properly keep track of how many 4289 /* Re-set th->t_super, so we can properly keep track of how many
4278 * persistent transactions there are. We need to do this so if this 4290 * persistent transactions there are. We need to do this so if this
4279 * call is part of a failed restart_transaction, we can free it later */ 4291 * call is part of a failed restart_transaction, we can free it later */
4280 th->t_super = p_s_sb; 4292 th->t_super = sb;
4281 4293
4282 return journal->j_errno; 4294 return journal->j_errno;
4283} 4295}
4284 4296
4285static void __reiserfs_journal_abort_hard(struct super_block *sb) 4297/* Send the file system read only and refuse new transactions */
4298void reiserfs_abort_journal(struct super_block *sb, int errno)
4286{ 4299{
4287 struct reiserfs_journal *journal = SB_JOURNAL(sb); 4300 struct reiserfs_journal *journal = SB_JOURNAL(sb);
4288 if (test_bit(J_ABORTED, &journal->j_state)) 4301 if (test_bit(J_ABORTED, &journal->j_state))
4289 return; 4302 return;
4290 4303
4291 printk(KERN_CRIT "REISERFS: Aborting journal for filesystem on %s\n", 4304 if (!journal->j_errno)
4292 reiserfs_bdevname(sb)); 4305 journal->j_errno = errno;
4293 4306
4294 sb->s_flags |= MS_RDONLY; 4307 sb->s_flags |= MS_RDONLY;
4295 set_bit(J_ABORTED, &journal->j_state); 4308 set_bit(J_ABORTED, &journal->j_state);
@@ -4299,19 +4312,3 @@ static void __reiserfs_journal_abort_hard(struct super_block *sb)
4299#endif 4312#endif
4300} 4313}
4301 4314
4302static void __reiserfs_journal_abort_soft(struct super_block *sb, int errno)
4303{
4304 struct reiserfs_journal *journal = SB_JOURNAL(sb);
4305 if (test_bit(J_ABORTED, &journal->j_state))
4306 return;
4307
4308 if (!journal->j_errno)
4309 journal->j_errno = errno;
4310
4311 __reiserfs_journal_abort_hard(sb);
4312}
4313
4314void reiserfs_journal_abort(struct super_block *sb, int errno)
4315{
4316 __reiserfs_journal_abort_soft(sb, errno);
4317}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-30 14:48:10 -0500