1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#ifndef _LINUX_JBD2_H
17#define _LINUX_JBD2_H
18
19
20#ifndef __KERNEL__
21#include "jfs_compat.h"
22#define JBD2_DEBUG
23#define jfs_debug jbd_debug
24#else
25
26#include <linux/types.h>
27#include <linux/buffer_head.h>
28#include <linux/journal-head.h>
29#include <linux/stddef.h>
30#include <linux/bit_spinlock.h>
31#include <linux/mutex.h>
32#include <linux/timer.h>
33#include <linux/slab.h>
34#include <crypto/hash.h>
35#endif
36
37#define journal_oom_retry 1
38
39
40
41
42
43
44
45
46#undef JBD2_PARANOID_IOFAIL
47
48
49
50
51#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
52
53#ifdef CONFIG_JBD2_DEBUG
54
55
56
57
58
59#define JBD2_EXPENSIVE_CHECKING
60extern u8 jbd2_journal_enable_debug;
61
62#define jbd_debug(n, f, a...) \
63 do { \
64 if ((n) <= jbd2_journal_enable_debug) { \
65 printk (KERN_DEBUG "(%s, %d): %s: ", \
66 __FILE__, __LINE__, __func__); \
67 printk (f, ## a); \
68 } \
69 } while (0)
70#else
71#define jbd_debug(f, a...)
72#endif
73
74extern void *jbd2_alloc(size_t size, gfp_t flags);
75extern void jbd2_free(void *ptr, size_t size);
76
77#define JBD2_MIN_JOURNAL_BLOCKS 1024
78
79#ifdef __KERNEL__
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98typedef struct jbd2_journal_handle handle_t;
99
100
101
102
103
104
105
106
107
108
109
110
111
112typedef struct journal_s journal_t;
113#endif
114
115
116
117
118
119#define JBD2_MAGIC_NUMBER 0xc03b3998U
120
121
122
123
124
125
126
127
128
129#define JBD2_DESCRIPTOR_BLOCK 1
130#define JBD2_COMMIT_BLOCK 2
131#define JBD2_SUPERBLOCK_V1 3
132#define JBD2_SUPERBLOCK_V2 4
133#define JBD2_REVOKE_BLOCK 5
134
135
136
137
138typedef struct journal_header_s
139{
140 __be32 h_magic;
141 __be32 h_blocktype;
142 __be32 h_sequence;
143} journal_header_t;
144
145
146
147
148#define JBD2_CRC32_CHKSUM 1
149#define JBD2_MD5_CHKSUM 2
150#define JBD2_SHA1_CHKSUM 3
151#define JBD2_CRC32C_CHKSUM 4
152
153#define JBD2_CRC32_CHKSUM_SIZE 4
154
155#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170struct commit_header {
171 __be32 h_magic;
172 __be32 h_blocktype;
173 __be32 h_sequence;
174 unsigned char h_chksum_type;
175 unsigned char h_chksum_size;
176 unsigned char h_padding[2];
177 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
178 __be64 h_commit_sec;
179 __be32 h_commit_nsec;
180};
181
182
183
184
185
186
187
188typedef struct journal_block_tag_s
189{
190 __be32 t_blocknr;
191 __be16 t_checksum;
192 __be16 t_flags;
193 __be32 t_blocknr_high;
194} journal_block_tag_t;
195
196#define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
197#define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
198
199
200struct jbd2_journal_block_tail {
201 __be32 t_checksum;
202};
203
204
205
206
207
208typedef struct jbd2_journal_revoke_header_s
209{
210 journal_header_t r_header;
211 __be32 r_count;
212} jbd2_journal_revoke_header_t;
213
214
215struct jbd2_journal_revoke_tail {
216 __be32 r_checksum;
217};
218
219
220#define JBD2_FLAG_ESCAPE 1
221#define JBD2_FLAG_SAME_UUID 2
222#define JBD2_FLAG_DELETED 4
223#define JBD2_FLAG_LAST_TAG 8
224
225
226
227
228
229typedef struct journal_superblock_s
230{
231
232 journal_header_t s_header;
233
234
235
236 __be32 s_blocksize;
237 __be32 s_maxlen;
238 __be32 s_first;
239
240
241
242 __be32 s_sequence;
243 __be32 s_start;
244
245
246
247 __be32 s_errno;
248
249
250
251 __be32 s_feature_compat;
252 __be32 s_feature_incompat;
253 __be32 s_feature_ro_compat;
254
255 __u8 s_uuid[16];
256
257
258 __be32 s_nr_users;
259
260 __be32 s_dynsuper;
261
262
263 __be32 s_max_transaction;
264 __be32 s_max_trans_data;
265
266
267 __u8 s_checksum_type;
268 __u8 s_padding2[3];
269 __u32 s_padding[42];
270 __be32 s_checksum;
271
272
273 __u8 s_users[16*48];
274
275} journal_superblock_t;
276
277#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
278 ((j)->j_format_version >= 2 && \
279 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
280#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
281 ((j)->j_format_version >= 2 && \
282 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
283#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
284 ((j)->j_format_version >= 2 && \
285 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
286
287#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
288
289#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
290#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
291#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
292#define JBD2_FEATURE_INCOMPAT_CSUM_V2 0x00000008
293
294
295#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
296#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
297#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
298 JBD2_FEATURE_INCOMPAT_64BIT | \
299 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
300 JBD2_FEATURE_INCOMPAT_CSUM_V2)
301
302#ifdef __KERNEL__
303
304#include <linux/fs.h>
305#include <linux/sched.h>
306#include <linux/jbd_common.h>
307
308#define J_ASSERT(assert) BUG_ON(!(assert))
309
310#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
311#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
312
313#if defined(JBD2_PARANOID_IOFAIL)
314#define J_EXPECT(expr, why...) J_ASSERT(expr)
315#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
316#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
317#else
318#define __journal_expect(expr, why...) \
319 ({ \
320 int val = (expr); \
321 if (!val) { \
322 printk(KERN_ERR \
323 "JBD2 unexpected failure: %s: %s;\n", \
324 __func__, #expr); \
325 printk(KERN_ERR why "\n"); \
326 } \
327 val; \
328 })
329#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
330#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
331#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
332#endif
333
334
335#define __JI_COMMIT_RUNNING 0
336
337
338
339
340#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
341
342
343
344
345
346struct jbd2_inode {
347
348
349 transaction_t *i_transaction;
350
351
352
353 transaction_t *i_next_transaction;
354
355
356 struct list_head i_list;
357
358
359
360 struct inode *i_vfs_inode;
361
362
363 unsigned long i_flags;
364};
365
366struct jbd2_revoke_table_s;
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384struct jbd2_journal_handle
385{
386
387 transaction_t *h_transaction;
388
389
390 int h_buffer_credits;
391
392
393 int h_ref;
394
395
396
397 int h_err;
398
399
400 unsigned int h_sync:1;
401 unsigned int h_jdata:1;
402 unsigned int h_aborted:1;
403 unsigned int h_cowing:1;
404
405
406
407 unsigned int h_base_credits:14;
408
409
410
411 unsigned int h_user_credits:14;
412
413
414#ifdef CONFIG_DEBUG_LOCK_ALLOC
415 struct lockdep_map h_lockdep_map;
416#endif
417
418#ifdef CONFIG_JBD2_DEBUG
419
420 unsigned int h_cow_moved;
421 unsigned int h_cow_copied;
422 unsigned int h_cow_ok_jh;
423
424 unsigned int h_cow_ok_bitmap;
425 unsigned int h_cow_ok_mapped;
426 unsigned int h_cow_bitmaps;
427 unsigned int h_cow_excluded;
428#endif
429};
430
431
432
433
434
435struct transaction_chp_stats_s {
436 unsigned long cs_chp_time;
437 __u32 cs_forced_to_close;
438 __u32 cs_written;
439 __u32 cs_dropped;
440};
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478struct transaction_s
479{
480
481 journal_t *t_journal;
482
483
484 tid_t t_tid;
485
486
487
488
489
490
491
492
493
494 enum {
495 T_RUNNING,
496 T_LOCKED,
497 T_FLUSH,
498 T_COMMIT,
499 T_COMMIT_DFLUSH,
500 T_COMMIT_JFLUSH,
501 T_FINISHED
502 } t_state;
503
504
505
506
507 unsigned long t_log_start;
508
509
510 int t_nr_buffers;
511
512
513
514
515
516 struct journal_head *t_reserved_list;
517
518
519
520
521
522 struct journal_head *t_buffers;
523
524
525
526
527
528
529 struct journal_head *t_forget;
530
531
532
533
534
535 struct journal_head *t_checkpoint_list;
536
537
538
539
540
541 struct journal_head *t_checkpoint_io_list;
542
543
544
545
546
547 struct journal_head *t_iobuf_list;
548
549
550
551
552
553
554 struct journal_head *t_shadow_list;
555
556
557
558
559
560 struct journal_head *t_log_list;
561
562
563
564
565
566 struct list_head t_inode_list;
567
568
569
570
571 spinlock_t t_handle_lock;
572
573
574
575
576 unsigned long t_max_wait;
577
578
579
580
581 unsigned long t_start;
582
583
584
585
586 struct transaction_chp_stats_s t_chp_stats;
587
588
589
590
591
592 atomic_t t_updates;
593
594
595
596
597
598 atomic_t t_outstanding_credits;
599
600
601
602
603
604 transaction_t *t_cpnext, *t_cpprev;
605
606
607
608
609
610 unsigned long t_expires;
611
612
613
614
615 ktime_t t_start_time;
616
617
618
619
620 atomic_t t_handle_count;
621
622
623
624
625
626 unsigned int t_synchronous_commit:1;
627
628
629 int t_need_data_flush;
630
631
632
633
634
635 struct list_head t_private_list;
636};
637
638struct transaction_run_stats_s {
639 unsigned long rs_wait;
640 unsigned long rs_running;
641 unsigned long rs_locked;
642 unsigned long rs_flushing;
643 unsigned long rs_logging;
644
645 __u32 rs_handle_count;
646 __u32 rs_blocks;
647 __u32 rs_blocks_logged;
648};
649
650struct transaction_stats_s {
651 unsigned long ts_tid;
652 struct transaction_run_stats_s run;
653};
654
655static inline unsigned long
656jbd2_time_diff(unsigned long start, unsigned long end)
657{
658 if (end >= start)
659 return end - start;
660
661 return end + (MAX_JIFFY_OFFSET - start);
662}
663
664#define JBD2_NR_BATCH 64
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736struct journal_s
737{
738
739 unsigned long j_flags;
740
741
742
743
744
745 int j_errno;
746
747
748 struct buffer_head *j_sb_buffer;
749 journal_superblock_t *j_superblock;
750
751
752 int j_format_version;
753
754
755
756
757 rwlock_t j_state_lock;
758
759
760
761
762 int j_barrier_count;
763
764
765 struct mutex j_barrier;
766
767
768
769
770
771 transaction_t *j_running_transaction;
772
773
774
775
776
777 transaction_t *j_committing_transaction;
778
779
780
781
782
783 transaction_t *j_checkpoint_transactions;
784
785
786
787
788
789 wait_queue_head_t j_wait_transaction_locked;
790
791
792 wait_queue_head_t j_wait_logspace;
793
794
795 wait_queue_head_t j_wait_done_commit;
796
797
798 wait_queue_head_t j_wait_checkpoint;
799
800
801 wait_queue_head_t j_wait_commit;
802
803
804 wait_queue_head_t j_wait_updates;
805
806
807 struct mutex j_checkpoint_mutex;
808
809
810
811
812
813
814
815 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
816
817
818
819
820
821 unsigned long j_head;
822
823
824
825
826
827 unsigned long j_tail;
828
829
830
831
832
833 unsigned long j_free;
834
835
836
837
838
839 unsigned long j_first;
840 unsigned long j_last;
841
842
843
844
845
846 struct block_device *j_dev;
847 int j_blocksize;
848 unsigned long long j_blk_offset;
849 char j_devname[BDEVNAME_SIZE+24];
850
851
852
853
854
855 struct block_device *j_fs_dev;
856
857
858 unsigned int j_maxlen;
859
860
861
862
863 spinlock_t j_list_lock;
864
865
866
867
868 struct inode *j_inode;
869
870
871
872
873 tid_t j_tail_sequence;
874
875
876
877
878 tid_t j_transaction_sequence;
879
880
881
882
883
884 tid_t j_commit_sequence;
885
886
887
888
889
890 tid_t j_commit_request;
891
892
893
894
895
896
897
898 __u8 j_uuid[16];
899
900
901 struct task_struct *j_task;
902
903
904
905
906
907 int j_max_transaction_buffers;
908
909
910
911
912 unsigned long j_commit_interval;
913
914
915 struct timer_list j_commit_timer;
916
917
918
919
920
921 spinlock_t j_revoke_lock;
922 struct jbd2_revoke_table_s *j_revoke;
923 struct jbd2_revoke_table_s *j_revoke_table[2];
924
925
926
927
928 struct buffer_head **j_wbuf;
929 int j_wbufsize;
930
931
932
933
934
935 pid_t j_last_sync_writer;
936
937
938
939
940
941 u64 j_average_commit_time;
942
943
944
945
946
947
948 u32 j_min_batch_time;
949 u32 j_max_batch_time;
950
951
952 void (*j_commit_callback)(journal_t *,
953 transaction_t *);
954
955
956
957
958 spinlock_t j_history_lock;
959 struct proc_dir_entry *j_proc_entry;
960 struct transaction_stats_s j_stats;
961
962
963 unsigned int j_failed_commit;
964
965
966
967
968
969 void *j_private;
970
971
972 struct crypto_shash *j_chksum_driver;
973
974
975 __u32 j_csum_seed;
976};
977
978
979
980
981#define JBD2_UNMOUNT 0x001
982#define JBD2_ABORT 0x002
983#define JBD2_ACK_ERR 0x004
984#define JBD2_FLUSHED 0x008
985#define JBD2_LOADED 0x010
986#define JBD2_BARRIER 0x020
987#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040
988
989
990
991
992
993
994
995
996
997extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
998extern void __jbd2_journal_refile_buffer(struct journal_head *);
999extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1000extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1001extern void __journal_free_buffer(struct journal_head *bh);
1002extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1003extern void __journal_clean_data_list(transaction_t *transaction);
1004
1005
1006extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
1007int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1008int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1009 unsigned long *block);
1010void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1011void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1012
1013
1014extern void jbd2_journal_commit_transaction(journal_t *);
1015
1016
1017int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
1018int __jbd2_journal_remove_checkpoint(struct journal_head *);
1019void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
1020
1021
1022
1023
1024
1025
1026struct jbd2_buffer_trigger_type {
1027
1028
1029
1030
1031
1032
1033 void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
1034 struct buffer_head *bh, void *mapped_data,
1035 size_t size);
1036
1037
1038
1039
1040
1041 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1042 struct buffer_head *bh);
1043};
1044
1045extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1046 void *mapped_data,
1047 struct jbd2_buffer_trigger_type *triggers);
1048extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1049 struct jbd2_buffer_trigger_type *triggers);
1050
1051
1052extern int
1053jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1054 struct journal_head *jh_in,
1055 struct journal_head **jh_out,
1056 unsigned long long blocknr);
1057
1058
1059extern void __wait_on_journal (journal_t *);
1060
1061
1062extern void jbd2_journal_destroy_transaction_cache(void);
1063extern int jbd2_journal_init_transaction_cache(void);
1064extern void jbd2_journal_free_transaction(transaction_t *);
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077static inline handle_t *journal_current_handle(void)
1078{
1079 return current->journal_info;
1080}
1081
1082
1083
1084
1085
1086
1087
1088extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1089extern handle_t *jbd2__journal_start(journal_t *, int nblocks, gfp_t gfp_mask);
1090extern int jbd2_journal_restart(handle_t *, int nblocks);
1091extern int jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
1092extern int jbd2_journal_extend (handle_t *, int nblocks);
1093extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1094extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1095extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1096void jbd2_journal_set_triggers(struct buffer_head *,
1097 struct jbd2_buffer_trigger_type *type);
1098extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1099extern void jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
1100extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1101extern void journal_sync_buffer (struct buffer_head *);
1102extern void jbd2_journal_invalidatepage(journal_t *,
1103 struct page *, unsigned long);
1104extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1105extern int jbd2_journal_stop(handle_t *);
1106extern int jbd2_journal_flush (journal_t *);
1107extern void jbd2_journal_lock_updates (journal_t *);
1108extern void jbd2_journal_unlock_updates (journal_t *);
1109
1110extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1111 struct block_device *fs_dev,
1112 unsigned long long start, int len, int bsize);
1113extern journal_t * jbd2_journal_init_inode (struct inode *);
1114extern int jbd2_journal_update_format (journal_t *);
1115extern int jbd2_journal_check_used_features
1116 (journal_t *, unsigned long, unsigned long, unsigned long);
1117extern int jbd2_journal_check_available_features
1118 (journal_t *, unsigned long, unsigned long, unsigned long);
1119extern int jbd2_journal_set_features
1120 (journal_t *, unsigned long, unsigned long, unsigned long);
1121extern void jbd2_journal_clear_features
1122 (journal_t *, unsigned long, unsigned long, unsigned long);
1123extern int jbd2_journal_load (journal_t *journal);
1124extern int jbd2_journal_destroy (journal_t *);
1125extern int jbd2_journal_recover (journal_t *journal);
1126extern int jbd2_journal_wipe (journal_t *, int);
1127extern int jbd2_journal_skip_recovery (journal_t *);
1128extern void jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1129 unsigned long, int);
1130extern void __jbd2_journal_abort_hard (journal_t *);
1131extern void jbd2_journal_abort (journal_t *, int);
1132extern int jbd2_journal_errno (journal_t *);
1133extern void jbd2_journal_ack_err (journal_t *);
1134extern int jbd2_journal_clear_err (journal_t *);
1135extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1136extern int jbd2_journal_force_commit(journal_t *);
1137extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
1138extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1139 struct jbd2_inode *inode, loff_t new_size);
1140extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1141extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1142
1143
1144
1145
1146struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1147struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1148void jbd2_journal_put_journal_head(struct journal_head *jh);
1149
1150
1151
1152
1153extern struct kmem_cache *jbd2_handle_cache;
1154
1155static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1156{
1157 return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
1158}
1159
1160static inline void jbd2_free_handle(handle_t *handle)
1161{
1162 kmem_cache_free(jbd2_handle_cache, handle);
1163}
1164
1165
1166
1167
1168
1169extern struct kmem_cache *jbd2_inode_cache;
1170
1171static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1172{
1173 return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1174}
1175
1176static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1177{
1178 kmem_cache_free(jbd2_inode_cache, jinode);
1179}
1180
1181
1182#define JOURNAL_REVOKE_DEFAULT_HASH 256
1183extern int jbd2_journal_init_revoke(journal_t *, int);
1184extern void jbd2_journal_destroy_revoke_caches(void);
1185extern int jbd2_journal_init_revoke_caches(void);
1186
1187extern void jbd2_journal_destroy_revoke(journal_t *);
1188extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1189extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1190extern void jbd2_journal_write_revoke_records(journal_t *,
1191 transaction_t *, int);
1192
1193
1194extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1195extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1196extern void jbd2_journal_clear_revoke(journal_t *);
1197extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1198extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
1199
1200
1201
1202
1203
1204
1205
1206
1207int __jbd2_log_space_left(journal_t *);
1208int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1209int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1210int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1211int jbd2_journal_force_commit_nested(journal_t *journal);
1212int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1213int jbd2_log_do_checkpoint(journal_t *journal);
1214int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1215
1216void __jbd2_log_wait_for_space(journal_t *journal);
1217extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1218extern int jbd2_cleanup_journal_tail(journal_t *);
1219
1220
1221
1222#define jbd_ENOSYS() \
1223do { \
1224 printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
1225 current->state = TASK_UNINTERRUPTIBLE; \
1226 schedule(); \
1227} while (1)
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239static inline int is_journal_aborted(journal_t *journal)
1240{
1241 return journal->j_flags & JBD2_ABORT;
1242}
1243
1244static inline int is_handle_aborted(handle_t *handle)
1245{
1246 if (handle->h_aborted)
1247 return 1;
1248 return is_journal_aborted(handle->h_transaction->t_journal);
1249}
1250
1251static inline void jbd2_journal_abort_handle(handle_t *handle)
1252{
1253 handle->h_aborted = 1;
1254}
1255
1256#endif
1257
1258
1259
1260
1261static inline int tid_gt(tid_t x, tid_t y)
1262{
1263 int difference = (x - y);
1264 return (difference > 0);
1265}
1266
1267static inline int tid_geq(tid_t x, tid_t y)
1268{
1269 int difference = (x - y);
1270 return (difference >= 0);
1271}
1272
1273extern int jbd2_journal_blocks_per_page(struct inode *inode);
1274extern size_t journal_tag_bytes(journal_t *journal);
1275
1276
1277
1278
1279
1280static inline int jbd_space_needed(journal_t *journal)
1281{
1282 int nblocks = journal->j_max_transaction_buffers;
1283 if (journal->j_committing_transaction)
1284 nblocks += atomic_read(&journal->j_committing_transaction->
1285 t_outstanding_credits);
1286 return nblocks;
1287}
1288
1289
1290
1291
1292
1293
1294#define BJ_None 0
1295#define BJ_Metadata 1
1296#define BJ_Forget 2
1297#define BJ_IO 3
1298#define BJ_Shadow 4
1299#define BJ_LogCtl 5
1300#define BJ_Reserved 6
1301#define BJ_Types 7
1302
1303extern int jbd_blocks_per_page(struct inode *inode);
1304
1305static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1306 const void *address, unsigned int length)
1307{
1308 struct {
1309 struct shash_desc shash;
1310 char ctx[crypto_shash_descsize(journal->j_chksum_driver)];
1311 } desc;
1312 int err;
1313
1314 desc.shash.tfm = journal->j_chksum_driver;
1315 desc.shash.flags = 0;
1316 *(u32 *)desc.ctx = crc;
1317
1318 err = crypto_shash_update(&desc.shash, address, length);
1319 BUG_ON(err);
1320
1321 return *(u32 *)desc.ctx;
1322}
1323
1324#ifdef __KERNEL__
1325
1326#define buffer_trace_init(bh) do {} while (0)
1327#define print_buffer_fields(bh) do {} while (0)
1328#define print_buffer_trace(bh) do {} while (0)
1329#define BUFFER_TRACE(bh, info) do {} while (0)
1330#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1331#define JBUFFER_TRACE(jh, info) do {} while (0)
1332
1333#endif
1334
1335#endif
1336