1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38#include <linux/time.h>
39#include <linux/semaphore.h>
40#include <linux/vmalloc.h>
41#include "reiserfs.h"
42#include <linux/kernel.h>
43#include <linux/errno.h>
44#include <linux/fcntl.h>
45#include <linux/stat.h>
46#include <linux/string.h>
47#include <linux/buffer_head.h>
48#include <linux/workqueue.h>
49#include <linux/writeback.h>
50#include <linux/blkdev.h>
51#include <linux/backing-dev.h>
52#include <linux/uaccess.h>
53#include <linux/slab.h>
54
55
56
57#define JOURNAL_LIST_ENTRY(h) (list_entry((h), struct reiserfs_journal_list, \
58 j_list))
59
60
61#define JOURNAL_TRANS_HALF 1018
62#define BUFNR 64
63
64
65
66
67#define BLOCK_FREED 2
68
69#define BLOCK_FREED_HOLDER 3
70
71
72#define BLOCK_NEEDS_FLUSH 4
73#define BLOCK_DIRTIED 5
74
75
76#define LIST_TOUCHED 1
77#define LIST_DIRTY 2
78#define LIST_COMMIT_PENDING 4
79
80
81#define FLUSH_ALL 1
82#define COMMIT_NOW 2
83#define WAIT 4
84
85static int do_journal_end(struct reiserfs_transaction_handle *, int flags);
86static int flush_journal_list(struct super_block *s,
87 struct reiserfs_journal_list *jl, int flushall);
88static int flush_commit_list(struct super_block *s,
89 struct reiserfs_journal_list *jl, int flushall);
90static int can_dirty(struct reiserfs_journal_cnode *cn);
91static int journal_join(struct reiserfs_transaction_handle *th,
92 struct super_block *sb);
93static void release_journal_dev(struct super_block *super,
94 struct reiserfs_journal *journal);
95static void dirty_one_transaction(struct super_block *s,
96 struct reiserfs_journal_list *jl);
97static void flush_async_commits(struct work_struct *work);
98static void queue_log_writer(struct super_block *s);
99
100
101enum {
102 JBEGIN_REG = 0,
103
104 JBEGIN_JOIN = 1,
105
106 JBEGIN_ABORT = 2,
107};
108
109static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
110 struct super_block *sb,
111 unsigned long nblocks, int join);
112
113static void init_journal_hash(struct super_block *sb)
114{
115 struct reiserfs_journal *journal = SB_JOURNAL(sb);
116 memset(journal->j_hash_table, 0,
117 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
118}
119
120
121
122
123
124
125
126static int reiserfs_clean_and_file_buffer(struct buffer_head *bh)
127{
128 if (bh) {
129 clear_buffer_dirty(bh);
130 clear_buffer_journal_test(bh);
131 }
132 return 0;
133}
134
135static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
136 *sb)
137{
138 struct reiserfs_bitmap_node *bn;
139 static int id;
140
141 bn = kmalloc(sizeof(struct reiserfs_bitmap_node), GFP_NOFS);
142 if (!bn) {
143 return NULL;
144 }
145 bn->data = kzalloc(sb->s_blocksize, GFP_NOFS);
146 if (!bn->data) {
147 kfree(bn);
148 return NULL;
149 }
150 bn->id = id++;
151 INIT_LIST_HEAD(&bn->list);
152 return bn;
153}
154
155static struct reiserfs_bitmap_node *get_bitmap_node(struct super_block *sb)
156{
157 struct reiserfs_journal *journal = SB_JOURNAL(sb);
158 struct reiserfs_bitmap_node *bn = NULL;
159 struct list_head *entry = journal->j_bitmap_nodes.next;
160
161 journal->j_used_bitmap_nodes++;
162repeat:
163
164 if (entry != &journal->j_bitmap_nodes) {
165 bn = list_entry(entry, struct reiserfs_bitmap_node, list);
166 list_del(entry);
167 memset(bn->data, 0, sb->s_blocksize);
168 journal->j_free_bitmap_nodes--;
169 return bn;
170 }
171 bn = allocate_bitmap_node(sb);
172 if (!bn) {
173 yield();
174 goto repeat;
175 }
176 return bn;
177}
178static inline void free_bitmap_node(struct super_block *sb,
179 struct reiserfs_bitmap_node *bn)
180{
181 struct reiserfs_journal *journal = SB_JOURNAL(sb);
182 journal->j_used_bitmap_nodes--;
183 if (journal->j_free_bitmap_nodes > REISERFS_MAX_BITMAP_NODES) {
184 kfree(bn->data);
185 kfree(bn);
186 } else {
187 list_add(&bn->list, &journal->j_bitmap_nodes);
188 journal->j_free_bitmap_nodes++;
189 }
190}
191
192static void allocate_bitmap_nodes(struct super_block *sb)
193{
194 int i;
195 struct reiserfs_journal *journal = SB_JOURNAL(sb);
196 struct reiserfs_bitmap_node *bn = NULL;
197 for (i = 0; i < REISERFS_MIN_BITMAP_NODES; i++) {
198 bn = allocate_bitmap_node(sb);
199 if (bn) {
200 list_add(&bn->list, &journal->j_bitmap_nodes);
201 journal->j_free_bitmap_nodes++;
202 } else {
203
204 break;
205 }
206 }
207}
208
209static int set_bit_in_list_bitmap(struct super_block *sb,
210 b_blocknr_t block,
211 struct reiserfs_list_bitmap *jb)
212{
213 unsigned int bmap_nr = block / (sb->s_blocksize << 3);
214 unsigned int bit_nr = block % (sb->s_blocksize << 3);
215
216 if (!jb->bitmaps[bmap_nr]) {
217 jb->bitmaps[bmap_nr] = get_bitmap_node(sb);
218 }
219 set_bit(bit_nr, (unsigned long *)jb->bitmaps[bmap_nr]->data);
220 return 0;
221}
222
223static void cleanup_bitmap_list(struct super_block *sb,
224 struct reiserfs_list_bitmap *jb)
225{
226 int i;
227 if (jb->bitmaps == NULL)
228 return;
229
230 for (i = 0; i < reiserfs_bmap_count(sb); i++) {
231 if (jb->bitmaps[i]) {
232 free_bitmap_node(sb, jb->bitmaps[i]);
233 jb->bitmaps[i] = NULL;
234 }
235 }
236}
237
238
239
240
241static int free_list_bitmaps(struct super_block *sb,
242 struct reiserfs_list_bitmap *jb_array)
243{
244 int i;
245 struct reiserfs_list_bitmap *jb;
246 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
247 jb = jb_array + i;
248 jb->journal_list = NULL;
249 cleanup_bitmap_list(sb, jb);
250 vfree(jb->bitmaps);
251 jb->bitmaps = NULL;
252 }
253 return 0;
254}
255
256static int free_bitmap_nodes(struct super_block *sb)
257{
258 struct reiserfs_journal *journal = SB_JOURNAL(sb);
259 struct list_head *next = journal->j_bitmap_nodes.next;
260 struct reiserfs_bitmap_node *bn;
261
262 while (next != &journal->j_bitmap_nodes) {
263 bn = list_entry(next, struct reiserfs_bitmap_node, list);
264 list_del(next);
265 kfree(bn->data);
266 kfree(bn);
267 next = journal->j_bitmap_nodes.next;
268 journal->j_free_bitmap_nodes--;
269 }
270
271 return 0;
272}
273
274
275
276
277
278int reiserfs_allocate_list_bitmaps(struct super_block *sb,
279 struct reiserfs_list_bitmap *jb_array,
280 unsigned int bmap_nr)
281{
282 int i;
283 int failed = 0;
284 struct reiserfs_list_bitmap *jb;
285 int mem = bmap_nr * sizeof(struct reiserfs_bitmap_node *);
286
287 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
288 jb = jb_array + i;
289 jb->journal_list = NULL;
290 jb->bitmaps = vzalloc(mem);
291 if (!jb->bitmaps) {
292 reiserfs_warning(sb, "clm-2000", "unable to "
293 "allocate bitmaps for journal lists");
294 failed = 1;
295 break;
296 }
297 }
298 if (failed) {
299 free_list_bitmaps(sb, jb_array);
300 return -1;
301 }
302 return 0;
303}
304
305
306
307
308
309static struct reiserfs_list_bitmap *get_list_bitmap(struct super_block *sb,
310 struct reiserfs_journal_list
311 *jl)
312{
313 int i, j;
314 struct reiserfs_journal *journal = SB_JOURNAL(sb);
315 struct reiserfs_list_bitmap *jb = NULL;
316
317 for (j = 0; j < (JOURNAL_NUM_BITMAPS * 3); j++) {
318 i = journal->j_list_bitmap_index;
319 journal->j_list_bitmap_index = (i + 1) % JOURNAL_NUM_BITMAPS;
320 jb = journal->j_list_bitmap + i;
321 if (journal->j_list_bitmap[i].journal_list) {
322 flush_commit_list(sb,
323 journal->j_list_bitmap[i].
324 journal_list, 1);
325 if (!journal->j_list_bitmap[i].journal_list) {
326 break;
327 }
328 } else {
329 break;
330 }
331 }
332
333 if (jb->journal_list)
334 return NULL;
335 jb->journal_list = jl;
336 return jb;
337}
338
339
340
341
342
343
344static struct reiserfs_journal_cnode *allocate_cnodes(int num_cnodes)
345{
346 struct reiserfs_journal_cnode *head;
347 int i;
348 if (num_cnodes <= 0) {
349 return NULL;
350 }
351 head = vzalloc(array_size(num_cnodes,
352 sizeof(struct reiserfs_journal_cnode)));
353 if (!head) {
354 return NULL;
355 }
356 head[0].prev = NULL;
357 head[0].next = head + 1;
358 for (i = 1; i < num_cnodes; i++) {
359 head[i].prev = head + (i - 1);
360 head[i].next = head + (i + 1);
361 }
362 head[num_cnodes - 1].next = NULL;
363 return head;
364}
365
366
367static struct reiserfs_journal_cnode *get_cnode(struct super_block *sb)
368{
369 struct reiserfs_journal_cnode *cn;
370 struct reiserfs_journal *journal = SB_JOURNAL(sb);
371
372 reiserfs_check_lock_depth(sb, "get_cnode");
373
374 if (journal->j_cnode_free <= 0) {
375 return NULL;
376 }
377 journal->j_cnode_used++;
378 journal->j_cnode_free--;
379 cn = journal->j_cnode_free_list;
380 if (!cn) {
381 return cn;
382 }
383 if (cn->next) {
384 cn->next->prev = NULL;
385 }
386 journal->j_cnode_free_list = cn->next;
387 memset(cn, 0, sizeof(struct reiserfs_journal_cnode));
388 return cn;
389}
390
391
392
393
394static void free_cnode(struct super_block *sb,
395 struct reiserfs_journal_cnode *cn)
396{
397 struct reiserfs_journal *journal = SB_JOURNAL(sb);
398
399 reiserfs_check_lock_depth(sb, "free_cnode");
400
401 journal->j_cnode_used--;
402 journal->j_cnode_free++;
403
404 cn->next = journal->j_cnode_free_list;
405 if (journal->j_cnode_free_list) {
406 journal->j_cnode_free_list->prev = cn;
407 }
408 cn->prev = NULL;
409 journal->j_cnode_free_list = cn;
410}
411
412static void clear_prepared_bits(struct buffer_head *bh)
413{
414 clear_buffer_journal_prepared(bh);
415 clear_buffer_journal_restore_dirty(bh);
416}
417
418
419
420
421
422static inline struct reiserfs_journal_cnode *get_journal_hash_dev(struct
423 super_block
424 *sb,
425 struct
426 reiserfs_journal_cnode
427 **table,
428 long bl)
429{
430 struct reiserfs_journal_cnode *cn;
431 cn = journal_hash(table, sb, bl);
432 while (cn) {
433 if (cn->blocknr == bl && cn->sb == sb)
434 return cn;
435 cn = cn->hnext;
436 }
437 return (struct reiserfs_journal_cnode *)0;
438}
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459int reiserfs_in_journal(struct super_block *sb,
460 unsigned int bmap_nr, int bit_nr, int search_all,
461 b_blocknr_t * next_zero_bit)
462{
463 struct reiserfs_journal *journal = SB_JOURNAL(sb);
464 struct reiserfs_list_bitmap *jb;
465 int i;
466 unsigned long bl;
467
468 *next_zero_bit = 0;
469
470 PROC_INFO_INC(sb, journal.in_journal);
471
472
473
474
475
476
477 if (search_all) {
478 for (i = 0; i < JOURNAL_NUM_BITMAPS; i++) {
479 PROC_INFO_INC(sb, journal.in_journal_bitmap);
480 jb = journal->j_list_bitmap + i;
481 if (jb->journal_list && jb->bitmaps[bmap_nr] &&
482 test_bit(bit_nr,
483 (unsigned long *)jb->bitmaps[bmap_nr]->
484 data)) {
485 *next_zero_bit =
486 find_next_zero_bit((unsigned long *)
487 (jb->bitmaps[bmap_nr]->
488 data),
489 sb->s_blocksize << 3,
490 bit_nr + 1);
491 return 1;
492 }
493 }
494 }
495
496 bl = bmap_nr * (sb->s_blocksize << 3) + bit_nr;
497
498 if (search_all
499 && (get_journal_hash_dev(sb, journal->j_list_hash_table, bl))) {
500 return 1;
501 }
502
503
504 if ((get_journal_hash_dev(sb, journal->j_hash_table, bl))) {
505 BUG();
506 return 1;
507 }
508
509 PROC_INFO_INC(sb, journal.in_journal_reusable);
510
511 return 0;
512}
513
514
515static inline void insert_journal_hash(struct reiserfs_journal_cnode **table,
516 struct reiserfs_journal_cnode *cn)
517{
518 struct reiserfs_journal_cnode *cn_orig;
519
520 cn_orig = journal_hash(table, cn->sb, cn->blocknr);
521 cn->hnext = cn_orig;
522 cn->hprev = NULL;
523 if (cn_orig) {
524 cn_orig->hprev = cn;
525 }
526 journal_hash(table, cn->sb, cn->blocknr) = cn;
527}
528
529
530static inline void lock_journal(struct super_block *sb)
531{
532 PROC_INFO_INC(sb, journal.lock_journal);
533
534 reiserfs_mutex_lock_safe(&SB_JOURNAL(sb)->j_mutex, sb);
535}
536
537
538static inline void unlock_journal(struct super_block *sb)
539{
540 mutex_unlock(&SB_JOURNAL(sb)->j_mutex);
541}
542
543static inline void get_journal_list(struct reiserfs_journal_list *jl)
544{
545 jl->j_refcount++;
546}
547
548static inline void put_journal_list(struct super_block *s,
549 struct reiserfs_journal_list *jl)
550{
551 if (jl->j_refcount < 1) {
552 reiserfs_panic(s, "journal-2", "trans id %u, refcount at %d",
553 jl->j_trans_id, jl->j_refcount);
554 }
555 if (--jl->j_refcount == 0)
556 kfree(jl);
557}
558
559
560
561
562
563
564static void cleanup_freed_for_journal_list(struct super_block *sb,
565 struct reiserfs_journal_list *jl)
566{
567
568 struct reiserfs_list_bitmap *jb = jl->j_list_bitmap;
569 if (jb) {
570 cleanup_bitmap_list(sb, jb);
571 }
572 jl->j_list_bitmap->journal_list = NULL;
573 jl->j_list_bitmap = NULL;
574}
575
576static int journal_list_still_alive(struct super_block *s,
577 unsigned int trans_id)
578{
579 struct reiserfs_journal *journal = SB_JOURNAL(s);
580 struct list_head *entry = &journal->j_journal_list;
581 struct reiserfs_journal_list *jl;
582
583 if (!list_empty(entry)) {
584 jl = JOURNAL_LIST_ENTRY(entry->next);
585 if (jl->j_trans_id <= trans_id) {
586 return 1;
587 }
588 }
589 return 0;
590}
591
592
593
594
595
596
597
598
599
600
601
602static void release_buffer_page(struct buffer_head *bh)
603{
604 struct page *page = bh->b_page;
605 if (!page->mapping && trylock_page(page)) {
606 get_page(page);
607 put_bh(bh);
608 if (!page->mapping)
609 try_to_free_buffers(page);
610 unlock_page(page);
611 put_page(page);
612 } else {
613 put_bh(bh);
614 }
615}
616
617static void reiserfs_end_buffer_io_sync(struct buffer_head *bh, int uptodate)
618{
619 if (buffer_journaled(bh)) {
620 reiserfs_warning(NULL, "clm-2084",
621 "pinned buffer %lu:%pg sent to disk",
622 bh->b_blocknr, bh->b_bdev);
623 }
624 if (uptodate)
625 set_buffer_uptodate(bh);
626 else
627 clear_buffer_uptodate(bh);
628
629 unlock_buffer(bh);
630 release_buffer_page(bh);
631}
632
633static void reiserfs_end_ordered_io(struct buffer_head *bh, int uptodate)
634{
635 if (uptodate)
636 set_buffer_uptodate(bh);
637 else
638 clear_buffer_uptodate(bh);
639 unlock_buffer(bh);
640 put_bh(bh);
641}
642
643static void submit_logged_buffer(struct buffer_head *bh)
644{
645 get_bh(bh);
646 bh->b_end_io = reiserfs_end_buffer_io_sync;
647 clear_buffer_journal_new(bh);
648 clear_buffer_dirty(bh);
649 if (!test_clear_buffer_journal_test(bh))
650 BUG();
651 if (!buffer_uptodate(bh))
652 BUG();
653 submit_bh(REQ_OP_WRITE, 0, bh);
654}
655
656static void submit_ordered_buffer(struct buffer_head *bh)
657{
658 get_bh(bh);
659 bh->b_end_io = reiserfs_end_ordered_io;
660 clear_buffer_dirty(bh);
661 if (!buffer_uptodate(bh))
662 BUG();
663 submit_bh(REQ_OP_WRITE, 0, bh);
664}
665
666#define CHUNK_SIZE 32
667struct buffer_chunk {
668 struct buffer_head *bh[CHUNK_SIZE];
669 int nr;
670};
671
672static void write_chunk(struct buffer_chunk *chunk)
673{
674 int i;
675 for (i = 0; i < chunk->nr; i++) {
676 submit_logged_buffer(chunk->bh[i]);
677 }
678 chunk->nr = 0;
679}
680
681static void write_ordered_chunk(struct buffer_chunk *chunk)
682{
683 int i;
684 for (i = 0; i < chunk->nr; i++) {
685 submit_ordered_buffer(chunk->bh[i]);
686 }
687 chunk->nr = 0;
688}
689
690static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
691 spinlock_t * lock, void (fn) (struct buffer_chunk *))
692{
693 int ret = 0;
694 BUG_ON(chunk->nr >= CHUNK_SIZE);
695 chunk->bh[chunk->nr++] = bh;
696 if (chunk->nr >= CHUNK_SIZE) {
697 ret = 1;
698 if (lock) {
699 spin_unlock(lock);
700 fn(chunk);
701 spin_lock(lock);
702 } else {
703 fn(chunk);
704 }
705 }
706 return ret;
707}
708
709static atomic_t nr_reiserfs_jh = ATOMIC_INIT(0);
710static struct reiserfs_jh *alloc_jh(void)
711{
712 struct reiserfs_jh *jh;
713 while (1) {
714 jh = kmalloc(sizeof(*jh), GFP_NOFS);
715 if (jh) {
716 atomic_inc(&nr_reiserfs_jh);
717 return jh;
718 }
719 yield();
720 }
721}
722
723
724
725
726
727void reiserfs_free_jh(struct buffer_head *bh)
728{
729 struct reiserfs_jh *jh;
730
731 jh = bh->b_private;
732 if (jh) {
733 bh->b_private = NULL;
734 jh->bh = NULL;
735 list_del_init(&jh->list);
736 kfree(jh);
737 if (atomic_read(&nr_reiserfs_jh) <= 0)
738 BUG();
739 atomic_dec(&nr_reiserfs_jh);
740 put_bh(bh);
741 }
742}
743
744static inline int __add_jh(struct reiserfs_journal *j, struct buffer_head *bh,
745 int tail)
746{
747 struct reiserfs_jh *jh;
748
749 if (bh->b_private) {
750 spin_lock(&j->j_dirty_buffers_lock);
751 if (!bh->b_private) {
752 spin_unlock(&j->j_dirty_buffers_lock);
753 goto no_jh;
754 }
755 jh = bh->b_private;
756 list_del_init(&jh->list);
757 } else {
758no_jh:
759 get_bh(bh);
760 jh = alloc_jh();
761 spin_lock(&j->j_dirty_buffers_lock);
762
763
764
765
766 BUG_ON(bh->b_private);
767 jh->bh = bh;
768 bh->b_private = jh;
769 }
770 jh->jl = j->j_current_jl;
771 if (tail)
772 list_add_tail(&jh->list, &jh->jl->j_tail_bh_list);
773 else {
774 list_add_tail(&jh->list, &jh->jl->j_bh_list);
775 }
776 spin_unlock(&j->j_dirty_buffers_lock);
777 return 0;
778}
779
780int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh)
781{
782 return __add_jh(SB_JOURNAL(inode->i_sb), bh, 1);
783}
784int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh)
785{
786 return __add_jh(SB_JOURNAL(inode->i_sb), bh, 0);
787}
788
789#define JH_ENTRY(l) list_entry((l), struct reiserfs_jh, list)
790static int write_ordered_buffers(spinlock_t * lock,
791 struct reiserfs_journal *j,
792 struct reiserfs_journal_list *jl,
793 struct list_head *list)
794{
795 struct buffer_head *bh;
796 struct reiserfs_jh *jh;
797 int ret = j->j_errno;
798 struct buffer_chunk chunk;
799 struct list_head tmp;
800 INIT_LIST_HEAD(&tmp);
801
802 chunk.nr = 0;
803 spin_lock(lock);
804 while (!list_empty(list)) {
805 jh = JH_ENTRY(list->next);
806 bh = jh->bh;
807 get_bh(bh);
808 if (!trylock_buffer(bh)) {
809 if (!buffer_dirty(bh)) {
810 list_move(&jh->list, &tmp);
811 goto loop_next;
812 }
813 spin_unlock(lock);
814 if (chunk.nr)
815 write_ordered_chunk(&chunk);
816 wait_on_buffer(bh);
817 cond_resched();
818 spin_lock(lock);
819 goto loop_next;
820 }
821
822
823
824
825
826 if (!buffer_uptodate(bh) && buffer_dirty(bh)) {
827 clear_buffer_dirty(bh);
828 ret = -EIO;
829 }
830 if (buffer_dirty(bh)) {
831 list_move(&jh->list, &tmp);
832 add_to_chunk(&chunk, bh, lock, write_ordered_chunk);
833 } else {
834 reiserfs_free_jh(bh);
835 unlock_buffer(bh);
836 }
837loop_next:
838 put_bh(bh);
839 cond_resched_lock(lock);
840 }
841 if (chunk.nr) {
842 spin_unlock(lock);
843 write_ordered_chunk(&chunk);
844 spin_lock(lock);
845 }
846 while (!list_empty(&tmp)) {
847 jh = JH_ENTRY(tmp.prev);
848 bh = jh->bh;
849 get_bh(bh);
850 reiserfs_free_jh(bh);
851
852 if (buffer_locked(bh)) {
853 spin_unlock(lock);
854 wait_on_buffer(bh);
855 spin_lock(lock);
856 }
857 if (!buffer_uptodate(bh)) {
858 ret = -EIO;
859 }
860
861
862
863
864
865
866
867
868
869 if (buffer_dirty(bh) && unlikely(bh->b_page->mapping == NULL)) {
870 spin_unlock(lock);
871 ll_rw_block(REQ_OP_WRITE, 0, 1, &bh);
872 spin_lock(lock);
873 }
874 put_bh(bh);
875 cond_resched_lock(lock);
876 }
877 spin_unlock(lock);
878 return ret;
879}
880
881static int flush_older_commits(struct super_block *s,
882 struct reiserfs_journal_list *jl)
883{
884 struct reiserfs_journal *journal = SB_JOURNAL(s);
885 struct reiserfs_journal_list *other_jl;
886 struct reiserfs_journal_list *first_jl;
887 struct list_head *entry;
888 unsigned int trans_id = jl->j_trans_id;
889 unsigned int other_trans_id;
890
891find_first:
892
893
894
895 first_jl = jl;
896 entry = jl->j_list.prev;
897 while (1) {
898 other_jl = JOURNAL_LIST_ENTRY(entry);
899 if (entry == &journal->j_journal_list ||
900 atomic_read(&other_jl->j_older_commits_done))
901 break;
902
903 first_jl = other_jl;
904 entry = other_jl->j_list.prev;
905 }
906
907
908 if (first_jl == jl) {
909 return 0;
910 }
911
912 entry = &first_jl->j_list;
913 while (1) {
914 other_jl = JOURNAL_LIST_ENTRY(entry);
915 other_trans_id = other_jl->j_trans_id;
916
917 if (other_trans_id < trans_id) {
918 if (atomic_read(&other_jl->j_commit_left) != 0) {
919 flush_commit_list(s, other_jl, 0);
920
921
922 if (!journal_list_still_alive(s, trans_id))
923 return 1;
924
925
926
927
928
929
930
931 if (!journal_list_still_alive
932 (s, other_trans_id)) {
933 goto find_first;
934 }
935 }
936 entry = entry->next;
937 if (entry == &journal->j_journal_list)
938 return 0;
939 } else {
940 return 0;
941 }
942 }
943 return 0;
944}
945
946static int reiserfs_async_progress_wait(struct super_block *s)
947{
948 struct reiserfs_journal *j = SB_JOURNAL(s);
949
950 if (atomic_read(&j->j_async_throttle)) {
951 int depth;
952
953 depth = reiserfs_write_unlock_nested(s);
954 congestion_wait(BLK_RW_ASYNC, HZ / 10);
955 reiserfs_write_lock_nested(s, depth);
956 }
957
958 return 0;
959}
960
961
962
963
964
965
966
967
968static int flush_commit_list(struct super_block *s,
969 struct reiserfs_journal_list *jl, int flushall)
970{
971 int i;
972 b_blocknr_t bn;
973 struct buffer_head *tbh = NULL;
974 unsigned int trans_id = jl->j_trans_id;
975 struct reiserfs_journal *journal = SB_JOURNAL(s);
976 int retval = 0;
977 int write_len;
978 int depth;
979
980 reiserfs_check_lock_depth(s, "flush_commit_list");
981
982 if (atomic_read(&jl->j_older_commits_done)) {
983 return 0;
984 }
985
986
987
988
989
990 BUG_ON(jl->j_len <= 0);
991 BUG_ON(trans_id == journal->j_trans_id);
992
993 get_journal_list(jl);
994 if (flushall) {
995 if (flush_older_commits(s, jl) == 1) {
996
997
998
999
1000 goto put_jl;
1001 }
1002 }
1003
1004
1005 reiserfs_mutex_lock_safe(&jl->j_commit_mutex, s);
1006
1007 if (!journal_list_still_alive(s, trans_id)) {
1008 mutex_unlock(&jl->j_commit_mutex);
1009 goto put_jl;
1010 }
1011 BUG_ON(jl->j_trans_id == 0);
1012
1013
1014 if (atomic_read(&jl->j_commit_left) <= 0) {
1015 if (flushall) {
1016 atomic_set(&jl->j_older_commits_done, 1);
1017 }
1018 mutex_unlock(&jl->j_commit_mutex);
1019 goto put_jl;
1020 }
1021
1022 if (!list_empty(&jl->j_bh_list)) {
1023 int ret;
1024
1025
1026
1027
1028
1029 depth = reiserfs_write_unlock_nested(s);
1030 ret = write_ordered_buffers(&journal->j_dirty_buffers_lock,
1031 journal, jl, &jl->j_bh_list);
1032 if (ret < 0 && retval == 0)
1033 retval = ret;
1034 reiserfs_write_lock_nested(s, depth);
1035 }
1036 BUG_ON(!list_empty(&jl->j_bh_list));
1037
1038
1039
1040
1041
1042
1043
1044 atomic_inc(&journal->j_async_throttle);
1045 write_len = jl->j_len + 1;
1046 if (write_len < 256)
1047 write_len = 256;
1048 for (i = 0 ; i < write_len ; i++) {
1049 bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) + (jl->j_start + i) %
1050 SB_ONDISK_JOURNAL_SIZE(s);
1051 tbh = journal_find_get_block(s, bn);
1052 if (tbh) {
1053 if (buffer_dirty(tbh)) {
1054 depth = reiserfs_write_unlock_nested(s);
1055 ll_rw_block(REQ_OP_WRITE, 0, 1, &tbh);
1056 reiserfs_write_lock_nested(s, depth);
1057 }
1058 put_bh(tbh) ;
1059 }
1060 }
1061 atomic_dec(&journal->j_async_throttle);
1062
1063 for (i = 0; i < (jl->j_len + 1); i++) {
1064 bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) +
1065 (jl->j_start + i) % SB_ONDISK_JOURNAL_SIZE(s);
1066 tbh = journal_find_get_block(s, bn);
1067
1068 depth = reiserfs_write_unlock_nested(s);
1069 __wait_on_buffer(tbh);
1070 reiserfs_write_lock_nested(s, depth);
1071
1072
1073
1074
1075
1076 if (buffer_dirty(tbh)) {
1077 depth = reiserfs_write_unlock_nested(s);
1078 sync_dirty_buffer(tbh);
1079 reiserfs_write_lock_nested(s, depth);
1080 }
1081 if (unlikely(!buffer_uptodate(tbh))) {
1082#ifdef CONFIG_REISERFS_CHECK
1083 reiserfs_warning(s, "journal-601",
1084 "buffer write failed");
1085#endif
1086 retval = -EIO;
1087 }
1088
1089 put_bh(tbh);
1090
1091 put_bh(tbh);
1092 atomic_dec(&jl->j_commit_left);
1093 }
1094
1095 BUG_ON(atomic_read(&jl->j_commit_left) != 1);
1096
1097
1098
1099
1100
1101
1102
1103 if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
1104 if (buffer_dirty(jl->j_commit_bh))
1105 BUG();
1106 mark_buffer_dirty(jl->j_commit_bh) ;
1107 depth = reiserfs_write_unlock_nested(s);
1108 if (reiserfs_barrier_flush(s))
1109 __sync_dirty_buffer(jl->j_commit_bh,
1110 REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
1111 else
1112 sync_dirty_buffer(jl->j_commit_bh);
1113 reiserfs_write_lock_nested(s, depth);
1114 }
1115
1116
1117
1118
1119
1120
1121 if (unlikely(!buffer_uptodate(jl->j_commit_bh))) {
1122#ifdef CONFIG_REISERFS_CHECK
1123 reiserfs_warning(s, "journal-615", "buffer write failed");
1124#endif
1125 retval = -EIO;
1126 }
1127 bforget(jl->j_commit_bh);
1128 if (journal->j_last_commit_id != 0 &&
1129 (jl->j_trans_id - journal->j_last_commit_id) != 1) {
1130 reiserfs_warning(s, "clm-2200", "last commit %lu, current %lu",
1131 journal->j_last_commit_id, jl->j_trans_id);
1132 }
1133 journal->j_last_commit_id = jl->j_trans_id;
1134
1135
1136
1137
1138
1139 cleanup_freed_for_journal_list(s, jl);
1140
1141 retval = retval ? retval : journal->j_errno;
1142
1143
1144 if (!retval)
1145 dirty_one_transaction(s, jl);
1146 atomic_dec(&jl->j_commit_left);
1147
1148 if (flushall) {
1149 atomic_set(&jl->j_older_commits_done, 1);
1150 }
1151 mutex_unlock(&jl->j_commit_mutex);
1152put_jl:
1153 put_journal_list(s, jl);
1154
1155 if (retval)
1156 reiserfs_abort(s, retval, "Journal write error in %s",
1157 __func__);
1158 return retval;
1159}
1160
1161
1162
1163
1164
1165static struct reiserfs_journal_list *find_newer_jl_for_cn(struct
1166 reiserfs_journal_cnode
1167 *cn)
1168{
1169 struct super_block *sb = cn->sb;
1170 b_blocknr_t blocknr = cn->blocknr;
1171
1172 cn = cn->hprev;
1173 while (cn) {
1174 if (cn->sb == sb && cn->blocknr == blocknr && cn->jlist) {
1175 return cn->jlist;
1176 }
1177 cn = cn->hprev;
1178 }
1179 return NULL;
1180}
1181
1182static void remove_journal_hash(struct super_block *,
1183 struct reiserfs_journal_cnode **,
1184 struct reiserfs_journal_list *, unsigned long,
1185 int);
1186
1187
1188
1189
1190
1191
1192
1193static void remove_all_from_journal_list(struct super_block *sb,
1194 struct reiserfs_journal_list *jl,
1195 int debug)
1196{
1197 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1198 struct reiserfs_journal_cnode *cn, *last;
1199 cn = jl->j_realblock;
1200
1201
1202
1203
1204
1205 while (cn) {
1206 if (cn->blocknr != 0) {
1207 if (debug) {
1208 reiserfs_warning(sb, "reiserfs-2201",
1209 "block %u, bh is %d, state %ld",
1210 cn->blocknr, cn->bh ? 1 : 0,
1211 cn->state);
1212 }
1213 cn->state = 0;
1214 remove_journal_hash(sb, journal->j_list_hash_table,
1215 jl, cn->blocknr, 1);
1216 }
1217 last = cn;
1218 cn = cn->next;
1219 free_cnode(sb, last);
1220 }
1221 jl->j_realblock = NULL;
1222}
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232static int _update_journal_header_block(struct super_block *sb,
1233 unsigned long offset,
1234 unsigned int trans_id)
1235{
1236 struct reiserfs_journal_header *jh;
1237 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1238 int depth;
1239
1240 if (reiserfs_is_journal_aborted(journal))
1241 return -EIO;
1242
1243 if (trans_id >= journal->j_last_flush_trans_id) {
1244 if (buffer_locked((journal->j_header_bh))) {
1245 depth = reiserfs_write_unlock_nested(sb);
1246 __wait_on_buffer(journal->j_header_bh);
1247 reiserfs_write_lock_nested(sb, depth);
1248 if (unlikely(!buffer_uptodate(journal->j_header_bh))) {
1249#ifdef CONFIG_REISERFS_CHECK
1250 reiserfs_warning(sb, "journal-699",
1251 "buffer write failed");
1252#endif
1253 return -EIO;
1254 }
1255 }
1256 journal->j_last_flush_trans_id = trans_id;
1257 journal->j_first_unflushed_offset = offset;
1258 jh = (struct reiserfs_journal_header *)(journal->j_header_bh->
1259 b_data);
1260 jh->j_last_flush_trans_id = cpu_to_le32(trans_id);
1261 jh->j_first_unflushed_offset = cpu_to_le32(offset);
1262 jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
1263
1264 set_buffer_dirty(journal->j_header_bh);
1265 depth = reiserfs_write_unlock_nested(sb);
1266
1267 if (reiserfs_barrier_flush(sb))
1268 __sync_dirty_buffer(journal->j_header_bh,
1269 REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
1270 else
1271 sync_dirty_buffer(journal->j_header_bh);
1272
1273 reiserfs_write_lock_nested(sb, depth);
1274 if (!buffer_uptodate(journal->j_header_bh)) {
1275 reiserfs_warning(sb, "journal-837",
1276 "IO error during journal replay");
1277 return -EIO;
1278 }
1279 }
1280 return 0;
1281}
1282
1283static int update_journal_header_block(struct super_block *sb,
1284 unsigned long offset,
1285 unsigned int trans_id)
1286{
1287 return _update_journal_header_block(sb, offset, trans_id);
1288}
1289
1290
1291
1292
1293
1294static int flush_older_journal_lists(struct super_block *sb,
1295 struct reiserfs_journal_list *jl)
1296{
1297 struct list_head *entry;
1298 struct reiserfs_journal_list *other_jl;
1299 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1300 unsigned int trans_id = jl->j_trans_id;
1301
1302
1303
1304
1305
1306restart:
1307 entry = journal->j_journal_list.next;
1308
1309 if (entry == &journal->j_journal_list)
1310 return 0;
1311 other_jl = JOURNAL_LIST_ENTRY(entry);
1312 if (other_jl->j_trans_id < trans_id) {
1313 BUG_ON(other_jl->j_refcount <= 0);
1314
1315 flush_journal_list(sb, other_jl, 0);
1316
1317
1318 goto restart;
1319 }
1320 return 0;
1321}
1322
1323static void del_from_work_list(struct super_block *s,
1324 struct reiserfs_journal_list *jl)
1325{
1326 struct reiserfs_journal *journal = SB_JOURNAL(s);
1327 if (!list_empty(&jl->j_working_list)) {
1328 list_del_init(&jl->j_working_list);
1329 journal->j_num_work_lists--;
1330 }
1331}
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343static int flush_journal_list(struct super_block *s,
1344 struct reiserfs_journal_list *jl, int flushall)
1345{
1346 struct reiserfs_journal_list *pjl;
1347 struct reiserfs_journal_cnode *cn;
1348 int count;
1349 int was_jwait = 0;
1350 int was_dirty = 0;
1351 struct buffer_head *saved_bh;
1352 unsigned long j_len_saved = jl->j_len;
1353 struct reiserfs_journal *journal = SB_JOURNAL(s);
1354 int err = 0;
1355 int depth;
1356
1357 BUG_ON(j_len_saved <= 0);
1358
1359 if (atomic_read(&journal->j_wcount) != 0) {
1360 reiserfs_warning(s, "clm-2048", "called with wcount %d",
1361 atomic_read(&journal->j_wcount));
1362 }
1363
1364
1365 if (flushall) {
1366 reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
1367 } else if (mutex_trylock(&journal->j_flush_mutex)) {
1368 BUG();
1369 }
1370
1371 count = 0;
1372 if (j_len_saved > journal->j_trans_max) {
1373 reiserfs_panic(s, "journal-715", "length is %lu, trans id %lu",
1374 j_len_saved, jl->j_trans_id);
1375 return 0;
1376 }
1377
1378
1379 if (atomic_read(&jl->j_nonzerolen) <= 0 &&
1380 atomic_read(&jl->j_commit_left) <= 0) {
1381 goto flush_older_and_return;
1382 }
1383
1384
1385
1386
1387
1388 flush_commit_list(s, jl, 1);
1389
1390 if (!(jl->j_state & LIST_DIRTY)
1391 && !reiserfs_is_journal_aborted(journal))
1392 BUG();
1393
1394
1395 if (atomic_read(&jl->j_nonzerolen) <= 0 &&
1396 atomic_read(&jl->j_commit_left) <= 0) {
1397 goto flush_older_and_return;
1398 }
1399
1400
1401
1402
1403
1404 if (atomic_read(&journal->j_wcount) != 0) {
1405 reiserfs_panic(s, "journal-844", "journal list is flushing, "
1406 "wcount is not 0");
1407 }
1408 cn = jl->j_realblock;
1409 while (cn) {
1410 was_jwait = 0;
1411 was_dirty = 0;
1412 saved_bh = NULL;
1413
1414 if (cn->blocknr == 0) {
1415 goto free_cnode;
1416 }
1417
1418
1419
1420
1421
1422 if (!(jl->j_state & LIST_DIRTY))
1423 goto free_cnode;
1424
1425 pjl = find_newer_jl_for_cn(cn);
1426
1427
1428
1429
1430
1431 if (!pjl && cn->bh) {
1432 saved_bh = cn->bh;
1433
1434
1435
1436
1437
1438 get_bh(saved_bh);
1439
1440 if (buffer_journal_dirty(saved_bh)) {
1441 BUG_ON(!can_dirty(cn));
1442 was_jwait = 1;
1443 was_dirty = 1;
1444 } else if (can_dirty(cn)) {
1445
1446
1447
1448
1449 BUG();
1450 }
1451 }
1452
1453
1454
1455
1456
1457 if (pjl) {
1458 if (atomic_read(&pjl->j_commit_left))
1459 flush_commit_list(s, pjl, 1);
1460 goto free_cnode;
1461 }
1462
1463
1464
1465
1466
1467 if (saved_bh == NULL) {
1468 goto free_cnode;
1469 }
1470
1471
1472
1473
1474
1475
1476 if ((!was_jwait) && !buffer_locked(saved_bh)) {
1477 reiserfs_warning(s, "journal-813",
1478 "BAD! buffer %llu %cdirty %cjwait, "
1479 "not in a newer transaction",
1480 (unsigned long long)saved_bh->
1481 b_blocknr, was_dirty ? ' ' : '!',
1482 was_jwait ? ' ' : '!');
1483 }
1484 if (was_dirty) {
1485
1486
1487
1488
1489 get_bh(saved_bh);
1490 set_bit(BLOCK_NEEDS_FLUSH, &cn->state);
1491 lock_buffer(saved_bh);
1492 BUG_ON(cn->blocknr != saved_bh->b_blocknr);
1493 if (buffer_dirty(saved_bh))
1494 submit_logged_buffer(saved_bh);
1495 else
1496 unlock_buffer(saved_bh);
1497 count++;
1498 } else {
1499 reiserfs_warning(s, "clm-2082",
1500 "Unable to flush buffer %llu in %s",
1501 (unsigned long long)saved_bh->
1502 b_blocknr, __func__);
1503 }
1504free_cnode:
1505 cn = cn->next;
1506 if (saved_bh) {
1507
1508
1509
1510
1511 put_bh(saved_bh);
1512 if (atomic_read(&saved_bh->b_count) < 0) {
1513 reiserfs_warning(s, "journal-945",
1514 "saved_bh->b_count < 0");
1515 }
1516 }
1517 }
1518 if (count > 0) {
1519 cn = jl->j_realblock;
1520 while (cn) {
1521 if (test_bit(BLOCK_NEEDS_FLUSH, &cn->state)) {
1522 if (!cn->bh) {
1523 reiserfs_panic(s, "journal-1011",
1524 "cn->bh is NULL");
1525 }
1526
1527 depth = reiserfs_write_unlock_nested(s);
1528 __wait_on_buffer(cn->bh);
1529 reiserfs_write_lock_nested(s, depth);
1530
1531 if (!cn->bh) {
1532 reiserfs_panic(s, "journal-1012",
1533 "cn->bh is NULL");
1534 }
1535 if (unlikely(!buffer_uptodate(cn->bh))) {
1536#ifdef CONFIG_REISERFS_CHECK
1537 reiserfs_warning(s, "journal-949",
1538 "buffer write failed");
1539#endif
1540 err = -EIO;
1541 }
1542
1543
1544
1545
1546
1547 BUG_ON(!test_clear_buffer_journal_dirty
1548 (cn->bh));
1549
1550
1551 put_bh(cn->bh);
1552
1553 release_buffer_page(cn->bh);
1554 }
1555 cn = cn->next;
1556 }
1557 }
1558
1559 if (err)
1560 reiserfs_abort(s, -EIO,
1561 "Write error while pushing transaction to disk in %s",
1562 __func__);
1563flush_older_and_return:
1564
1565
1566
1567
1568
1569
1570
1571 if (flushall) {
1572 flush_older_journal_lists(s, jl);
1573 }
1574
1575 err = journal->j_errno;
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585 if (!err && flushall) {
1586 err =
1587 update_journal_header_block(s,
1588 (jl->j_start + jl->j_len +
1589 2) % SB_ONDISK_JOURNAL_SIZE(s),
1590 jl->j_trans_id);
1591 if (err)
1592 reiserfs_abort(s, -EIO,
1593 "Write error while updating journal header in %s",
1594 __func__);
1595 }
1596 remove_all_from_journal_list(s, jl, 0);
1597 list_del_init(&jl->j_list);
1598 journal->j_num_lists--;
1599 del_from_work_list(s, jl);
1600
1601 if (journal->j_last_flush_id != 0 &&
1602 (jl->j_trans_id - journal->j_last_flush_id) != 1) {
1603 reiserfs_warning(s, "clm-2201", "last flush %lu, current %lu",
1604 journal->j_last_flush_id, jl->j_trans_id);
1605 }
1606 journal->j_last_flush_id = jl->j_trans_id;
1607
1608
1609
1610
1611
1612 jl->j_len = 0;
1613 atomic_set(&jl->j_nonzerolen, 0);
1614 jl->j_start = 0;
1615 jl->j_realblock = NULL;
1616 jl->j_commit_bh = NULL;
1617 jl->j_trans_id = 0;
1618 jl->j_state = 0;
1619 put_journal_list(s, jl);
1620 if (flushall)
1621 mutex_unlock(&journal->j_flush_mutex);
1622 return err;
1623}
1624
1625static int write_one_transaction(struct super_block *s,
1626 struct reiserfs_journal_list *jl,
1627 struct buffer_chunk *chunk)
1628{
1629 struct reiserfs_journal_cnode *cn;
1630 int ret = 0;
1631
1632 jl->j_state |= LIST_TOUCHED;
1633 del_from_work_list(s, jl);
1634 if (jl->j_len == 0 || atomic_read(&jl->j_nonzerolen) == 0) {
1635 return 0;
1636 }
1637
1638 cn = jl->j_realblock;
1639 while (cn) {
1640
1641
1642
1643
1644 if (cn->blocknr == 0) {
1645 goto next;
1646 }
1647 if (cn->bh && can_dirty(cn) && buffer_dirty(cn->bh)) {
1648 struct buffer_head *tmp_bh;
1649
1650
1651
1652
1653
1654 tmp_bh = cn->bh;
1655 get_bh(tmp_bh);
1656 lock_buffer(tmp_bh);
1657 if (cn->bh && can_dirty(cn) && buffer_dirty(tmp_bh)) {
1658 if (!buffer_journal_dirty(tmp_bh) ||
1659 buffer_journal_prepared(tmp_bh))
1660 BUG();
1661 add_to_chunk(chunk, tmp_bh, NULL, write_chunk);
1662 ret++;
1663 } else {
1664
1665 unlock_buffer(tmp_bh);
1666 }
1667 put_bh(tmp_bh);
1668 }
1669next:
1670 cn = cn->next;
1671 cond_resched();
1672 }
1673 return ret;
1674}
1675
1676
1677static void dirty_one_transaction(struct super_block *s,
1678 struct reiserfs_journal_list *jl)
1679{
1680 struct reiserfs_journal_cnode *cn;
1681 struct reiserfs_journal_list *pjl;
1682
1683 jl->j_state |= LIST_DIRTY;
1684 cn = jl->j_realblock;
1685 while (cn) {
1686
1687
1688
1689
1690
1691 pjl = find_newer_jl_for_cn(cn);
1692 if (!pjl && cn->blocknr && cn->bh
1693 && buffer_journal_dirty(cn->bh)) {
1694 BUG_ON(!can_dirty(cn));
1695
1696
1697
1698
1699
1700 clear_buffer_journal_new(cn->bh);
1701 if (buffer_journal_prepared(cn->bh)) {
1702 set_buffer_journal_restore_dirty(cn->bh);
1703 } else {
1704 set_buffer_journal_test(cn->bh);
1705 mark_buffer_dirty(cn->bh);
1706 }
1707 }
1708 cn = cn->next;
1709 }
1710}
1711
1712static int kupdate_transactions(struct super_block *s,
1713 struct reiserfs_journal_list *jl,
1714 struct reiserfs_journal_list **next_jl,
1715 unsigned int *next_trans_id,
1716 int num_blocks, int num_trans)
1717{
1718 int ret = 0;
1719 int written = 0;
1720 int transactions_flushed = 0;
1721 unsigned int orig_trans_id = jl->j_trans_id;
1722 struct buffer_chunk chunk;
1723 struct list_head *entry;
1724 struct reiserfs_journal *journal = SB_JOURNAL(s);
1725 chunk.nr = 0;
1726
1727 reiserfs_mutex_lock_safe(&journal->j_flush_mutex, s);
1728 if (!journal_list_still_alive(s, orig_trans_id)) {
1729 goto done;
1730 }
1731
1732
1733
1734
1735
1736 while ((num_trans && transactions_flushed < num_trans) ||
1737 (!num_trans && written < num_blocks)) {
1738
1739 if (jl->j_len == 0 || (jl->j_state & LIST_TOUCHED) ||
1740 atomic_read(&jl->j_commit_left)
1741 || !(jl->j_state & LIST_DIRTY)) {
1742 del_from_work_list(s, jl);
1743 break;
1744 }
1745 ret = write_one_transaction(s, jl, &chunk);
1746
1747 if (ret < 0)
1748 goto done;
1749 transactions_flushed++;
1750 written += ret;
1751 entry = jl->j_list.next;
1752
1753
1754 if (entry == &journal->j_journal_list) {
1755 break;
1756 }
1757 jl = JOURNAL_LIST_ENTRY(entry);
1758
1759
1760 if (jl->j_trans_id <= orig_trans_id)
1761 break;
1762 }
1763 if (chunk.nr) {
1764 write_chunk(&chunk);
1765 }
1766
1767done:
1768 mutex_unlock(&journal->j_flush_mutex);
1769 return ret;
1770}
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782static int flush_used_journal_lists(struct super_block *s,
1783 struct reiserfs_journal_list *jl)
1784{
1785 unsigned long len = 0;
1786 unsigned long cur_len;
1787 int i;
1788 int limit = 256;
1789 struct reiserfs_journal_list *tjl;
1790 struct reiserfs_journal_list *flush_jl;
1791 unsigned int trans_id;
1792 struct reiserfs_journal *journal = SB_JOURNAL(s);
1793
1794 flush_jl = tjl = jl;
1795
1796
1797 if (reiserfs_data_log(s))
1798 limit = 1024;
1799
1800 for (i = 0; i < 256 && len < limit; i++) {
1801 if (atomic_read(&tjl->j_commit_left) ||
1802 tjl->j_trans_id < jl->j_trans_id) {
1803 break;
1804 }
1805 cur_len = atomic_read(&tjl->j_nonzerolen);
1806 if (cur_len > 0) {
1807 tjl->j_state &= ~LIST_TOUCHED;
1808 }
1809 len += cur_len;
1810 flush_jl = tjl;
1811 if (tjl->j_list.next == &journal->j_journal_list)
1812 break;
1813 tjl = JOURNAL_LIST_ENTRY(tjl->j_list.next);
1814 }
1815 get_journal_list(jl);
1816 get_journal_list(flush_jl);
1817
1818
1819
1820
1821
1822
1823 if (flush_jl != jl)
1824 kupdate_transactions(s, jl, &tjl, &trans_id, len, i);
1825
1826 flush_journal_list(s, flush_jl, 1);
1827 put_journal_list(s, flush_jl);
1828 put_journal_list(s, jl);
1829 return 0;
1830}
1831
1832
1833
1834
1835
1836static void remove_journal_hash(struct super_block *sb,
1837 struct reiserfs_journal_cnode **table,
1838 struct reiserfs_journal_list *jl,
1839 unsigned long block, int remove_freed)
1840{
1841 struct reiserfs_journal_cnode *cur;
1842 struct reiserfs_journal_cnode **head;
1843
1844 head = &(journal_hash(table, sb, block));
1845 if (!head) {
1846 return;
1847 }
1848 cur = *head;
1849 while (cur) {
1850 if (cur->blocknr == block && cur->sb == sb
1851 && (jl == NULL || jl == cur->jlist)
1852 && (!test_bit(BLOCK_FREED, &cur->state) || remove_freed)) {
1853 if (cur->hnext) {
1854 cur->hnext->hprev = cur->hprev;
1855 }
1856 if (cur->hprev) {
1857 cur->hprev->hnext = cur->hnext;
1858 } else {
1859 *head = cur->hnext;
1860 }
1861 cur->blocknr = 0;
1862 cur->sb = NULL;
1863 cur->state = 0;
1864
1865
1866
1867
1868 if (cur->bh && cur->jlist)
1869 atomic_dec(&cur->jlist->j_nonzerolen);
1870 cur->bh = NULL;
1871 cur->jlist = NULL;
1872 }
1873 cur = cur->hnext;
1874 }
1875}
1876
1877static void free_journal_ram(struct super_block *sb)
1878{
1879 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1880 kfree(journal->j_current_jl);
1881 journal->j_num_lists--;
1882
1883 vfree(journal->j_cnode_free_orig);
1884 free_list_bitmaps(sb, journal->j_list_bitmap);
1885 free_bitmap_nodes(sb);
1886 if (journal->j_header_bh) {
1887 brelse(journal->j_header_bh);
1888 }
1889
1890
1891
1892
1893 release_journal_dev(sb, journal);
1894 vfree(journal);
1895}
1896
1897
1898
1899
1900
1901static int do_journal_release(struct reiserfs_transaction_handle *th,
1902 struct super_block *sb, int error)
1903{
1904 struct reiserfs_transaction_handle myth;
1905 struct reiserfs_journal *journal = SB_JOURNAL(sb);
1906
1907
1908
1909
1910
1911 if (!error && !sb_rdonly(sb)) {
1912
1913 BUG_ON(!th->t_trans_id);
1914 do_journal_end(th, FLUSH_ALL);
1915
1916
1917
1918
1919
1920 if (!journal_join(&myth, sb)) {
1921 reiserfs_prepare_for_journal(sb,
1922 SB_BUFFER_WITH_SB(sb),
1923 1);
1924 journal_mark_dirty(&myth, SB_BUFFER_WITH_SB(sb));
1925 do_journal_end(&myth, FLUSH_ALL);
1926 }
1927 }
1928
1929
1930 if (!error && reiserfs_is_journal_aborted(journal)) {
1931 memset(&myth, 0, sizeof(myth));
1932 if (!journal_join_abort(&myth, sb)) {
1933 reiserfs_prepare_for_journal(sb,
1934 SB_BUFFER_WITH_SB(sb),
1935 1);
1936 journal_mark_dirty(&myth, SB_BUFFER_WITH_SB(sb));
1937 do_journal_end(&myth, FLUSH_ALL);
1938 }
1939 }
1940
1941
1942
1943
1944
1945
1946 reiserfs_write_unlock(sb);
1947
1948
1949
1950
1951
1952
1953 reiserfs_cancel_old_flush(sb);
1954
1955 cancel_delayed_work_sync(&SB_JOURNAL(sb)->j_work);
1956
1957 free_journal_ram(sb);
1958
1959 reiserfs_write_lock(sb);
1960
1961 return 0;
1962}
1963
1964
1965int journal_release(struct reiserfs_transaction_handle *th,
1966 struct super_block *sb)
1967{
1968 return do_journal_release(th, sb, 0);
1969}
1970
1971
1972int journal_release_error(struct reiserfs_transaction_handle *th,
1973 struct super_block *sb)
1974{
1975 return do_journal_release(th, sb, 1);
1976}
1977
1978
1979
1980
1981
1982static int journal_compare_desc_commit(struct super_block *sb,
1983 struct reiserfs_journal_desc *desc,
1984 struct reiserfs_journal_commit *commit)
1985{
1986 if (get_commit_trans_id(commit) != get_desc_trans_id(desc) ||
1987 get_commit_trans_len(commit) != get_desc_trans_len(desc) ||
1988 get_commit_trans_len(commit) > SB_JOURNAL(sb)->j_trans_max ||
1989 get_commit_trans_len(commit) <= 0) {
1990 return 1;
1991 }
1992 return 0;
1993}
1994
1995
1996
1997
1998
1999
2000
2001static int journal_transaction_is_valid(struct super_block *sb,
2002 struct buffer_head *d_bh,
2003 unsigned int *oldest_invalid_trans_id,
2004 unsigned long *newest_mount_id)
2005{
2006 struct reiserfs_journal_desc *desc;
2007 struct reiserfs_journal_commit *commit;
2008 struct buffer_head *c_bh;
2009 unsigned long offset;
2010
2011 if (!d_bh)
2012 return 0;
2013
2014 desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2015 if (get_desc_trans_len(desc) > 0
2016 && !memcmp(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8)) {
2017 if (oldest_invalid_trans_id && *oldest_invalid_trans_id
2018 && get_desc_trans_id(desc) > *oldest_invalid_trans_id) {
2019 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2020 "journal-986: transaction "
2021 "is valid returning because trans_id %d is greater than "
2022 "oldest_invalid %lu",
2023 get_desc_trans_id(desc),
2024 *oldest_invalid_trans_id);
2025 return 0;
2026 }
2027 if (newest_mount_id
2028 && *newest_mount_id > get_desc_mount_id(desc)) {
2029 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2030 "journal-1087: transaction "
2031 "is valid returning because mount_id %d is less than "
2032 "newest_mount_id %lu",
2033 get_desc_mount_id(desc),
2034 *newest_mount_id);
2035 return -1;
2036 }
2037 if (get_desc_trans_len(desc) > SB_JOURNAL(sb)->j_trans_max) {
2038 reiserfs_warning(sb, "journal-2018",
2039 "Bad transaction length %d "
2040 "encountered, ignoring transaction",
2041 get_desc_trans_len(desc));
2042 return -1;
2043 }
2044 offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2045
2046
2047
2048
2049
2050 c_bh =
2051 journal_bread(sb,
2052 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2053 ((offset + get_desc_trans_len(desc) +
2054 1) % SB_ONDISK_JOURNAL_SIZE(sb)));
2055 if (!c_bh)
2056 return 0;
2057 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2058 if (journal_compare_desc_commit(sb, desc, commit)) {
2059 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2060 "journal_transaction_is_valid, commit offset %ld had bad "
2061 "time %d or length %d",
2062 c_bh->b_blocknr -
2063 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2064 get_commit_trans_id(commit),
2065 get_commit_trans_len(commit));
2066 brelse(c_bh);
2067 if (oldest_invalid_trans_id) {
2068 *oldest_invalid_trans_id =
2069 get_desc_trans_id(desc);
2070 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2071 "journal-1004: "
2072 "transaction_is_valid setting oldest invalid trans_id "
2073 "to %d",
2074 get_desc_trans_id(desc));
2075 }
2076 return -1;
2077 }
2078 brelse(c_bh);
2079 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2080 "journal-1006: found valid "
2081 "transaction start offset %llu, len %d id %d",
2082 d_bh->b_blocknr -
2083 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2084 get_desc_trans_len(desc),
2085 get_desc_trans_id(desc));
2086 return 1;
2087 } else {
2088 return 0;
2089 }
2090}
2091
2092static void brelse_array(struct buffer_head **heads, int num)
2093{
2094 int i;
2095 for (i = 0; i < num; i++) {
2096 brelse(heads[i]);
2097 }
2098}
2099
2100
2101
2102
2103
2104
2105
2106static int journal_read_transaction(struct super_block *sb,
2107 unsigned long cur_dblock,
2108 unsigned long oldest_start,
2109 unsigned int oldest_trans_id,
2110 unsigned long newest_mount_id)
2111{
2112 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2113 struct reiserfs_journal_desc *desc;
2114 struct reiserfs_journal_commit *commit;
2115 unsigned int trans_id = 0;
2116 struct buffer_head *c_bh;
2117 struct buffer_head *d_bh;
2118 struct buffer_head **log_blocks = NULL;
2119 struct buffer_head **real_blocks = NULL;
2120 unsigned int trans_offset;
2121 int i;
2122 int trans_half;
2123
2124 d_bh = journal_bread(sb, cur_dblock);
2125 if (!d_bh)
2126 return 1;
2127 desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2128 trans_offset = d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2129 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1037: "
2130 "journal_read_transaction, offset %llu, len %d mount_id %d",
2131 d_bh->b_blocknr - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2132 get_desc_trans_len(desc), get_desc_mount_id(desc));
2133 if (get_desc_trans_id(desc) < oldest_trans_id) {
2134 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1039: "
2135 "journal_read_trans skipping because %lu is too old",
2136 cur_dblock -
2137 SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2138 brelse(d_bh);
2139 return 1;
2140 }
2141 if (get_desc_mount_id(desc) != newest_mount_id) {
2142 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1146: "
2143 "journal_read_trans skipping because %d is != "
2144 "newest_mount_id %lu", get_desc_mount_id(desc),
2145 newest_mount_id);
2146 brelse(d_bh);
2147 return 1;
2148 }
2149 c_bh = journal_bread(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2150 ((trans_offset + get_desc_trans_len(desc) + 1) %
2151 SB_ONDISK_JOURNAL_SIZE(sb)));
2152 if (!c_bh) {
2153 brelse(d_bh);
2154 return 1;
2155 }
2156 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
2157 if (journal_compare_desc_commit(sb, desc, commit)) {
2158 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2159 "journal_read_transaction, "
2160 "commit offset %llu had bad time %d or length %d",
2161 c_bh->b_blocknr -
2162 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2163 get_commit_trans_id(commit),
2164 get_commit_trans_len(commit));
2165 brelse(c_bh);
2166 brelse(d_bh);
2167 return 1;
2168 }
2169
2170 if (bdev_read_only(sb->s_bdev)) {
2171 reiserfs_warning(sb, "clm-2076",
2172 "device is readonly, unable to replay log");
2173 brelse(c_bh);
2174 brelse(d_bh);
2175 return -EROFS;
2176 }
2177
2178 trans_id = get_desc_trans_id(desc);
2179
2180
2181
2182
2183 log_blocks = kmalloc_array(get_desc_trans_len(desc),
2184 sizeof(struct buffer_head *),
2185 GFP_NOFS);
2186 real_blocks = kmalloc_array(get_desc_trans_len(desc),
2187 sizeof(struct buffer_head *),
2188 GFP_NOFS);
2189 if (!log_blocks || !real_blocks) {
2190 brelse(c_bh);
2191 brelse(d_bh);
2192 kfree(log_blocks);
2193 kfree(real_blocks);
2194 reiserfs_warning(sb, "journal-1169",
2195 "kmalloc failed, unable to mount FS");
2196 return -1;
2197 }
2198
2199 trans_half = journal_trans_half(sb->s_blocksize);
2200 for (i = 0; i < get_desc_trans_len(desc); i++) {
2201 log_blocks[i] =
2202 journal_getblk(sb,
2203 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2204 (trans_offset + 1 +
2205 i) % SB_ONDISK_JOURNAL_SIZE(sb));
2206 if (i < trans_half) {
2207 real_blocks[i] =
2208 sb_getblk(sb,
2209 le32_to_cpu(desc->j_realblock[i]));
2210 } else {
2211 real_blocks[i] =
2212 sb_getblk(sb,
2213 le32_to_cpu(commit->
2214 j_realblock[i - trans_half]));
2215 }
2216 if (real_blocks[i]->b_blocknr > SB_BLOCK_COUNT(sb)) {
2217 reiserfs_warning(sb, "journal-1207",
2218 "REPLAY FAILURE fsck required! "
2219 "Block to replay is outside of "
2220 "filesystem");
2221 goto abort_replay;
2222 }
2223
2224 if (is_block_in_log_or_reserved_area
2225 (sb, real_blocks[i]->b_blocknr)) {
2226 reiserfs_warning(sb, "journal-1204",
2227 "REPLAY FAILURE fsck required! "
2228 "Trying to replay onto a log block");
2229abort_replay:
2230 brelse_array(log_blocks, i);
2231 brelse_array(real_blocks, i);
2232 brelse(c_bh);
2233 brelse(d_bh);
2234 kfree(log_blocks);
2235 kfree(real_blocks);
2236 return -1;
2237 }
2238 }
2239
2240 ll_rw_block(REQ_OP_READ, 0, get_desc_trans_len(desc), log_blocks);
2241 for (i = 0; i < get_desc_trans_len(desc); i++) {
2242
2243 wait_on_buffer(log_blocks[i]);
2244 if (!buffer_uptodate(log_blocks[i])) {
2245 reiserfs_warning(sb, "journal-1212",
2246 "REPLAY FAILURE fsck required! "
2247 "buffer write failed");
2248 brelse_array(log_blocks + i,
2249 get_desc_trans_len(desc) - i);
2250 brelse_array(real_blocks, get_desc_trans_len(desc));
2251 brelse(c_bh);
2252 brelse(d_bh);
2253 kfree(log_blocks);
2254 kfree(real_blocks);
2255 return -1;
2256 }
2257 memcpy(real_blocks[i]->b_data, log_blocks[i]->b_data,
2258 real_blocks[i]->b_size);
2259 set_buffer_uptodate(real_blocks[i]);
2260 brelse(log_blocks[i]);
2261 }
2262
2263 for (i = 0; i < get_desc_trans_len(desc); i++) {
2264 set_buffer_dirty(real_blocks[i]);
2265 write_dirty_buffer(real_blocks[i], 0);
2266 }
2267 for (i = 0; i < get_desc_trans_len(desc); i++) {
2268 wait_on_buffer(real_blocks[i]);
2269 if (!buffer_uptodate(real_blocks[i])) {
2270 reiserfs_warning(sb, "journal-1226",
2271 "REPLAY FAILURE, fsck required! "
2272 "buffer write failed");
2273 brelse_array(real_blocks + i,
2274 get_desc_trans_len(desc) - i);
2275 brelse(c_bh);
2276 brelse(d_bh);
2277 kfree(log_blocks);
2278 kfree(real_blocks);
2279 return -1;
2280 }
2281 brelse(real_blocks[i]);
2282 }
2283 cur_dblock =
2284 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2285 ((trans_offset + get_desc_trans_len(desc) +
2286 2) % SB_ONDISK_JOURNAL_SIZE(sb));
2287 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2288 "journal-1095: setting journal " "start to offset %ld",
2289 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2290
2291
2292
2293
2294
2295 journal->j_start = cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2296 journal->j_last_flush_trans_id = trans_id;
2297 journal->j_trans_id = trans_id + 1;
2298
2299 if (journal->j_trans_id == 0)
2300 journal->j_trans_id = 10;
2301 brelse(c_bh);
2302 brelse(d_bh);
2303 kfree(log_blocks);
2304 kfree(real_blocks);
2305 return 0;
2306}
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316static struct buffer_head *reiserfs_breada(struct block_device *dev,
2317 b_blocknr_t block, int bufsize,
2318 b_blocknr_t max_block)
2319{
2320 struct buffer_head *bhlist[BUFNR];
2321 unsigned int blocks = BUFNR;
2322 struct buffer_head *bh;
2323 int i, j;
2324
2325 bh = __getblk(dev, block, bufsize);
2326 if (buffer_uptodate(bh))
2327 return (bh);
2328
2329 if (block + BUFNR > max_block) {
2330 blocks = max_block - block;
2331 }
2332 bhlist[0] = bh;
2333 j = 1;
2334 for (i = 1; i < blocks; i++) {
2335 bh = __getblk(dev, block + i, bufsize);
2336 if (buffer_uptodate(bh)) {
2337 brelse(bh);
2338 break;
2339 } else
2340 bhlist[j++] = bh;
2341 }
2342 ll_rw_block(REQ_OP_READ, 0, j, bhlist);
2343 for (i = 1; i < j; i++)
2344 brelse(bhlist[i]);
2345 bh = bhlist[0];
2346 wait_on_buffer(bh);
2347 if (buffer_uptodate(bh))
2348 return bh;
2349 brelse(bh);
2350 return NULL;
2351}
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365static int journal_read(struct super_block *sb)
2366{
2367 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2368 struct reiserfs_journal_desc *desc;
2369 unsigned int oldest_trans_id = 0;
2370 unsigned int oldest_invalid_trans_id = 0;
2371 time64_t start;
2372 unsigned long oldest_start = 0;
2373 unsigned long cur_dblock = 0;
2374 unsigned long newest_mount_id = 9;
2375 struct buffer_head *d_bh;
2376 struct reiserfs_journal_header *jh;
2377 int valid_journal_header = 0;
2378 int replay_count = 0;
2379 int continue_replay = 1;
2380 int ret;
2381
2382 cur_dblock = SB_ONDISK_JOURNAL_1st_BLOCK(sb);
2383 reiserfs_info(sb, "checking transaction log (%pg)\n",
2384 journal->j_dev_bd);
2385 start = ktime_get_seconds();
2386
2387
2388
2389
2390
2391
2392 journal->j_header_bh = journal_bread(sb,
2393 SB_ONDISK_JOURNAL_1st_BLOCK(sb)
2394 + SB_ONDISK_JOURNAL_SIZE(sb));
2395 if (!journal->j_header_bh) {
2396 return 1;
2397 }
2398 jh = (struct reiserfs_journal_header *)(journal->j_header_bh->b_data);
2399 if (le32_to_cpu(jh->j_first_unflushed_offset) <
2400 SB_ONDISK_JOURNAL_SIZE(sb)
2401 && le32_to_cpu(jh->j_last_flush_trans_id) > 0) {
2402 oldest_start =
2403 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2404 le32_to_cpu(jh->j_first_unflushed_offset);
2405 oldest_trans_id = le32_to_cpu(jh->j_last_flush_trans_id) + 1;
2406 newest_mount_id = le32_to_cpu(jh->j_mount_id);
2407 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2408 "journal-1153: found in "
2409 "header: first_unflushed_offset %d, last_flushed_trans_id "
2410 "%lu", le32_to_cpu(jh->j_first_unflushed_offset),
2411 le32_to_cpu(jh->j_last_flush_trans_id));
2412 valid_journal_header = 1;
2413
2414
2415
2416
2417
2418
2419 d_bh =
2420 journal_bread(sb,
2421 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2422 le32_to_cpu(jh->j_first_unflushed_offset));
2423 ret = journal_transaction_is_valid(sb, d_bh, NULL, NULL);
2424 if (!ret) {
2425 continue_replay = 0;
2426 }
2427 brelse(d_bh);
2428 goto start_log_replay;
2429 }
2430
2431
2432
2433
2434
2435
2436 while (continue_replay
2437 && cur_dblock <
2438 (SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2439 SB_ONDISK_JOURNAL_SIZE(sb))) {
2440
2441
2442
2443
2444 d_bh =
2445 reiserfs_breada(journal->j_dev_bd, cur_dblock,
2446 sb->s_blocksize,
2447 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2448 SB_ONDISK_JOURNAL_SIZE(sb));
2449 ret =
2450 journal_transaction_is_valid(sb, d_bh,
2451 &oldest_invalid_trans_id,
2452 &newest_mount_id);
2453 if (ret == 1) {
2454 desc = (struct reiserfs_journal_desc *)d_bh->b_data;
2455 if (oldest_start == 0) {
2456 oldest_trans_id = get_desc_trans_id(desc);
2457 oldest_start = d_bh->b_blocknr;
2458 newest_mount_id = get_desc_mount_id(desc);
2459 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2460 "journal-1179: Setting "
2461 "oldest_start to offset %llu, trans_id %lu",
2462 oldest_start -
2463 SB_ONDISK_JOURNAL_1st_BLOCK
2464 (sb), oldest_trans_id);
2465 } else if (oldest_trans_id > get_desc_trans_id(desc)) {
2466
2467 oldest_trans_id = get_desc_trans_id(desc);
2468 oldest_start = d_bh->b_blocknr;
2469 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2470 "journal-1180: Resetting "
2471 "oldest_start to offset %lu, trans_id %lu",
2472 oldest_start -
2473 SB_ONDISK_JOURNAL_1st_BLOCK
2474 (sb), oldest_trans_id);
2475 }
2476 if (newest_mount_id < get_desc_mount_id(desc)) {
2477 newest_mount_id = get_desc_mount_id(desc);
2478 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2479 "journal-1299: Setting "
2480 "newest_mount_id to %d",
2481 get_desc_mount_id(desc));
2482 }
2483 cur_dblock += get_desc_trans_len(desc) + 2;
2484 } else {
2485 cur_dblock++;
2486 }
2487 brelse(d_bh);
2488 }
2489
2490start_log_replay:
2491 cur_dblock = oldest_start;
2492 if (oldest_trans_id) {
2493 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2494 "journal-1206: Starting replay "
2495 "from offset %llu, trans_id %lu",
2496 cur_dblock - SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2497 oldest_trans_id);
2498
2499 }
2500 replay_count = 0;
2501 while (continue_replay && oldest_trans_id > 0) {
2502 ret =
2503 journal_read_transaction(sb, cur_dblock, oldest_start,
2504 oldest_trans_id, newest_mount_id);
2505 if (ret < 0) {
2506 return ret;
2507 } else if (ret != 0) {
2508 break;
2509 }
2510 cur_dblock =
2511 SB_ONDISK_JOURNAL_1st_BLOCK(sb) + journal->j_start;
2512 replay_count++;
2513 if (cur_dblock == oldest_start)
2514 break;
2515 }
2516
2517 if (oldest_trans_id == 0) {
2518 reiserfs_debug(sb, REISERFS_DEBUG_CODE,
2519 "journal-1225: No valid " "transactions found");
2520 }
2521
2522
2523
2524
2525
2526
2527 if (valid_journal_header && replay_count == 0) {
2528 journal->j_start = le32_to_cpu(jh->j_first_unflushed_offset);
2529 journal->j_trans_id =
2530 le32_to_cpu(jh->j_last_flush_trans_id) + 1;
2531
2532 if (journal->j_trans_id == 0)
2533 journal->j_trans_id = 10;
2534 journal->j_last_flush_trans_id =
2535 le32_to_cpu(jh->j_last_flush_trans_id);
2536 journal->j_mount_id = le32_to_cpu(jh->j_mount_id) + 1;
2537 } else {
2538 journal->j_mount_id = newest_mount_id + 1;
2539 }
2540 reiserfs_debug(sb, REISERFS_DEBUG_CODE, "journal-1299: Setting "
2541 "newest_mount_id to %lu", journal->j_mount_id);
2542 journal->j_first_unflushed_offset = journal->j_start;
2543 if (replay_count > 0) {
2544 reiserfs_info(sb,
2545 "replayed %d transactions in %lu seconds\n",
2546 replay_count, ktime_get_seconds() - start);
2547 }
2548
2549 reiserfs_write_lock(sb);
2550 if (!bdev_read_only(sb->s_bdev) &&
2551 _update_journal_header_block(sb, journal->j_start,
2552 journal->j_last_flush_trans_id)) {
2553 reiserfs_write_unlock(sb);
2554
2555
2556
2557
2558 return -1;
2559 }
2560 reiserfs_write_unlock(sb);
2561 return 0;
2562}
2563
2564static struct reiserfs_journal_list *alloc_journal_list(struct super_block *s)
2565{
2566 struct reiserfs_journal_list *jl;
2567 jl = kzalloc(sizeof(struct reiserfs_journal_list),
2568 GFP_NOFS | __GFP_NOFAIL);
2569 INIT_LIST_HEAD(&jl->j_list);
2570 INIT_LIST_HEAD(&jl->j_working_list);
2571 INIT_LIST_HEAD(&jl->j_tail_bh_list);
2572 INIT_LIST_HEAD(&jl->j_bh_list);
2573 mutex_init(&jl->j_commit_mutex);
2574 SB_JOURNAL(s)->j_num_lists++;
2575 get_journal_list(jl);
2576 return jl;
2577}
2578
2579static void journal_list_init(struct super_block *sb)
2580{
2581 SB_JOURNAL(sb)->j_current_jl = alloc_journal_list(sb);
2582}
2583
2584static void release_journal_dev(struct super_block *super,
2585 struct reiserfs_journal *journal)
2586{
2587 if (journal->j_dev_bd != NULL) {
2588 blkdev_put(journal->j_dev_bd, journal->j_dev_mode);
2589 journal->j_dev_bd = NULL;
2590 }
2591}
2592
2593static int journal_init_dev(struct super_block *super,
2594 struct reiserfs_journal *journal,
2595 const char *jdev_name)
2596{
2597 int result;
2598 dev_t jdev;
2599 fmode_t blkdev_mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
2600
2601 result = 0;
2602
2603 journal->j_dev_bd = NULL;
2604 jdev = SB_ONDISK_JOURNAL_DEVICE(super) ?
2605 new_decode_dev(SB_ONDISK_JOURNAL_DEVICE(super)) : super->s_dev;
2606
2607 if (bdev_read_only(super->s_bdev))
2608 blkdev_mode = FMODE_READ;
2609
2610
2611 if ((!jdev_name || !jdev_name[0])) {
2612 if (jdev == super->s_dev)
2613 blkdev_mode &= ~FMODE_EXCL;
2614 journal->j_dev_bd = blkdev_get_by_dev(jdev, blkdev_mode,
2615 journal);
2616 journal->j_dev_mode = blkdev_mode;
2617 if (IS_ERR(journal->j_dev_bd)) {
2618 result = PTR_ERR(journal->j_dev_bd);
2619 journal->j_dev_bd = NULL;
2620 reiserfs_warning(super, "sh-458",
2621 "cannot init journal device unknown-block(%u,%u): %i",
2622 MAJOR(jdev), MINOR(jdev), result);
2623 return result;
2624 } else if (jdev != super->s_dev)
2625 set_blocksize(journal->j_dev_bd, super->s_blocksize);
2626
2627 return 0;
2628 }
2629
2630 journal->j_dev_mode = blkdev_mode;
2631 journal->j_dev_bd = blkdev_get_by_path(jdev_name, blkdev_mode, journal);
2632 if (IS_ERR(journal->j_dev_bd)) {
2633 result = PTR_ERR(journal->j_dev_bd);
2634 journal->j_dev_bd = NULL;
2635 reiserfs_warning(super, "sh-457",
2636 "journal_init_dev: Cannot open '%s': %i",
2637 jdev_name, result);
2638 return result;
2639 }
2640
2641 set_blocksize(journal->j_dev_bd, super->s_blocksize);
2642 reiserfs_info(super,
2643 "journal_init_dev: journal device: %pg\n",
2644 journal->j_dev_bd);
2645 return 0;
2646}
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660#define REISERFS_STANDARD_BLKSIZE (4096)
2661
2662static int check_advise_trans_params(struct super_block *sb,
2663 struct reiserfs_journal *journal)
2664{
2665 if (journal->j_trans_max) {
2666
2667 int ratio = 1;
2668 if (sb->s_blocksize < REISERFS_STANDARD_BLKSIZE)
2669 ratio = REISERFS_STANDARD_BLKSIZE / sb->s_blocksize;
2670
2671 if (journal->j_trans_max > JOURNAL_TRANS_MAX_DEFAULT / ratio ||
2672 journal->j_trans_max < JOURNAL_TRANS_MIN_DEFAULT / ratio ||
2673 SB_ONDISK_JOURNAL_SIZE(sb) / journal->j_trans_max <
2674 JOURNAL_MIN_RATIO) {
2675 reiserfs_warning(sb, "sh-462",
2676 "bad transaction max size (%u). "
2677 "FSCK?", journal->j_trans_max);
2678 return 1;
2679 }
2680 if (journal->j_max_batch != (journal->j_trans_max) *
2681 JOURNAL_MAX_BATCH_DEFAULT/JOURNAL_TRANS_MAX_DEFAULT) {
2682 reiserfs_warning(sb, "sh-463",
2683 "bad transaction max batch (%u). "
2684 "FSCK?", journal->j_max_batch);
2685 return 1;
2686 }
2687 } else {
2688
2689
2690
2691
2692
2693
2694 if (sb->s_blocksize != REISERFS_STANDARD_BLKSIZE) {
2695 reiserfs_warning(sb, "sh-464", "bad blocksize (%u)",
2696 sb->s_blocksize);
2697 return 1;
2698 }
2699 journal->j_trans_max = JOURNAL_TRANS_MAX_DEFAULT;
2700 journal->j_max_batch = JOURNAL_MAX_BATCH_DEFAULT;
2701 journal->j_max_commit_age = JOURNAL_MAX_COMMIT_AGE;
2702 }
2703 return 0;
2704}
2705
2706
2707int journal_init(struct super_block *sb, const char *j_dev_name,
2708 int old_format, unsigned int commit_max_age)
2709{
2710 int num_cnodes = SB_ONDISK_JOURNAL_SIZE(sb) * 2;
2711 struct buffer_head *bhjh;
2712 struct reiserfs_super_block *rs;
2713 struct reiserfs_journal_header *jh;
2714 struct reiserfs_journal *journal;
2715 struct reiserfs_journal_list *jl;
2716 int ret;
2717
2718 journal = SB_JOURNAL(sb) = vzalloc(sizeof(struct reiserfs_journal));
2719 if (!journal) {
2720 reiserfs_warning(sb, "journal-1256",
2721 "unable to get memory for journal structure");
2722 return 1;
2723 }
2724 INIT_LIST_HEAD(&journal->j_bitmap_nodes);
2725 INIT_LIST_HEAD(&journal->j_prealloc_list);
2726 INIT_LIST_HEAD(&journal->j_working_list);
2727 INIT_LIST_HEAD(&journal->j_journal_list);
2728 journal->j_persistent_trans = 0;
2729 if (reiserfs_allocate_list_bitmaps(sb, journal->j_list_bitmap,
2730 reiserfs_bmap_count(sb)))
2731 goto free_and_return;
2732
2733 allocate_bitmap_nodes(sb);
2734
2735
2736 SB_JOURNAL_1st_RESERVED_BLOCK(sb) = (old_format ?
2737 REISERFS_OLD_DISK_OFFSET_IN_BYTES
2738 / sb->s_blocksize +
2739 reiserfs_bmap_count(sb) +
2740 1 :
2741 REISERFS_DISK_OFFSET_IN_BYTES /
2742 sb->s_blocksize + 2);
2743
2744
2745
2746
2747
2748 if (!SB_ONDISK_JOURNAL_DEVICE(sb) &&
2749 (SB_JOURNAL_1st_RESERVED_BLOCK(sb) +
2750 SB_ONDISK_JOURNAL_SIZE(sb) > sb->s_blocksize * 8)) {
2751 reiserfs_warning(sb, "journal-1393",
2752 "journal does not fit for area addressed "
2753 "by first of bitmap blocks. It starts at "
2754 "%u and its size is %u. Block size %ld",
2755 SB_JOURNAL_1st_RESERVED_BLOCK(sb),
2756 SB_ONDISK_JOURNAL_SIZE(sb),
2757 sb->s_blocksize);
2758 goto free_and_return;
2759 }
2760
2761
2762
2763
2764
2765
2766 if (!SB_ONDISK_JOURNAL_DEVICE(sb) &&
2767 SB_ONDISK_JOURNAL_1st_BLOCK(sb) < SB_JOURNAL_1st_RESERVED_BLOCK(sb)) {
2768 reiserfs_warning(sb, "journal-1393",
2769 "journal 1st super block is invalid: 1st reserved block %d, but actual 1st block is %d",
2770 SB_JOURNAL_1st_RESERVED_BLOCK(sb),
2771 SB_ONDISK_JOURNAL_1st_BLOCK(sb));
2772 goto free_and_return;
2773 }
2774
2775 if (journal_init_dev(sb, journal, j_dev_name) != 0) {
2776 reiserfs_warning(sb, "sh-462",
2777 "unable to initialize journal device");
2778 goto free_and_return;
2779 }
2780
2781 rs = SB_DISK_SUPER_BLOCK(sb);
2782
2783
2784 bhjh = journal_bread(sb,
2785 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
2786 SB_ONDISK_JOURNAL_SIZE(sb));
2787 if (!bhjh) {
2788 reiserfs_warning(sb, "sh-459",
2789 "unable to read journal header");
2790 goto free_and_return;
2791 }
2792 jh = (struct reiserfs_journal_header *)(bhjh->b_data);
2793
2794
2795 if (is_reiserfs_jr(rs)
2796 && (le32_to_cpu(jh->jh_journal.jp_journal_magic) !=
2797 sb_jp_journal_magic(rs))) {
2798 reiserfs_warning(sb, "sh-460",
2799 "journal header magic %x (device %pg) does "
2800 "not match to magic found in super block %x",
2801 jh->jh_journal.jp_journal_magic,
2802 journal->j_dev_bd,
2803 sb_jp_journal_magic(rs));
2804 brelse(bhjh);
2805 goto free_and_return;
2806 }
2807
2808 journal->j_trans_max = le32_to_cpu(jh->jh_journal.jp_journal_trans_max);
2809 journal->j_max_batch = le32_to_cpu(jh->jh_journal.jp_journal_max_batch);
2810 journal->j_max_commit_age =
2811 le32_to_cpu(jh->jh_journal.jp_journal_max_commit_age);
2812 journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
2813
2814 if (check_advise_trans_params(sb, journal) != 0)
2815 goto free_and_return;
2816 journal->j_default_max_commit_age = journal->j_max_commit_age;
2817
2818 if (commit_max_age != 0) {
2819 journal->j_max_commit_age = commit_max_age;
2820 journal->j_max_trans_age = commit_max_age;
2821 }
2822
2823 reiserfs_info(sb, "journal params: device %pg, size %u, "
2824 "journal first block %u, max trans len %u, max batch %u, "
2825 "max commit age %u, max trans age %u\n",
2826 journal->j_dev_bd,
2827 SB_ONDISK_JOURNAL_SIZE(sb),
2828 SB_ONDISK_JOURNAL_1st_BLOCK(sb),
2829 journal->j_trans_max,
2830 journal->j_max_batch,
2831 journal->j_max_commit_age, journal->j_max_trans_age);
2832
2833 brelse(bhjh);
2834
2835 journal->j_list_bitmap_index = 0;
2836 journal_list_init(sb);
2837
2838 memset(journal->j_list_hash_table, 0,
2839 JOURNAL_HASH_SIZE * sizeof(struct reiserfs_journal_cnode *));
2840
2841 INIT_LIST_HEAD(&journal->j_dirty_buffers);
2842 spin_lock_init(&journal->j_dirty_buffers_lock);
2843
2844 journal->j_start = 0;
2845 journal->j_len = 0;
2846 journal->j_len_alloc = 0;
2847 atomic_set(&journal->j_wcount, 0);
2848 atomic_set(&journal->j_async_throttle, 0);
2849 journal->j_bcount = 0;
2850 journal->j_trans_start_time = 0;
2851 journal->j_last = NULL;
2852 journal->j_first = NULL;
2853 init_waitqueue_head(&journal->j_join_wait);
2854 mutex_init(&journal->j_mutex);
2855 mutex_init(&journal->j_flush_mutex);
2856
2857 journal->j_trans_id = 10;
2858 journal->j_mount_id = 10;
2859 journal->j_state = 0;
2860 atomic_set(&journal->j_jlock, 0);
2861 journal->j_cnode_free_list = allocate_cnodes(num_cnodes);
2862 journal->j_cnode_free_orig = journal->j_cnode_free_list;
2863 journal->j_cnode_free = journal->j_cnode_free_list ? num_cnodes : 0;
2864 journal->j_cnode_used = 0;
2865 journal->j_must_wait = 0;
2866
2867 if (journal->j_cnode_free == 0) {
2868 reiserfs_warning(sb, "journal-2004", "Journal cnode memory "
2869 "allocation failed (%ld bytes). Journal is "
2870 "too large for available memory. Usually "
2871 "this is due to a journal that is too large.",
2872 sizeof (struct reiserfs_journal_cnode) * num_cnodes);
2873 goto free_and_return;
2874 }
2875
2876 init_journal_hash(sb);
2877 jl = journal->j_current_jl;
2878
2879
2880
2881
2882
2883
2884 reiserfs_write_lock(sb);
2885 jl->j_list_bitmap = get_list_bitmap(sb, jl);
2886 reiserfs_write_unlock(sb);
2887 if (!jl->j_list_bitmap) {
2888 reiserfs_warning(sb, "journal-2005",
2889 "get_list_bitmap failed for journal list 0");
2890 goto free_and_return;
2891 }
2892
2893 ret = journal_read(sb);
2894 if (ret < 0) {
2895 reiserfs_warning(sb, "reiserfs-2006",
2896 "Replay Failure, unable to mount");
2897 goto free_and_return;
2898 }
2899
2900 INIT_DELAYED_WORK(&journal->j_work, flush_async_commits);
2901 journal->j_work_sb = sb;
2902 return 0;
2903free_and_return:
2904 free_journal_ram(sb);
2905 return 1;
2906}
2907
2908
2909
2910
2911
2912
2913int journal_transaction_should_end(struct reiserfs_transaction_handle *th,
2914 int new_alloc)
2915{
2916 struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
2917 time64_t now = ktime_get_seconds();
2918
2919 BUG_ON(!th->t_trans_id);
2920 if (th->t_refcount > 1)
2921 return 0;
2922 if (journal->j_must_wait > 0 ||
2923 (journal->j_len_alloc + new_alloc) >= journal->j_max_batch ||
2924 atomic_read(&journal->j_jlock) ||
2925 (now - journal->j_trans_start_time) > journal->j_max_trans_age ||
2926 journal->j_cnode_free < (journal->j_trans_max * 3)) {
2927 return 1;
2928 }
2929
2930 journal->j_len_alloc += new_alloc;
2931 th->t_blocks_allocated += new_alloc ;
2932 return 0;
2933}
2934
2935
2936void reiserfs_block_writes(struct reiserfs_transaction_handle *th)
2937{
2938 struct reiserfs_journal *journal = SB_JOURNAL(th->t_super);
2939 BUG_ON(!th->t_trans_id);
2940 journal->j_must_wait = 1;
2941 set_bit(J_WRITERS_BLOCKED, &journal->j_state);
2942 return;
2943}
2944
2945
2946void reiserfs_allow_writes(struct super_block *s)
2947{
2948 struct reiserfs_journal *journal = SB_JOURNAL(s);
2949 clear_bit(J_WRITERS_BLOCKED, &journal->j_state);
2950 wake_up(&journal->j_join_wait);
2951}
2952
2953
2954void reiserfs_wait_on_write_block(struct super_block *s)
2955{
2956 struct reiserfs_journal *journal = SB_JOURNAL(s);
2957 wait_event(journal->j_join_wait,
2958 !test_bit(J_WRITERS_BLOCKED, &journal->j_state));
2959}
2960
2961static void queue_log_writer(struct super_block *s)
2962{
2963 wait_queue_entry_t wait;
2964 struct reiserfs_journal *journal = SB_JOURNAL(s);
2965 set_bit(J_WRITERS_QUEUED, &journal->j_state);
2966
2967
2968
2969
2970
2971 init_waitqueue_entry(&wait, current);
2972 add_wait_queue(&journal->j_join_wait, &wait);
2973 set_current_state(TASK_UNINTERRUPTIBLE);
2974 if (test_bit(J_WRITERS_QUEUED, &journal->j_state)) {
2975 int depth = reiserfs_write_unlock_nested(s);
2976 schedule();
2977 reiserfs_write_lock_nested(s, depth);
2978 }
2979 __set_current_state(TASK_RUNNING);
2980 remove_wait_queue(&journal->j_join_wait, &wait);
2981}
2982
2983static void wake_queued_writers(struct super_block *s)
2984{
2985 struct reiserfs_journal *journal = SB_JOURNAL(s);
2986 if (test_and_clear_bit(J_WRITERS_QUEUED, &journal->j_state))
2987 wake_up(&journal->j_join_wait);
2988}
2989
2990static void let_transaction_grow(struct super_block *sb, unsigned int trans_id)
2991{
2992 struct reiserfs_journal *journal = SB_JOURNAL(sb);
2993 unsigned long bcount = journal->j_bcount;
2994 while (1) {
2995 int depth;
2996
2997 depth = reiserfs_write_unlock_nested(sb);
2998 schedule_timeout_uninterruptible(1);
2999 reiserfs_write_lock_nested(sb, depth);
3000
3001 journal->j_current_jl->j_state |= LIST_COMMIT_PENDING;
3002 while ((atomic_read(&journal->j_wcount) > 0 ||
3003 atomic_read(&journal->j_jlock)) &&
3004 journal->j_trans_id == trans_id) {
3005 queue_log_writer(sb);
3006 }
3007 if (journal->j_trans_id != trans_id)
3008 break;
3009 if (bcount == journal->j_bcount)
3010 break;
3011 bcount = journal->j_bcount;
3012 }
3013}
3014
3015
3016
3017
3018
3019
3020
3021
3022static int do_journal_begin_r(struct reiserfs_transaction_handle *th,
3023 struct super_block *sb, unsigned long nblocks,
3024 int join)
3025{
3026 time64_t now = ktime_get_seconds();
3027 unsigned int old_trans_id;
3028 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3029 struct reiserfs_transaction_handle myth;
3030 int sched_count = 0;
3031 int retval;
3032 int depth;
3033
3034 reiserfs_check_lock_depth(sb, "journal_begin");
3035 BUG_ON(nblocks > journal->j_trans_max);
3036
3037 PROC_INFO_INC(sb, journal.journal_being);
3038
3039 th->t_refcount = 1;
3040 th->t_super = sb;
3041
3042relock:
3043 lock_journal(sb);
3044 if (join != JBEGIN_ABORT && reiserfs_is_journal_aborted(journal)) {
3045 unlock_journal(sb);
3046 retval = journal->j_errno;
3047 goto out_fail;
3048 }
3049 journal->j_bcount++;
3050
3051 if (test_bit(J_WRITERS_BLOCKED, &journal->j_state)) {
3052 unlock_journal(sb);
3053 depth = reiserfs_write_unlock_nested(sb);
3054 reiserfs_wait_on_write_block(sb);
3055 reiserfs_write_lock_nested(sb, depth);
3056 PROC_INFO_INC(sb, journal.journal_relock_writers);
3057 goto relock;
3058 }
3059 now = ktime_get_seconds();
3060
3061
3062
3063
3064
3065
3066
3067
3068 if ((!join && journal->j_must_wait > 0) ||
3069 (!join
3070 && (journal->j_len_alloc + nblocks + 2) >= journal->j_max_batch)
3071 || (!join && atomic_read(&journal->j_wcount) > 0
3072 && journal->j_trans_start_time > 0
3073 && (now - journal->j_trans_start_time) >
3074 journal->j_max_trans_age) || (!join
3075 && atomic_read(&journal->j_jlock))
3076 || (!join && journal->j_cnode_free < (journal->j_trans_max * 3))) {
3077
3078 old_trans_id = journal->j_trans_id;
3079
3080 unlock_journal(sb);
3081
3082 if (!join && (journal->j_len_alloc + nblocks + 2) >=
3083 journal->j_max_batch &&
3084 ((journal->j_len + nblocks + 2) * 100) <
3085 (journal->j_len_alloc * 75)) {
3086 if (atomic_read(&journal->j_wcount) > 10) {
3087 sched_count++;
3088 queue_log_writer(sb);
3089 goto relock;
3090 }
3091 }
3092
3093
3094
3095
3096 if (atomic_read(&journal->j_jlock)) {
3097 while (journal->j_trans_id == old_trans_id &&
3098 atomic_read(&journal->j_jlock)) {
3099 queue_log_writer(sb);
3100 }
3101 goto relock;
3102 }
3103 retval = journal_join(&myth, sb);
3104 if (retval)
3105 goto out_fail;
3106
3107
3108 if (old_trans_id != journal->j_trans_id) {
3109 retval = do_journal_end(&myth, 0);
3110 } else {
3111 retval = do_journal_end(&myth, COMMIT_NOW);
3112 }
3113
3114 if (retval)
3115 goto out_fail;
3116
3117 PROC_INFO_INC(sb, journal.journal_relock_wcount);
3118 goto relock;
3119 }
3120
3121 if (journal->j_trans_start_time == 0) {
3122 journal->j_trans_start_time = ktime_get_seconds();
3123 }
3124 atomic_inc(&journal->j_wcount);
3125 journal->j_len_alloc += nblocks;
3126 th->t_blocks_logged = 0;
3127 th->t_blocks_allocated = nblocks;
3128 th->t_trans_id = journal->j_trans_id;
3129 unlock_journal(sb);
3130 INIT_LIST_HEAD(&th->t_list);
3131 return 0;
3132
3133out_fail:
3134 memset(th, 0, sizeof(*th));
3135
3136
3137
3138
3139
3140 th->t_super = sb;
3141 return retval;
3142}
3143
3144struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
3145 super_block
3146 *s,
3147 int nblocks)
3148{
3149 int ret;
3150 struct reiserfs_transaction_handle *th;
3151
3152
3153
3154
3155
3156 if (reiserfs_transaction_running(s)) {
3157 th = current->journal_info;
3158 th->t_refcount++;
3159 BUG_ON(th->t_refcount < 2);
3160
3161 return th;
3162 }
3163 th = kmalloc(sizeof(struct reiserfs_transaction_handle), GFP_NOFS);
3164 if (!th)
3165 return NULL;
3166 ret = journal_begin(th, s, nblocks);
3167 if (ret) {
3168 kfree(th);
3169 return NULL;
3170 }
3171
3172 SB_JOURNAL(s)->j_persistent_trans++;
3173 return th;
3174}
3175
3176int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *th)
3177{
3178 struct super_block *s = th->t_super;
3179 int ret = 0;
3180 if (th->t_trans_id)
3181 ret = journal_end(th);
3182 else
3183 ret = -EIO;
3184 if (th->t_refcount == 0) {
3185 SB_JOURNAL(s)->j_persistent_trans--;
3186 kfree(th);
3187 }
3188 return ret;
3189}
3190
3191static int journal_join(struct reiserfs_transaction_handle *th,
3192 struct super_block *sb)
3193{
3194 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3195
3196
3197
3198
3199
3200 th->t_handle_save = cur_th;
3201 BUG_ON(cur_th && cur_th->t_refcount > 1);
3202 return do_journal_begin_r(th, sb, 1, JBEGIN_JOIN);
3203}
3204
3205int journal_join_abort(struct reiserfs_transaction_handle *th,
3206 struct super_block *sb)
3207{
3208 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3209
3210
3211
3212
3213
3214 th->t_handle_save = cur_th;
3215 BUG_ON(cur_th && cur_th->t_refcount > 1);
3216 return do_journal_begin_r(th, sb, 1, JBEGIN_ABORT);
3217}
3218
3219int journal_begin(struct reiserfs_transaction_handle *th,
3220 struct super_block *sb, unsigned long nblocks)
3221{
3222 struct reiserfs_transaction_handle *cur_th = current->journal_info;
3223 int ret;
3224
3225 th->t_handle_save = NULL;
3226 if (cur_th) {
3227
3228 if (cur_th->t_super == sb) {
3229 BUG_ON(!cur_th->t_refcount);
3230 cur_th->t_refcount++;
3231 memcpy(th, cur_th, sizeof(*th));
3232 if (th->t_refcount <= 1)
3233 reiserfs_warning(sb, "reiserfs-2005",
3234 "BAD: refcount <= 1, but "
3235 "journal_info != 0");
3236 return 0;
3237 } else {
3238
3239
3240
3241
3242
3243 reiserfs_warning(sb, "clm-2100",
3244 "nesting info a different FS");
3245 th->t_handle_save = current->journal_info;
3246 current->journal_info = th;
3247 }
3248 } else {
3249 current->journal_info = th;
3250 }
3251 ret = do_journal_begin_r(th, sb, nblocks, JBEGIN_REG);
3252 BUG_ON(current->journal_info != th);
3253
3254
3255
3256
3257
3258 if (ret)
3259 current->journal_info = th->t_handle_save;
3260 else
3261 BUG_ON(!th->t_refcount);
3262
3263 return ret;
3264}
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276int journal_mark_dirty(struct reiserfs_transaction_handle *th,
3277 struct buffer_head *bh)
3278{
3279 struct super_block *sb = th->t_super;
3280 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3281 struct reiserfs_journal_cnode *cn = NULL;
3282 int count_already_incd = 0;
3283 int prepared = 0;
3284 BUG_ON(!th->t_trans_id);
3285
3286 PROC_INFO_INC(sb, journal.mark_dirty);
3287 if (th->t_trans_id != journal->j_trans_id) {
3288 reiserfs_panic(th->t_super, "journal-1577",
3289 "handle trans id %ld != current trans id %ld",
3290 th->t_trans_id, journal->j_trans_id);
3291 }
3292
3293 prepared = test_clear_buffer_journal_prepared(bh);
3294 clear_buffer_journal_restore_dirty(bh);
3295
3296 if (buffer_journaled(bh)) {
3297 PROC_INFO_INC(sb, journal.mark_dirty_already);
3298 return 0;
3299 }
3300
3301
3302
3303
3304
3305
3306 if (!prepared || buffer_dirty(bh)) {
3307 reiserfs_warning(sb, "journal-1777",
3308 "buffer %llu bad state "
3309 "%cPREPARED %cLOCKED %cDIRTY %cJDIRTY_WAIT",
3310 (unsigned long long)bh->b_blocknr,
3311 prepared ? ' ' : '!',
3312 buffer_locked(bh) ? ' ' : '!',
3313 buffer_dirty(bh) ? ' ' : '!',
3314 buffer_journal_dirty(bh) ? ' ' : '!');
3315 }
3316
3317 if (atomic_read(&journal->j_wcount) <= 0) {
3318 reiserfs_warning(sb, "journal-1409",
3319 "returning because j_wcount was %d",
3320 atomic_read(&journal->j_wcount));
3321 return 1;
3322 }
3323
3324
3325
3326
3327
3328 if (journal->j_len >= journal->j_trans_max) {
3329 reiserfs_panic(th->t_super, "journal-1413",
3330 "j_len (%lu) is too big",
3331 journal->j_len);
3332 }
3333
3334 if (buffer_journal_dirty(bh)) {
3335 count_already_incd = 1;
3336 PROC_INFO_INC(sb, journal.mark_dirty_notjournal);
3337 clear_buffer_journal_dirty(bh);
3338 }
3339
3340 if (journal->j_len > journal->j_len_alloc) {
3341 journal->j_len_alloc = journal->j_len + JOURNAL_PER_BALANCE_CNT;
3342 }
3343
3344 set_buffer_journaled(bh);
3345
3346
3347 if (!cn) {
3348 cn = get_cnode(sb);
3349 if (!cn) {
3350 reiserfs_panic(sb, "journal-4", "get_cnode failed!");
3351 }
3352
3353 if (th->t_blocks_logged == th->t_blocks_allocated) {
3354 th->t_blocks_allocated += JOURNAL_PER_BALANCE_CNT;
3355 journal->j_len_alloc += JOURNAL_PER_BALANCE_CNT;
3356 }
3357 th->t_blocks_logged++;
3358 journal->j_len++;
3359
3360 cn->bh = bh;
3361 cn->blocknr = bh->b_blocknr;
3362 cn->sb = sb;
3363 cn->jlist = NULL;
3364 insert_journal_hash(journal->j_hash_table, cn);
3365 if (!count_already_incd) {
3366 get_bh(bh);
3367 }
3368 }
3369 cn->next = NULL;
3370 cn->prev = journal->j_last;
3371 cn->bh = bh;
3372 if (journal->j_last) {
3373 journal->j_last->next = cn;
3374 journal->j_last = cn;
3375 } else {
3376 journal->j_first = cn;
3377 journal->j_last = cn;
3378 }
3379 reiserfs_schedule_old_flush(sb);
3380 return 0;
3381}
3382
3383int journal_end(struct reiserfs_transaction_handle *th)
3384{
3385 struct super_block *sb = th->t_super;
3386 if (!current->journal_info && th->t_refcount > 1)
3387 reiserfs_warning(sb, "REISER-NESTING",
3388 "th NULL, refcount %d", th->t_refcount);
3389
3390 if (!th->t_trans_id) {
3391 WARN_ON(1);
3392 return -EIO;
3393 }
3394
3395 th->t_refcount--;
3396 if (th->t_refcount > 0) {
3397 struct reiserfs_transaction_handle *cur_th =
3398 current->journal_info;
3399
3400
3401
3402
3403
3404 BUG_ON(cur_th->t_super != th->t_super);
3405
3406 if (th != cur_th) {
3407 memcpy(current->journal_info, th, sizeof(*th));
3408 th->t_trans_id = 0;
3409 }
3410 return 0;
3411 } else {
3412 return do_journal_end(th, 0);
3413 }
3414}
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424static int remove_from_transaction(struct super_block *sb,
3425 b_blocknr_t blocknr, int already_cleaned)
3426{
3427 struct buffer_head *bh;
3428 struct reiserfs_journal_cnode *cn;
3429 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3430 int ret = 0;
3431
3432 cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3433 if (!cn || !cn->bh) {
3434 return ret;
3435 }
3436 bh = cn->bh;
3437 if (cn->prev) {
3438 cn->prev->next = cn->next;
3439 }
3440 if (cn->next) {
3441 cn->next->prev = cn->prev;
3442 }
3443 if (cn == journal->j_first) {
3444 journal->j_first = cn->next;
3445 }
3446 if (cn == journal->j_last) {
3447 journal->j_last = cn->prev;
3448 }
3449 remove_journal_hash(sb, journal->j_hash_table, NULL,
3450 bh->b_blocknr, 0);
3451 clear_buffer_journaled(bh);
3452
3453 if (!already_cleaned) {
3454 clear_buffer_journal_dirty(bh);
3455 clear_buffer_dirty(bh);
3456 clear_buffer_journal_test(bh);
3457 put_bh(bh);
3458 if (atomic_read(&bh->b_count) < 0) {
3459 reiserfs_warning(sb, "journal-1752",
3460 "b_count < 0");
3461 }
3462 ret = 1;
3463 }
3464 journal->j_len--;
3465 journal->j_len_alloc--;
3466 free_cnode(sb, cn);
3467 return ret;
3468}
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481static int can_dirty(struct reiserfs_journal_cnode *cn)
3482{
3483 struct super_block *sb = cn->sb;
3484 b_blocknr_t blocknr = cn->blocknr;
3485 struct reiserfs_journal_cnode *cur = cn->hprev;
3486 int can_dirty = 1;
3487
3488
3489
3490
3491
3492
3493 while (cur && can_dirty) {
3494 if (cur->jlist && cur->bh && cur->blocknr && cur->sb == sb &&
3495 cur->blocknr == blocknr) {
3496 can_dirty = 0;
3497 }
3498 cur = cur->hprev;
3499 }
3500
3501
3502
3503
3504 cur = cn->hnext;
3505 while (cur && can_dirty) {
3506 if (cur->jlist && cur->jlist->j_len > 0 &&
3507 atomic_read(&cur->jlist->j_commit_left) > 0 && cur->bh &&
3508 cur->blocknr && cur->sb == sb && cur->blocknr == blocknr) {
3509 can_dirty = 0;
3510 }
3511 cur = cur->hnext;
3512 }
3513 return can_dirty;
3514}
3515
3516
3517
3518
3519
3520int journal_end_sync(struct reiserfs_transaction_handle *th)
3521{
3522 struct super_block *sb = th->t_super;
3523 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3524
3525 BUG_ON(!th->t_trans_id);
3526
3527 BUG_ON(th->t_refcount > 1);
3528 if (journal->j_len == 0) {
3529 reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3530 1);
3531 journal_mark_dirty(th, SB_BUFFER_WITH_SB(sb));
3532 }
3533 return do_journal_end(th, COMMIT_NOW | WAIT);
3534}
3535
3536
3537static void flush_async_commits(struct work_struct *work)
3538{
3539 struct reiserfs_journal *journal =
3540 container_of(work, struct reiserfs_journal, j_work.work);
3541 struct super_block *sb = journal->j_work_sb;
3542 struct reiserfs_journal_list *jl;
3543 struct list_head *entry;
3544
3545 reiserfs_write_lock(sb);
3546 if (!list_empty(&journal->j_journal_list)) {
3547
3548 entry = journal->j_journal_list.prev;
3549 jl = JOURNAL_LIST_ENTRY(entry);
3550 flush_commit_list(sb, jl, 1);
3551 }
3552 reiserfs_write_unlock(sb);
3553}
3554
3555
3556
3557
3558
3559void reiserfs_flush_old_commits(struct super_block *sb)
3560{
3561 time64_t now;
3562 struct reiserfs_transaction_handle th;
3563 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3564
3565 now = ktime_get_seconds();
3566
3567
3568
3569
3570 if (list_empty(&journal->j_journal_list))
3571 return;
3572
3573
3574
3575
3576
3577 if (atomic_read(&journal->j_wcount) <= 0 &&
3578 journal->j_trans_start_time > 0 &&
3579 journal->j_len > 0 &&
3580 (now - journal->j_trans_start_time) > journal->j_max_trans_age) {
3581 if (!journal_join(&th, sb)) {
3582 reiserfs_prepare_for_journal(sb,
3583 SB_BUFFER_WITH_SB(sb),
3584 1);
3585 journal_mark_dirty(&th, SB_BUFFER_WITH_SB(sb));
3586
3587
3588
3589
3590
3591
3592 do_journal_end(&th, COMMIT_NOW | WAIT);
3593 }
3594 }
3595}
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612static int check_journal_end(struct reiserfs_transaction_handle *th, int flags)
3613{
3614
3615 time64_t now;
3616 int flush = flags & FLUSH_ALL;
3617 int commit_now = flags & COMMIT_NOW;
3618 int wait_on_commit = flags & WAIT;
3619 struct reiserfs_journal_list *jl;
3620 struct super_block *sb = th->t_super;
3621 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3622
3623 BUG_ON(!th->t_trans_id);
3624
3625 if (th->t_trans_id != journal->j_trans_id) {
3626 reiserfs_panic(th->t_super, "journal-1577",
3627 "handle trans id %ld != current trans id %ld",
3628 th->t_trans_id, journal->j_trans_id);
3629 }
3630
3631 journal->j_len_alloc -= (th->t_blocks_allocated - th->t_blocks_logged);
3632
3633 if (atomic_read(&journal->j_wcount) > 0)
3634 atomic_dec(&journal->j_wcount);
3635
3636
3637
3638
3639
3640
3641
3642 BUG_ON(journal->j_len == 0);
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652 if (atomic_read(&journal->j_wcount) > 0) {
3653 if (flush || commit_now) {
3654 unsigned trans_id;
3655
3656 jl = journal->j_current_jl;
3657 trans_id = jl->j_trans_id;
3658 if (wait_on_commit)
3659 jl->j_state |= LIST_COMMIT_PENDING;
3660 atomic_set(&journal->j_jlock, 1);
3661 if (flush) {
3662 journal->j_next_full_flush = 1;
3663 }
3664 unlock_journal(sb);
3665
3666
3667
3668
3669
3670 while (journal->j_trans_id == trans_id) {
3671 if (atomic_read(&journal->j_jlock)) {
3672 queue_log_writer(sb);
3673 } else {
3674 lock_journal(sb);
3675 if (journal->j_trans_id == trans_id) {
3676 atomic_set(&journal->j_jlock,
3677 1);
3678 }
3679 unlock_journal(sb);
3680 }
3681 }
3682 BUG_ON(journal->j_trans_id == trans_id);
3683
3684 if (commit_now
3685 && journal_list_still_alive(sb, trans_id)
3686 && wait_on_commit) {
3687 flush_commit_list(sb, jl, 1);
3688 }
3689 return 0;
3690 }
3691 unlock_journal(sb);
3692 return 0;
3693 }
3694
3695
3696 now = ktime_get_seconds();
3697 if ((now - journal->j_trans_start_time) > journal->j_max_trans_age) {
3698 commit_now = 1;
3699 journal->j_next_async_flush = 1;
3700 }
3701
3702
3703 if (!(journal->j_must_wait > 0) && !(atomic_read(&journal->j_jlock))
3704 && !flush && !commit_now && (journal->j_len < journal->j_max_batch)
3705 && journal->j_len_alloc < journal->j_max_batch
3706 && journal->j_cnode_free > (journal->j_trans_max * 3)) {
3707 journal->j_bcount++;
3708 unlock_journal(sb);
3709 return 0;
3710 }
3711
3712 if (journal->j_start > SB_ONDISK_JOURNAL_SIZE(sb)) {
3713 reiserfs_panic(sb, "journal-003",
3714 "j_start (%ld) is too high",
3715 journal->j_start);
3716 }
3717 return 1;
3718}
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737int journal_mark_freed(struct reiserfs_transaction_handle *th,
3738 struct super_block *sb, b_blocknr_t blocknr)
3739{
3740 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3741 struct reiserfs_journal_cnode *cn = NULL;
3742 struct buffer_head *bh = NULL;
3743 struct reiserfs_list_bitmap *jb = NULL;
3744 int cleaned = 0;
3745 BUG_ON(!th->t_trans_id);
3746
3747 cn = get_journal_hash_dev(sb, journal->j_hash_table, blocknr);
3748 if (cn && cn->bh) {
3749 bh = cn->bh;
3750 get_bh(bh);
3751 }
3752
3753 if (bh && buffer_journal_new(bh)) {
3754 clear_buffer_journal_new(bh);
3755 clear_prepared_bits(bh);
3756 reiserfs_clean_and_file_buffer(bh);
3757 cleaned = remove_from_transaction(sb, blocknr, cleaned);
3758 } else {
3759
3760
3761
3762
3763 jb = journal->j_current_jl->j_list_bitmap;
3764 if (!jb) {
3765 reiserfs_panic(sb, "journal-1702",
3766 "journal_list_bitmap is NULL");
3767 }
3768 set_bit_in_list_bitmap(sb, blocknr, jb);
3769
3770
3771
3772 if (bh) {
3773 clear_prepared_bits(bh);
3774 reiserfs_clean_and_file_buffer(bh);
3775 }
3776 cleaned = remove_from_transaction(sb, blocknr, cleaned);
3777
3778
3779
3780
3781
3782 cn = get_journal_hash_dev(sb, journal->j_list_hash_table,
3783 blocknr);
3784 while (cn) {
3785 if (sb == cn->sb && blocknr == cn->blocknr) {
3786 set_bit(BLOCK_FREED, &cn->state);
3787 if (cn->bh) {
3788
3789
3790
3791
3792
3793 if (!cleaned) {
3794 clear_buffer_journal_dirty(cn->
3795 bh);
3796 clear_buffer_dirty(cn->bh);
3797 clear_buffer_journal_test(cn->
3798 bh);
3799 cleaned = 1;
3800 put_bh(cn->bh);
3801 if (atomic_read
3802 (&cn->bh->b_count) < 0) {
3803 reiserfs_warning(sb,
3804 "journal-2138",
3805 "cn->bh->b_count < 0");
3806 }
3807 }
3808
3809
3810
3811
3812 if (cn->jlist) {
3813 atomic_dec(&cn->jlist->
3814 j_nonzerolen);
3815 }
3816 cn->bh = NULL;
3817 }
3818 }
3819 cn = cn->hnext;
3820 }
3821 }
3822
3823 if (bh)
3824 release_buffer_page(bh);
3825 return 0;
3826}
3827
3828void reiserfs_update_inode_transaction(struct inode *inode)
3829{
3830 struct reiserfs_journal *journal = SB_JOURNAL(inode->i_sb);
3831 REISERFS_I(inode)->i_jl = journal->j_current_jl;
3832 REISERFS_I(inode)->i_trans_id = journal->j_trans_id;
3833}
3834
3835
3836
3837
3838
3839static int __commit_trans_jl(struct inode *inode, unsigned long id,
3840 struct reiserfs_journal_list *jl)
3841{
3842 struct reiserfs_transaction_handle th;
3843 struct super_block *sb = inode->i_sb;
3844 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3845 int ret = 0;
3846
3847
3848
3849
3850
3851 if (id == journal->j_trans_id) {
3852 jl = journal->j_current_jl;
3853
3854
3855
3856
3857 let_transaction_grow(sb, id);
3858 if (journal->j_trans_id != id) {
3859 goto flush_commit_only;
3860 }
3861
3862 ret = journal_begin(&th, sb, 1);
3863 if (ret)
3864 return ret;
3865
3866
3867 if (journal->j_trans_id != id) {
3868 reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
3869 1);
3870 journal_mark_dirty(&th, SB_BUFFER_WITH_SB(sb));
3871 ret = journal_end(&th);
3872 goto flush_commit_only;
3873 }
3874
3875 ret = journal_end_sync(&th);
3876 if (!ret)
3877 ret = 1;
3878
3879 } else {
3880
3881
3882
3883
3884
3885flush_commit_only:
3886 if (journal_list_still_alive(inode->i_sb, id)) {
3887
3888
3889
3890
3891
3892 if (atomic_read(&jl->j_commit_left) > 1)
3893 ret = 1;
3894 flush_commit_list(sb, jl, 1);
3895 if (journal->j_errno)
3896 ret = journal->j_errno;
3897 }
3898 }
3899
3900 return ret;
3901}
3902
3903int reiserfs_commit_for_inode(struct inode *inode)
3904{
3905 unsigned int id = REISERFS_I(inode)->i_trans_id;
3906 struct reiserfs_journal_list *jl = REISERFS_I(inode)->i_jl;
3907
3908
3909
3910
3911
3912 if (!id || !jl) {
3913 reiserfs_update_inode_transaction(inode);
3914 id = REISERFS_I(inode)->i_trans_id;
3915
3916 }
3917
3918 return __commit_trans_jl(inode, id, jl);
3919}
3920
3921void reiserfs_restore_prepared_buffer(struct super_block *sb,
3922 struct buffer_head *bh)
3923{
3924 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3925 PROC_INFO_INC(sb, journal.restore_prepared);
3926 if (!bh) {
3927 return;
3928 }
3929 if (test_clear_buffer_journal_restore_dirty(bh) &&
3930 buffer_journal_dirty(bh)) {
3931 struct reiserfs_journal_cnode *cn;
3932 reiserfs_write_lock(sb);
3933 cn = get_journal_hash_dev(sb,
3934 journal->j_list_hash_table,
3935 bh->b_blocknr);
3936 if (cn && can_dirty(cn)) {
3937 set_buffer_journal_test(bh);
3938 mark_buffer_dirty(bh);
3939 }
3940 reiserfs_write_unlock(sb);
3941 }
3942 clear_buffer_journal_prepared(bh);
3943}
3944
3945extern struct tree_balance *cur_tb;
3946
3947
3948
3949
3950
3951
3952int reiserfs_prepare_for_journal(struct super_block *sb,
3953 struct buffer_head *bh, int wait)
3954{
3955 PROC_INFO_INC(sb, journal.prepare);
3956
3957 if (!trylock_buffer(bh)) {
3958 if (!wait)
3959 return 0;
3960 lock_buffer(bh);
3961 }
3962 set_buffer_journal_prepared(bh);
3963 if (test_clear_buffer_dirty(bh) && buffer_journal_dirty(bh)) {
3964 clear_buffer_journal_test(bh);
3965 set_buffer_journal_restore_dirty(bh);
3966 }
3967 unlock_buffer(bh);
3968 return 1;
3969}
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981static int do_journal_end(struct reiserfs_transaction_handle *th, int flags)
3982{
3983 struct super_block *sb = th->t_super;
3984 struct reiserfs_journal *journal = SB_JOURNAL(sb);
3985 struct reiserfs_journal_cnode *cn, *next, *jl_cn;
3986 struct reiserfs_journal_cnode *last_cn = NULL;
3987 struct reiserfs_journal_desc *desc;
3988 struct reiserfs_journal_commit *commit;
3989 struct buffer_head *c_bh;
3990 struct buffer_head *d_bh;
3991 int cur_write_start = 0;
3992 int i;
3993 int flush;
3994 int wait_on_commit;
3995 struct reiserfs_journal_list *jl, *temp_jl;
3996 struct list_head *entry, *safe;
3997 unsigned long jindex;
3998 unsigned int commit_trans_id;
3999 int trans_half;
4000 int depth;
4001
4002 BUG_ON(th->t_refcount > 1);
4003 BUG_ON(!th->t_trans_id);
4004 BUG_ON(!th->t_super);
4005
4006
4007
4008
4009
4010 if (th->t_trans_id == ~0U)
4011 flags |= FLUSH_ALL | COMMIT_NOW | WAIT;
4012 flush = flags & FLUSH_ALL;
4013 wait_on_commit = flags & WAIT;
4014
4015 current->journal_info = th->t_handle_save;
4016 reiserfs_check_lock_depth(sb, "journal end");
4017 if (journal->j_len == 0) {
4018 reiserfs_prepare_for_journal(sb, SB_BUFFER_WITH_SB(sb),
4019 1);
4020 journal_mark_dirty(th, SB_BUFFER_WITH_SB(sb));
4021 }
4022
4023 lock_journal(sb);
4024 if (journal->j_next_full_flush) {
4025 flags |= FLUSH_ALL;
4026 flush = 1;
4027 }
4028 if (journal->j_next_async_flush) {
4029 flags |= COMMIT_NOW | WAIT;
4030 wait_on_commit = 1;
4031 }
4032
4033
4034
4035
4036
4037
4038 if (!check_journal_end(th, flags)) {
4039 reiserfs_schedule_old_flush(sb);
4040 wake_queued_writers(sb);
4041 reiserfs_async_progress_wait(sb);
4042 goto out;
4043 }
4044
4045
4046 if (journal->j_next_full_flush) {
4047 flush = 1;
4048 }
4049
4050
4051
4052
4053
4054 if (journal->j_must_wait > 0) {
4055 flush = 1;
4056 }
4057#ifdef REISERFS_PREALLOCATE
4058
4059
4060
4061
4062 current->journal_info = th;
4063 th->t_refcount++;
4064
4065
4066 reiserfs_discard_all_prealloc(th);
4067
4068 th->t_refcount--;
4069 current->journal_info = th->t_handle_save;
4070#endif
4071
4072
4073 d_bh =
4074 journal_getblk(sb,
4075 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4076 journal->j_start);
4077 set_buffer_uptodate(d_bh);
4078 desc = (struct reiserfs_journal_desc *)(d_bh)->b_data;
4079 memset(d_bh->b_data, 0, d_bh->b_size);
4080 memcpy(get_journal_desc_magic(d_bh), JOURNAL_DESC_MAGIC, 8);
4081 set_desc_trans_id(desc, journal->j_trans_id);
4082
4083
4084
4085
4086
4087 c_bh = journal_getblk(sb, SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4088 ((journal->j_start + journal->j_len +
4089 1) % SB_ONDISK_JOURNAL_SIZE(sb)));
4090 commit = (struct reiserfs_journal_commit *)c_bh->b_data;
4091 memset(c_bh->b_data, 0, c_bh->b_size);
4092 set_commit_trans_id(commit, journal->j_trans_id);
4093 set_buffer_uptodate(c_bh);
4094
4095
4096 jl = journal->j_current_jl;
4097
4098
4099
4100
4101
4102
4103
4104 reiserfs_mutex_lock_safe(&jl->j_commit_mutex, sb);
4105
4106
4107 commit_trans_id = jl->j_trans_id;
4108
4109 atomic_set(&jl->j_older_commits_done, 0);
4110 jl->j_trans_id = journal->j_trans_id;
4111 jl->j_timestamp = journal->j_trans_start_time;
4112 jl->j_commit_bh = c_bh;
4113 jl->j_start = journal->j_start;
4114 jl->j_len = journal->j_len;
4115 atomic_set(&jl->j_nonzerolen, journal->j_len);
4116 atomic_set(&jl->j_commit_left, journal->j_len + 2);
4117 jl->j_realblock = NULL;
4118
4119
4120
4121
4122
4123
4124 trans_half = journal_trans_half(sb->s_blocksize);
4125 for (i = 0, cn = journal->j_first; cn; cn = cn->next, i++) {
4126 if (buffer_journaled(cn->bh)) {
4127 jl_cn = get_cnode(sb);
4128 if (!jl_cn) {
4129 reiserfs_panic(sb, "journal-1676",
4130 "get_cnode returned NULL");
4131 }
4132 if (i == 0) {
4133 jl->j_realblock = jl_cn;
4134 }
4135 jl_cn->prev = last_cn;
4136 jl_cn->next = NULL;
4137 if (last_cn) {
4138 last_cn->next = jl_cn;
4139 }
4140 last_cn = jl_cn;
4141
4142
4143
4144
4145 if (is_block_in_log_or_reserved_area
4146 (sb, cn->bh->b_blocknr)) {
4147 reiserfs_panic(sb, "journal-2332",
4148 "Trying to log block %lu, "
4149 "which is a log block",
4150 cn->bh->b_blocknr);
4151 }
4152 jl_cn->blocknr = cn->bh->b_blocknr;
4153 jl_cn->state = 0;
4154 jl_cn->sb = sb;
4155 jl_cn->bh = cn->bh;
4156 jl_cn->jlist = jl;
4157 insert_journal_hash(journal->j_list_hash_table, jl_cn);
4158 if (i < trans_half) {
4159 desc->j_realblock[i] =
4160 cpu_to_le32(cn->bh->b_blocknr);
4161 } else {
4162 commit->j_realblock[i - trans_half] =
4163 cpu_to_le32(cn->bh->b_blocknr);
4164 }
4165 } else {
4166 i--;
4167 }
4168 }
4169 set_desc_trans_len(desc, journal->j_len);
4170 set_desc_mount_id(desc, journal->j_mount_id);
4171 set_desc_trans_id(desc, journal->j_trans_id);
4172 set_commit_trans_len(commit, journal->j_len);
4173
4174
4175
4176
4177
4178 BUG_ON(journal->j_len == 0);
4179
4180
4181
4182
4183
4184
4185 mark_buffer_dirty(d_bh);
4186
4187
4188
4189
4190
4191 cur_write_start = journal->j_start;
4192 cn = journal->j_first;
4193 jindex = 1;
4194 while (cn) {
4195 clear_buffer_journal_new(cn->bh);
4196
4197 if (buffer_journaled(cn->bh)) {
4198 struct buffer_head *tmp_bh;
4199 char *addr;
4200 struct page *page;
4201 tmp_bh =
4202 journal_getblk(sb,
4203 SB_ONDISK_JOURNAL_1st_BLOCK(sb) +
4204 ((cur_write_start +
4205 jindex) %
4206 SB_ONDISK_JOURNAL_SIZE(sb)));
4207 set_buffer_uptodate(tmp_bh);
4208 page = cn->bh->b_page;
4209 addr = kmap(page);
4210 memcpy(tmp_bh->b_data,
4211 addr + offset_in_page(cn->bh->b_data),
4212 cn->bh->b_size);
4213 kunmap(page);
4214 mark_buffer_dirty(tmp_bh);
4215 jindex++;
4216 set_buffer_journal_dirty(cn->bh);
4217 clear_buffer_journaled(cn->bh);
4218 } else {
4219
4220
4221
4222
4223 reiserfs_warning(sb, "journal-2048",
4224 "BAD, buffer in journal hash, "
4225 "but not JDirty!");
4226 brelse(cn->bh);
4227 }
4228 next = cn->next;
4229 free_cnode(sb, cn);
4230 cn = next;
4231 reiserfs_cond_resched(sb);
4232 }
4233
4234
4235
4236
4237
4238
4239
4240 journal->j_current_jl = alloc_journal_list(sb);
4241
4242
4243 list_add_tail(&jl->j_list, &journal->j_journal_list);
4244 list_add_tail(&jl->j_working_list, &journal->j_working_list);
4245 journal->j_num_work_lists++;
4246
4247
4248 journal->j_start =
4249 (journal->j_start + journal->j_len +
4250 2) % SB_ONDISK_JOURNAL_SIZE(sb);
4251 atomic_set(&journal->j_wcount, 0);
4252 journal->j_bcount = 0;
4253 journal->j_last = NULL;
4254 journal->j_first = NULL;
4255 journal->j_len = 0;
4256 journal->j_trans_start_time = 0;
4257
4258 if (++journal->j_trans_id == 0)
4259 journal->j_trans_id = 10;
4260 journal->j_current_jl->j_trans_id = journal->j_trans_id;
4261 journal->j_must_wait = 0;
4262 journal->j_len_alloc = 0;
4263 journal->j_next_full_flush = 0;
4264 journal->j_next_async_flush = 0;
4265 init_journal_hash(sb);
4266
4267
4268
4269
4270
4271 smp_mb();
4272
4273
4274
4275
4276
4277
4278
4279
4280 if (!list_empty(&jl->j_tail_bh_list)) {
4281 depth = reiserfs_write_unlock_nested(sb);
4282 write_ordered_buffers(&journal->j_dirty_buffers_lock,
4283 journal, jl, &jl->j_tail_bh_list);
4284 reiserfs_write_lock_nested(sb, depth);
4285 }
4286 BUG_ON(!list_empty(&jl->j_tail_bh_list));
4287 mutex_unlock(&jl->j_commit_mutex);
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297 if (flush) {
4298 flush_commit_list(sb, jl, 1);
4299 flush_journal_list(sb, jl, 1);
4300 } else if (!(jl->j_state & LIST_COMMIT_PENDING)) {
4301
4302
4303
4304
4305 if (sb->s_flags & SB_ACTIVE)
4306 queue_delayed_work(REISERFS_SB(sb)->commit_wq,
4307 &journal->j_work, HZ / 10);
4308 }
4309
4310
4311
4312
4313
4314
4315first_jl:
4316 list_for_each_safe(entry, safe, &journal->j_journal_list) {
4317 temp_jl = JOURNAL_LIST_ENTRY(entry);
4318 if (journal->j_start <= temp_jl->j_start) {
4319 if ((journal->j_start + journal->j_trans_max + 1) >=
4320 temp_jl->j_start) {
4321 flush_used_journal_lists(sb, temp_jl);
4322 goto first_jl;
4323 } else if ((journal->j_start +
4324 journal->j_trans_max + 1) <
4325 SB_ONDISK_JOURNAL_SIZE(sb)) {
4326
4327
4328
4329
4330
4331
4332 break;
4333 }
4334 } else if ((journal->j_start +
4335 journal->j_trans_max + 1) >
4336 SB_ONDISK_JOURNAL_SIZE(sb)) {
4337 if (((journal->j_start + journal->j_trans_max + 1) %
4338 SB_ONDISK_JOURNAL_SIZE(sb)) >=
4339 temp_jl->j_start) {
4340 flush_used_journal_lists(sb, temp_jl);
4341 goto first_jl;
4342 } else {
4343
4344
4345
4346
4347
4348
4349 break;
4350 }
4351 }
4352 }
4353
4354 journal->j_current_jl->j_list_bitmap =
4355 get_list_bitmap(sb, journal->j_current_jl);
4356
4357 if (!(journal->j_current_jl->j_list_bitmap)) {
4358 reiserfs_panic(sb, "journal-1996",
4359 "could not get a list bitmap");
4360 }
4361
4362 atomic_set(&journal->j_jlock, 0);
4363 unlock_journal(sb);
4364
4365 clear_bit(J_WRITERS_QUEUED, &journal->j_state);
4366 wake_up(&journal->j_join_wait);
4367
4368 if (!flush && wait_on_commit &&
4369 journal_list_still_alive(sb, commit_trans_id)) {
4370 flush_commit_list(sb, jl, 1);
4371 }
4372out:
4373 reiserfs_check_lock_depth(sb, "journal end2");
4374
4375 memset(th, 0, sizeof(*th));
4376
4377
4378
4379
4380
4381 th->t_super = sb;
4382
4383 return journal->j_errno;
4384}
4385
4386
4387void reiserfs_abort_journal(struct super_block *sb, int errno)
4388{
4389 struct reiserfs_journal *journal = SB_JOURNAL(sb);
4390 if (test_bit(J_ABORTED, &journal->j_state))
4391 return;
4392
4393 if (!journal->j_errno)
4394 journal->j_errno = errno;
4395
4396 sb->s_flags |= SB_RDONLY;
4397 set_bit(J_ABORTED, &journal->j_state);
4398
4399#ifdef CONFIG_REISERFS_CHECK
4400 dump_stack();
4401#endif
4402}
4403