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