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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83#ifndef __KERNEL__
84#include "jfs_user.h"
85#else
86#include <linux/time.h>
87#include <linux/fs.h>
88#include <linux/jbd2.h>
89#include <linux/errno.h>
90#include <linux/slab.h>
91#include <linux/list.h>
92#include <linux/init.h>
93#include <linux/bio.h>
94#endif
95#include <linux/log2.h>
96
97static struct kmem_cache *jbd2_revoke_record_cache;
98static struct kmem_cache *jbd2_revoke_table_cache;
99
100
101
102
103
104struct jbd2_revoke_record_s
105{
106 struct list_head hash;
107 tid_t sequence;
108 unsigned long long blocknr;
109};
110
111
112
113struct jbd2_revoke_table_s
114{
115
116
117 int hash_size;
118 int hash_shift;
119 struct list_head *hash_table;
120};
121
122
123#ifdef __KERNEL__
124static void write_one_revoke_record(journal_t *, transaction_t *,
125 struct journal_head **, int *,
126 struct jbd2_revoke_record_s *, int);
127static void flush_descriptor(journal_t *, struct journal_head *, int, int);
128#endif
129
130
131
132
133static inline int hash(journal_t *journal, unsigned long long block)
134{
135 struct jbd2_revoke_table_s *table = journal->j_revoke;
136 int hash_shift = table->hash_shift;
137 int hash = (int)block ^ (int)((block >> 31) >> 1);
138
139 return ((hash << (hash_shift - 6)) ^
140 (hash >> 13) ^
141 (hash << (hash_shift - 12))) & (table->hash_size - 1);
142}
143
144static int insert_revoke_hash(journal_t *journal, unsigned long long blocknr,
145 tid_t seq)
146{
147 struct list_head *hash_list;
148 struct jbd2_revoke_record_s *record;
149
150repeat:
151 record = kmem_cache_alloc(jbd2_revoke_record_cache, GFP_NOFS);
152 if (!record)
153 goto oom;
154
155 record->sequence = seq;
156 record->blocknr = blocknr;
157 hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
158 spin_lock(&journal->j_revoke_lock);
159 list_add(&record->hash, hash_list);
160 spin_unlock(&journal->j_revoke_lock);
161 return 0;
162
163oom:
164 if (!journal_oom_retry)
165 return -ENOMEM;
166 jbd_debug(1, "ENOMEM in %s, retrying\n", __func__);
167 yield();
168 goto repeat;
169}
170
171
172
173static struct jbd2_revoke_record_s *find_revoke_record(journal_t *journal,
174 unsigned long long blocknr)
175{
176 struct list_head *hash_list;
177 struct jbd2_revoke_record_s *record;
178
179 hash_list = &journal->j_revoke->hash_table[hash(journal, blocknr)];
180
181 spin_lock(&journal->j_revoke_lock);
182 record = (struct jbd2_revoke_record_s *) hash_list->next;
183 while (&(record->hash) != hash_list) {
184 if (record->blocknr == blocknr) {
185 spin_unlock(&journal->j_revoke_lock);
186 return record;
187 }
188 record = (struct jbd2_revoke_record_s *) record->hash.next;
189 }
190 spin_unlock(&journal->j_revoke_lock);
191 return NULL;
192}
193
194void jbd2_journal_destroy_revoke_caches(void)
195{
196 if (jbd2_revoke_record_cache) {
197 kmem_cache_destroy(jbd2_revoke_record_cache);
198 jbd2_revoke_record_cache = NULL;
199 }
200 if (jbd2_revoke_table_cache) {
201 kmem_cache_destroy(jbd2_revoke_table_cache);
202 jbd2_revoke_table_cache = NULL;
203 }
204}
205
206int __init jbd2_journal_init_revoke_caches(void)
207{
208 J_ASSERT(!jbd2_revoke_record_cache);
209 J_ASSERT(!jbd2_revoke_table_cache);
210
211 jbd2_revoke_record_cache = KMEM_CACHE(jbd2_revoke_record_s,
212 SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY);
213 if (!jbd2_revoke_record_cache)
214 goto record_cache_failure;
215
216 jbd2_revoke_table_cache = KMEM_CACHE(jbd2_revoke_table_s,
217 SLAB_TEMPORARY);
218 if (!jbd2_revoke_table_cache)
219 goto table_cache_failure;
220 return 0;
221table_cache_failure:
222 jbd2_journal_destroy_revoke_caches();
223record_cache_failure:
224 return -ENOMEM;
225}
226
227static struct jbd2_revoke_table_s *jbd2_journal_init_revoke_table(int hash_size)
228{
229 int shift = 0;
230 int tmp = hash_size;
231 struct jbd2_revoke_table_s *table;
232
233 table = kmem_cache_alloc(jbd2_revoke_table_cache, GFP_KERNEL);
234 if (!table)
235 goto out;
236
237 while((tmp >>= 1UL) != 0UL)
238 shift++;
239
240 table->hash_size = hash_size;
241 table->hash_shift = shift;
242 table->hash_table =
243 kmalloc(hash_size * sizeof(struct list_head), GFP_KERNEL);
244 if (!table->hash_table) {
245 kmem_cache_free(jbd2_revoke_table_cache, table);
246 table = NULL;
247 goto out;
248 }
249
250 for (tmp = 0; tmp < hash_size; tmp++)
251 INIT_LIST_HEAD(&table->hash_table[tmp]);
252
253out:
254 return table;
255}
256
257static void jbd2_journal_destroy_revoke_table(struct jbd2_revoke_table_s *table)
258{
259 int i;
260 struct list_head *hash_list;
261
262 for (i = 0; i < table->hash_size; i++) {
263 hash_list = &table->hash_table[i];
264 J_ASSERT(list_empty(hash_list));
265 }
266
267 kfree(table->hash_table);
268 kmem_cache_free(jbd2_revoke_table_cache, table);
269}
270
271
272int jbd2_journal_init_revoke(journal_t *journal, int hash_size)
273{
274 J_ASSERT(journal->j_revoke_table[0] == NULL);
275 J_ASSERT(is_power_of_2(hash_size));
276
277 journal->j_revoke_table[0] = jbd2_journal_init_revoke_table(hash_size);
278 if (!journal->j_revoke_table[0])
279 goto fail0;
280
281 journal->j_revoke_table[1] = jbd2_journal_init_revoke_table(hash_size);
282 if (!journal->j_revoke_table[1])
283 goto fail1;
284
285 journal->j_revoke = journal->j_revoke_table[1];
286
287 spin_lock_init(&journal->j_revoke_lock);
288
289 return 0;
290
291fail1:
292 jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);
293fail0:
294 return -ENOMEM;
295}
296
297
298void jbd2_journal_destroy_revoke(journal_t *journal)
299{
300 journal->j_revoke = NULL;
301 if (journal->j_revoke_table[0])
302 jbd2_journal_destroy_revoke_table(journal->j_revoke_table[0]);
303 if (journal->j_revoke_table[1])
304 jbd2_journal_destroy_revoke_table(journal->j_revoke_table[1]);
305}
306
307
308#ifdef __KERNEL__
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334int jbd2_journal_revoke(handle_t *handle, unsigned long long blocknr,
335 struct buffer_head *bh_in)
336{
337 struct buffer_head *bh = NULL;
338 journal_t *journal;
339 struct block_device *bdev;
340 int err;
341
342 might_sleep();
343 if (bh_in)
344 BUFFER_TRACE(bh_in, "enter");
345
346 journal = handle->h_transaction->t_journal;
347 if (!jbd2_journal_set_features(journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)){
348 J_ASSERT (!"Cannot set revoke feature!");
349 return -EINVAL;
350 }
351
352 bdev = journal->j_fs_dev;
353 bh = bh_in;
354
355 if (!bh) {
356 bh = __find_get_block(bdev, blocknr, journal->j_blocksize);
357 if (bh)
358 BUFFER_TRACE(bh, "found on hash");
359 }
360#ifdef JBD2_EXPENSIVE_CHECKING
361 else {
362 struct buffer_head *bh2;
363
364
365
366 bh2 = __find_get_block(bdev, blocknr, journal->j_blocksize);
367 if (bh2) {
368
369 if (bh2 != bh && buffer_revokevalid(bh2))
370
371
372
373
374
375
376 J_ASSERT_BH(bh2, buffer_revoked(bh2));
377 put_bh(bh2);
378 }
379 }
380#endif
381
382
383
384
385 if (bh) {
386 if (!J_EXPECT_BH(bh, !buffer_revoked(bh),
387 "inconsistent data on disk")) {
388 if (!bh_in)
389 brelse(bh);
390 return -EIO;
391 }
392 set_buffer_revoked(bh);
393 set_buffer_revokevalid(bh);
394 if (bh_in) {
395 BUFFER_TRACE(bh_in, "call jbd2_journal_forget");
396 jbd2_journal_forget(handle, bh_in);
397 } else {
398 BUFFER_TRACE(bh, "call brelse");
399 __brelse(bh);
400 }
401 }
402
403 jbd_debug(2, "insert revoke for block %llu, bh_in=%p\n",blocknr, bh_in);
404 err = insert_revoke_hash(journal, blocknr,
405 handle->h_transaction->t_tid);
406 BUFFER_TRACE(bh_in, "exit");
407 return err;
408}
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
426{
427 struct jbd2_revoke_record_s *record;
428 journal_t *journal = handle->h_transaction->t_journal;
429 int need_cancel;
430 int did_revoke = 0;
431 struct buffer_head *bh = jh2bh(jh);
432
433 jbd_debug(4, "journal_head %p, cancelling revoke\n", jh);
434
435
436
437
438
439 if (test_set_buffer_revokevalid(bh)) {
440 need_cancel = test_clear_buffer_revoked(bh);
441 } else {
442 need_cancel = 1;
443 clear_buffer_revoked(bh);
444 }
445
446 if (need_cancel) {
447 record = find_revoke_record(journal, bh->b_blocknr);
448 if (record) {
449 jbd_debug(4, "cancelled existing revoke on "
450 "blocknr %llu\n", (unsigned long long)bh->b_blocknr);
451 spin_lock(&journal->j_revoke_lock);
452 list_del(&record->hash);
453 spin_unlock(&journal->j_revoke_lock);
454 kmem_cache_free(jbd2_revoke_record_cache, record);
455 did_revoke = 1;
456 }
457 }
458
459#ifdef JBD2_EXPENSIVE_CHECKING
460
461 record = find_revoke_record(journal, bh->b_blocknr);
462 J_ASSERT_JH(jh, record == NULL);
463#endif
464
465
466
467
468
469 if (need_cancel) {
470 struct buffer_head *bh2;
471 bh2 = __find_get_block(bh->b_bdev, bh->b_blocknr, bh->b_size);
472 if (bh2) {
473 if (bh2 != bh)
474 clear_buffer_revoked(bh2);
475 __brelse(bh2);
476 }
477 }
478 return did_revoke;
479}
480
481
482
483
484
485
486void jbd2_clear_buffer_revoked_flags(journal_t *journal)
487{
488 struct jbd2_revoke_table_s *revoke = journal->j_revoke;
489 int i = 0;
490
491 for (i = 0; i < revoke->hash_size; i++) {
492 struct list_head *hash_list;
493 struct list_head *list_entry;
494 hash_list = &revoke->hash_table[i];
495
496 list_for_each(list_entry, hash_list) {
497 struct jbd2_revoke_record_s *record;
498 struct buffer_head *bh;
499 record = (struct jbd2_revoke_record_s *)list_entry;
500 bh = __find_get_block(journal->j_fs_dev,
501 record->blocknr,
502 journal->j_blocksize);
503 if (bh) {
504 clear_buffer_revoked(bh);
505 __brelse(bh);
506 }
507 }
508 }
509}
510
511
512
513
514
515void jbd2_journal_switch_revoke_table(journal_t *journal)
516{
517 int i;
518
519 if (journal->j_revoke == journal->j_revoke_table[0])
520 journal->j_revoke = journal->j_revoke_table[1];
521 else
522 journal->j_revoke = journal->j_revoke_table[0];
523
524 for (i = 0; i < journal->j_revoke->hash_size; i++)
525 INIT_LIST_HEAD(&journal->j_revoke->hash_table[i]);
526}
527
528
529
530
531
532void jbd2_journal_write_revoke_records(journal_t *journal,
533 transaction_t *transaction,
534 int write_op)
535{
536 struct journal_head *descriptor;
537 struct jbd2_revoke_record_s *record;
538 struct jbd2_revoke_table_s *revoke;
539 struct list_head *hash_list;
540 int i, offset, count;
541
542 descriptor = NULL;
543 offset = 0;
544 count = 0;
545
546
547 revoke = journal->j_revoke == journal->j_revoke_table[0] ?
548 journal->j_revoke_table[1] : journal->j_revoke_table[0];
549
550 for (i = 0; i < revoke->hash_size; i++) {
551 hash_list = &revoke->hash_table[i];
552
553 while (!list_empty(hash_list)) {
554 record = (struct jbd2_revoke_record_s *)
555 hash_list->next;
556 write_one_revoke_record(journal, transaction,
557 &descriptor, &offset,
558 record, write_op);
559 count++;
560 list_del(&record->hash);
561 kmem_cache_free(jbd2_revoke_record_cache, record);
562 }
563 }
564 if (descriptor)
565 flush_descriptor(journal, descriptor, offset, write_op);
566 jbd_debug(1, "Wrote %d revoke records\n", count);
567}
568
569
570
571
572
573
574static void write_one_revoke_record(journal_t *journal,
575 transaction_t *transaction,
576 struct journal_head **descriptorp,
577 int *offsetp,
578 struct jbd2_revoke_record_s *record,
579 int write_op)
580{
581 int csum_size = 0;
582 struct journal_head *descriptor;
583 int offset;
584 journal_header_t *header;
585
586
587
588
589
590 if (is_journal_aborted(journal))
591 return;
592
593 descriptor = *descriptorp;
594 offset = *offsetp;
595
596
597 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_CSUM_V2))
598 csum_size = sizeof(struct jbd2_journal_revoke_tail);
599
600
601 if (descriptor) {
602 if (offset >= journal->j_blocksize - csum_size) {
603 flush_descriptor(journal, descriptor, offset, write_op);
604 descriptor = NULL;
605 }
606 }
607
608 if (!descriptor) {
609 descriptor = jbd2_journal_get_descriptor_buffer(journal);
610 if (!descriptor)
611 return;
612 header = (journal_header_t *) &jh2bh(descriptor)->b_data[0];
613 header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
614 header->h_blocktype = cpu_to_be32(JBD2_REVOKE_BLOCK);
615 header->h_sequence = cpu_to_be32(transaction->t_tid);
616
617
618 JBUFFER_TRACE(descriptor, "file as BJ_LogCtl");
619 jbd2_journal_file_buffer(descriptor, transaction, BJ_LogCtl);
620
621 offset = sizeof(jbd2_journal_revoke_header_t);
622 *descriptorp = descriptor;
623 }
624
625 if (JBD2_HAS_INCOMPAT_FEATURE(journal, JBD2_FEATURE_INCOMPAT_64BIT)) {
626 * ((__be64 *)(&jh2bh(descriptor)->b_data[offset])) =
627 cpu_to_be64(record->blocknr);
628 offset += 8;
629
630 } else {
631 * ((__be32 *)(&jh2bh(descriptor)->b_data[offset])) =
632 cpu_to_be32(record->blocknr);
633 offset += 4;
634 }
635
636 *offsetp = offset;
637}
638
639static void jbd2_revoke_csum_set(journal_t *j,
640 struct journal_head *descriptor)
641{
642 struct jbd2_journal_revoke_tail *tail;
643 __u32 csum;
644
645 if (!JBD2_HAS_INCOMPAT_FEATURE(j, JBD2_FEATURE_INCOMPAT_CSUM_V2))
646 return;
647
648 tail = (struct jbd2_journal_revoke_tail *)
649 (jh2bh(descriptor)->b_data + j->j_blocksize -
650 sizeof(struct jbd2_journal_revoke_tail));
651 tail->r_checksum = 0;
652 csum = jbd2_chksum(j, j->j_csum_seed, jh2bh(descriptor)->b_data,
653 j->j_blocksize);
654 tail->r_checksum = cpu_to_be32(csum);
655}
656
657
658
659
660
661
662
663
664static void flush_descriptor(journal_t *journal,
665 struct journal_head *descriptor,
666 int offset, int write_op)
667{
668 jbd2_journal_revoke_header_t *header;
669 struct buffer_head *bh = jh2bh(descriptor);
670
671 if (is_journal_aborted(journal)) {
672 put_bh(bh);
673 return;
674 }
675
676 header = (jbd2_journal_revoke_header_t *) jh2bh(descriptor)->b_data;
677 header->r_count = cpu_to_be32(offset);
678 jbd2_revoke_csum_set(journal, descriptor);
679
680 set_buffer_jwrite(bh);
681 BUFFER_TRACE(bh, "write");
682 set_buffer_dirty(bh);
683 write_dirty_buffer(bh, write_op);
684}
685#endif
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709int jbd2_journal_set_revoke(journal_t *journal,
710 unsigned long long blocknr,
711 tid_t sequence)
712{
713 struct jbd2_revoke_record_s *record;
714
715 record = find_revoke_record(journal, blocknr);
716 if (record) {
717
718
719 if (tid_gt(sequence, record->sequence))
720 record->sequence = sequence;
721 return 0;
722 }
723 return insert_revoke_hash(journal, blocknr, sequence);
724}
725
726
727
728
729
730
731
732
733int jbd2_journal_test_revoke(journal_t *journal,
734 unsigned long long blocknr,
735 tid_t sequence)
736{
737 struct jbd2_revoke_record_s *record;
738
739 record = find_revoke_record(journal, blocknr);
740 if (!record)
741 return 0;
742 if (tid_gt(sequence, record->sequence))
743 return 0;
744 return 1;
745}
746
747
748
749
750
751
752void jbd2_journal_clear_revoke(journal_t *journal)
753{
754 int i;
755 struct list_head *hash_list;
756 struct jbd2_revoke_record_s *record;
757 struct jbd2_revoke_table_s *revoke;
758
759 revoke = journal->j_revoke;
760
761 for (i = 0; i < revoke->hash_size; i++) {
762 hash_list = &revoke->hash_table[i];
763 while (!list_empty(hash_list)) {
764 record = (struct jbd2_revoke_record_s*) hash_list->next;
765 list_del(&record->hash);
766 kmem_cache_free(jbd2_revoke_record_cache, record);
767 }
768 }
769}
770