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#else
24
25#include <linux/types.h>
26#include <linux/buffer_head.h>
27#include <linux/journal-head.h>
28#include <linux/stddef.h>
29#include <linux/mutex.h>
30#include <linux/timer.h>
31#include <linux/slab.h>
32#include <linux/bit_spinlock.h>
33#include <crypto/hash.h>
34#endif
35
36#define journal_oom_retry 1
37
38
39
40
41
42
43
44
45#undef JBD2_PARANOID_IOFAIL
46
47
48
49
50#define JBD2_DEFAULT_MAX_COMMIT_AGE 5
51
52#ifdef CONFIG_JBD2_DEBUG
53
54
55
56
57
58#define JBD2_EXPENSIVE_CHECKING
59extern ushort jbd2_journal_enable_debug;
60void __jbd2_debug(int level, const char *file, const char *func,
61 unsigned int line, const char *fmt, ...);
62
63#define jbd_debug(n, fmt, a...) \
64 __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
65#else
66#define jbd_debug(n, fmt, a...)
67#endif
68
69extern void *jbd2_alloc(size_t size, gfp_t flags);
70extern void jbd2_free(void *ptr, size_t size);
71
72#define JBD2_MIN_JOURNAL_BLOCKS 1024
73
74#ifdef __KERNEL__
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93typedef struct jbd2_journal_handle handle_t;
94
95
96
97
98
99
100
101
102
103
104
105
106
107typedef struct journal_s journal_t;
108#endif
109
110
111
112
113
114#define JBD2_MAGIC_NUMBER 0xc03b3998U
115
116
117
118
119
120
121
122
123
124#define JBD2_DESCRIPTOR_BLOCK 1
125#define JBD2_COMMIT_BLOCK 2
126#define JBD2_SUPERBLOCK_V1 3
127#define JBD2_SUPERBLOCK_V2 4
128#define JBD2_REVOKE_BLOCK 5
129
130
131
132
133typedef struct journal_header_s
134{
135 __be32 h_magic;
136 __be32 h_blocktype;
137 __be32 h_sequence;
138} journal_header_t;
139
140
141
142
143#define JBD2_CRC32_CHKSUM 1
144#define JBD2_MD5_CHKSUM 2
145#define JBD2_SHA1_CHKSUM 3
146#define JBD2_CRC32C_CHKSUM 4
147
148#define JBD2_CRC32_CHKSUM_SIZE 4
149
150#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169struct commit_header {
170 __be32 h_magic;
171 __be32 h_blocktype;
172 __be32 h_sequence;
173 unsigned char h_chksum_type;
174 unsigned char h_chksum_size;
175 unsigned char h_padding[2];
176 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
177 __be64 h_commit_sec;
178 __be32 h_commit_nsec;
179};
180
181
182
183
184
185
186
187typedef struct journal_block_tag3_s
188{
189 __be32 t_blocknr;
190 __be32 t_flags;
191 __be32 t_blocknr_high;
192 __be32 t_checksum;
193} journal_block_tag3_t;
194
195typedef struct journal_block_tag_s
196{
197 __be32 t_blocknr;
198 __be16 t_checksum;
199 __be16 t_flags;
200 __be32 t_blocknr_high;
201} journal_block_tag_t;
202
203
204struct jbd2_journal_block_tail {
205 __be32 t_checksum;
206};
207
208
209
210
211
212typedef struct jbd2_journal_revoke_header_s
213{
214 journal_header_t r_header;
215 __be32 r_count;
216} jbd2_journal_revoke_header_t;
217
218
219#define JBD2_FLAG_ESCAPE 1
220#define JBD2_FLAG_SAME_UUID 2
221#define JBD2_FLAG_DELETED 4
222#define JBD2_FLAG_LAST_TAG 8
223
224
225
226
227
228typedef struct journal_superblock_s
229{
230
231 journal_header_t s_header;
232
233
234
235 __be32 s_blocksize;
236 __be32 s_maxlen;
237 __be32 s_first;
238
239
240
241 __be32 s_sequence;
242 __be32 s_start;
243
244
245
246 __be32 s_errno;
247
248
249
250 __be32 s_feature_compat;
251 __be32 s_feature_incompat;
252 __be32 s_feature_ro_compat;
253
254 __u8 s_uuid[16];
255
256
257 __be32 s_nr_users;
258
259 __be32 s_dynsuper;
260
261
262 __be32 s_max_transaction;
263 __be32 s_max_trans_data;
264
265
266 __u8 s_checksum_type;
267 __u8 s_padding2[3];
268 __u32 s_padding[42];
269 __be32 s_checksum;
270
271
272 __u8 s_users[16*48];
273
274} journal_superblock_t;
275
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#define JBD2_FEATURE_INCOMPAT_CSUM_V3 0x00000010
294
295
296
297
298#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
299#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
300#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
301 JBD2_FEATURE_INCOMPAT_64BIT | \
302 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT | \
303 JBD2_FEATURE_INCOMPAT_CSUM_V2 | \
304 JBD2_FEATURE_INCOMPAT_CSUM_V3)
305
306#ifdef __KERNEL__
307
308#include <linux/fs.h>
309#include <linux/sched.h>
310
311enum jbd_state_bits {
312 BH_JBD
313 = BH_PrivateStart,
314 BH_JWrite,
315 BH_Freed,
316 BH_Revoked,
317 BH_RevokeValid,
318 BH_JBDDirty,
319 BH_State,
320 BH_JournalHead,
321 BH_Shadow,
322 BH_Verified,
323 BH_JBDPrivateStart,
324};
325
326BUFFER_FNS(JBD, jbd)
327BUFFER_FNS(JWrite, jwrite)
328BUFFER_FNS(JBDDirty, jbddirty)
329TAS_BUFFER_FNS(JBDDirty, jbddirty)
330BUFFER_FNS(Revoked, revoked)
331TAS_BUFFER_FNS(Revoked, revoked)
332BUFFER_FNS(RevokeValid, revokevalid)
333TAS_BUFFER_FNS(RevokeValid, revokevalid)
334BUFFER_FNS(Freed, freed)
335BUFFER_FNS(Shadow, shadow)
336BUFFER_FNS(Verified, verified)
337
338static inline struct buffer_head *jh2bh(struct journal_head *jh)
339{
340 return jh->b_bh;
341}
342
343static inline struct journal_head *bh2jh(struct buffer_head *bh)
344{
345 return bh->b_private;
346}
347
348static inline void jbd_lock_bh_state(struct buffer_head *bh)
349{
350 bit_spin_lock(BH_State, &bh->b_state);
351}
352
353static inline int jbd_trylock_bh_state(struct buffer_head *bh)
354{
355 return bit_spin_trylock(BH_State, &bh->b_state);
356}
357
358static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
359{
360 return bit_spin_is_locked(BH_State, &bh->b_state);
361}
362
363static inline void jbd_unlock_bh_state(struct buffer_head *bh)
364{
365 bit_spin_unlock(BH_State, &bh->b_state);
366}
367
368static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
369{
370 bit_spin_lock(BH_JournalHead, &bh->b_state);
371}
372
373static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
374{
375 bit_spin_unlock(BH_JournalHead, &bh->b_state);
376}
377
378#define J_ASSERT(assert) BUG_ON(!(assert))
379
380#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
381#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
382
383#if defined(JBD2_PARANOID_IOFAIL)
384#define J_EXPECT(expr, why...) J_ASSERT(expr)
385#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
386#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
387#else
388#define __journal_expect(expr, why...) \
389 ({ \
390 int val = (expr); \
391 if (!val) { \
392 printk(KERN_ERR \
393 "JBD2 unexpected failure: %s: %s;\n", \
394 __func__, #expr); \
395 printk(KERN_ERR why "\n"); \
396 } \
397 val; \
398 })
399#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
400#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
401#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
402#endif
403
404
405#define __JI_COMMIT_RUNNING 0
406#define __JI_WRITE_DATA 1
407#define __JI_WAIT_DATA 2
408
409
410
411
412
413
414#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
415
416#define JI_WRITE_DATA (1 << __JI_WRITE_DATA)
417
418#define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
419
420
421
422
423
424struct jbd2_inode {
425
426
427
428
429
430
431 transaction_t *i_transaction;
432
433
434
435
436
437
438
439 transaction_t *i_next_transaction;
440
441
442
443
444 struct list_head i_list;
445
446
447
448
449
450
451 struct inode *i_vfs_inode;
452
453
454
455
456 unsigned long i_flags;
457};
458
459struct jbd2_revoke_table_s;
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485struct jbd2_journal_handle
486{
487 union {
488 transaction_t *h_transaction;
489
490 journal_t *h_journal;
491 };
492
493 handle_t *h_rsv_handle;
494 int h_buffer_credits;
495 int h_ref;
496 int h_err;
497
498
499 unsigned int h_sync: 1;
500 unsigned int h_jdata: 1;
501 unsigned int h_reserved: 1;
502 unsigned int h_aborted: 1;
503 unsigned int h_type: 8;
504 unsigned int h_line_no: 16;
505
506 unsigned long h_start_jiffies;
507 unsigned int h_requested_credits;
508
509 unsigned int saved_alloc_context;
510};
511
512
513
514
515
516struct transaction_chp_stats_s {
517 unsigned long cs_chp_time;
518 __u32 cs_forced_to_close;
519 __u32 cs_written;
520 __u32 cs_dropped;
521};
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559struct transaction_s
560{
561
562 journal_t *t_journal;
563
564
565 tid_t t_tid;
566
567
568
569
570
571
572
573
574
575 enum {
576 T_RUNNING,
577 T_LOCKED,
578 T_FLUSH,
579 T_COMMIT,
580 T_COMMIT_DFLUSH,
581 T_COMMIT_JFLUSH,
582 T_COMMIT_CALLBACK,
583 T_FINISHED
584 } t_state;
585
586
587
588
589 unsigned long t_log_start;
590
591
592 int t_nr_buffers;
593
594
595
596
597
598 struct journal_head *t_reserved_list;
599
600
601
602
603
604 struct journal_head *t_buffers;
605
606
607
608
609
610
611 struct journal_head *t_forget;
612
613
614
615
616
617 struct journal_head *t_checkpoint_list;
618
619
620
621
622
623 struct journal_head *t_checkpoint_io_list;
624
625
626
627
628
629
630 struct journal_head *t_shadow_list;
631
632
633
634
635
636 struct list_head t_inode_list;
637
638
639
640
641 spinlock_t t_handle_lock;
642
643
644
645
646 unsigned long t_max_wait;
647
648
649
650
651 unsigned long t_start;
652
653
654
655
656 unsigned long t_requested;
657
658
659
660
661 struct transaction_chp_stats_s t_chp_stats;
662
663
664
665
666
667 atomic_t t_updates;
668
669
670
671
672
673 atomic_t t_outstanding_credits;
674
675
676
677
678
679 transaction_t *t_cpnext, *t_cpprev;
680
681
682
683
684
685 unsigned long t_expires;
686
687
688
689
690 ktime_t t_start_time;
691
692
693
694
695 atomic_t t_handle_count;
696
697
698
699
700
701 unsigned int t_synchronous_commit:1;
702
703
704 int t_need_data_flush;
705
706
707
708
709
710 struct list_head t_private_list;
711};
712
713struct transaction_run_stats_s {
714 unsigned long rs_wait;
715 unsigned long rs_request_delay;
716 unsigned long rs_running;
717 unsigned long rs_locked;
718 unsigned long rs_flushing;
719 unsigned long rs_logging;
720
721 __u32 rs_handle_count;
722 __u32 rs_blocks;
723 __u32 rs_blocks_logged;
724};
725
726struct transaction_stats_s {
727 unsigned long ts_tid;
728 unsigned long ts_requested;
729 struct transaction_run_stats_s run;
730};
731
732static inline unsigned long
733jbd2_time_diff(unsigned long start, unsigned long end)
734{
735 if (end >= start)
736 return end - start;
737
738 return end + (MAX_JIFFY_OFFSET - start);
739}
740
741#define JBD2_NR_BATCH 64
742
743
744
745
746
747struct journal_s
748{
749
750
751
752 unsigned long j_flags;
753
754
755
756
757
758
759
760 int j_errno;
761
762
763
764
765 struct buffer_head *j_sb_buffer;
766
767
768
769
770 journal_superblock_t *j_superblock;
771
772
773
774
775 int j_format_version;
776
777
778
779
780 rwlock_t j_state_lock;
781
782
783
784
785
786
787 int j_barrier_count;
788
789
790
791
792 struct mutex j_barrier;
793
794
795
796
797
798
799
800 transaction_t *j_running_transaction;
801
802
803
804
805
806
807
808 transaction_t *j_committing_transaction;
809
810
811
812
813
814
815
816 transaction_t *j_checkpoint_transactions;
817
818
819
820
821
822
823
824 wait_queue_head_t j_wait_transaction_locked;
825
826
827
828
829 wait_queue_head_t j_wait_done_commit;
830
831
832
833
834 wait_queue_head_t j_wait_commit;
835
836
837
838
839 wait_queue_head_t j_wait_updates;
840
841
842
843
844
845
846 wait_queue_head_t j_wait_reserved;
847
848
849
850
851
852
853 struct mutex j_checkpoint_mutex;
854
855
856
857
858
859
860
861
862
863 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
864
865
866
867
868
869
870
871 unsigned long j_head;
872
873
874
875
876
877
878
879 unsigned long j_tail;
880
881
882
883
884
885
886
887 unsigned long j_free;
888
889
890
891
892
893
894
895 unsigned long j_first;
896
897
898
899
900
901
902
903 unsigned long j_last;
904
905
906
907
908 struct block_device *j_dev;
909
910
911
912
913 int j_blocksize;
914
915
916
917
918
919
920 unsigned long long j_blk_offset;
921
922
923
924
925 char j_devname[BDEVNAME_SIZE+24];
926
927
928
929
930
931
932
933 struct block_device *j_fs_dev;
934
935
936
937
938 unsigned int j_maxlen;
939
940
941
942
943
944
945 atomic_t j_reserved_credits;
946
947
948
949
950 spinlock_t j_list_lock;
951
952
953
954
955
956
957
958 struct inode *j_inode;
959
960
961
962
963
964
965 tid_t j_tail_sequence;
966
967
968
969
970
971
972 tid_t j_transaction_sequence;
973
974
975
976
977
978
979
980 tid_t j_commit_sequence;
981
982
983
984
985
986
987
988 tid_t j_commit_request;
989
990
991
992
993
994
995
996
997
998 __u8 j_uuid[16];
999
1000
1001
1002
1003 struct task_struct *j_task;
1004
1005
1006
1007
1008
1009
1010
1011 int j_max_transaction_buffers;
1012
1013
1014
1015
1016
1017
1018 unsigned long j_commit_interval;
1019
1020
1021
1022
1023 struct timer_list j_commit_timer;
1024
1025
1026
1027
1028 spinlock_t j_revoke_lock;
1029
1030
1031
1032
1033
1034
1035
1036 struct jbd2_revoke_table_s *j_revoke;
1037
1038
1039
1040
1041 struct jbd2_revoke_table_s *j_revoke_table[2];
1042
1043
1044
1045
1046 struct buffer_head **j_wbuf;
1047
1048
1049
1050
1051
1052
1053 int j_wbufsize;
1054
1055
1056
1057
1058
1059
1060
1061 pid_t j_last_sync_writer;
1062
1063
1064
1065
1066
1067
1068
1069 u64 j_average_commit_time;
1070
1071
1072
1073
1074
1075
1076
1077 u32 j_min_batch_time;
1078
1079
1080
1081
1082
1083
1084
1085 u32 j_max_batch_time;
1086
1087
1088
1089
1090
1091
1092 void (*j_commit_callback)(journal_t *,
1093 transaction_t *);
1094
1095
1096
1097
1098
1099
1100
1101
1102 spinlock_t j_history_lock;
1103
1104
1105
1106
1107 struct proc_dir_entry *j_proc_entry;
1108
1109
1110
1111
1112 struct transaction_stats_s j_stats;
1113
1114
1115
1116
1117 unsigned int j_failed_commit;
1118
1119
1120
1121
1122
1123
1124
1125 void *j_private;
1126
1127
1128
1129
1130
1131
1132 struct crypto_shash *j_chksum_driver;
1133
1134
1135
1136
1137
1138
1139 __u32 j_csum_seed;
1140
1141#ifdef CONFIG_DEBUG_LOCK_ALLOC
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152 struct lockdep_map j_trans_commit_map;
1153#endif
1154};
1155
1156#define jbd2_might_wait_for_commit(j) \
1157 do { \
1158 rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
1159 rwsem_release(&j->j_trans_commit_map, 1, _THIS_IP_); \
1160 } while (0)
1161
1162
1163#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
1164static inline bool jbd2_has_feature_##name(journal_t *j) \
1165{ \
1166 return ((j)->j_format_version >= 2 && \
1167 ((j)->j_superblock->s_feature_compat & \
1168 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
1169} \
1170static inline void jbd2_set_feature_##name(journal_t *j) \
1171{ \
1172 (j)->j_superblock->s_feature_compat |= \
1173 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1174} \
1175static inline void jbd2_clear_feature_##name(journal_t *j) \
1176{ \
1177 (j)->j_superblock->s_feature_compat &= \
1178 ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1179}
1180
1181#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
1182static inline bool jbd2_has_feature_##name(journal_t *j) \
1183{ \
1184 return ((j)->j_format_version >= 2 && \
1185 ((j)->j_superblock->s_feature_ro_compat & \
1186 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
1187} \
1188static inline void jbd2_set_feature_##name(journal_t *j) \
1189{ \
1190 (j)->j_superblock->s_feature_ro_compat |= \
1191 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1192} \
1193static inline void jbd2_clear_feature_##name(journal_t *j) \
1194{ \
1195 (j)->j_superblock->s_feature_ro_compat &= \
1196 ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1197}
1198
1199#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
1200static inline bool jbd2_has_feature_##name(journal_t *j) \
1201{ \
1202 return ((j)->j_format_version >= 2 && \
1203 ((j)->j_superblock->s_feature_incompat & \
1204 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
1205} \
1206static inline void jbd2_set_feature_##name(journal_t *j) \
1207{ \
1208 (j)->j_superblock->s_feature_incompat |= \
1209 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1210} \
1211static inline void jbd2_clear_feature_##name(journal_t *j) \
1212{ \
1213 (j)->j_superblock->s_feature_incompat &= \
1214 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1215}
1216
1217JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
1218
1219JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
1220JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
1221JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
1222JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
1223JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
1224
1225
1226
1227
1228#define JBD2_UNMOUNT 0x001
1229#define JBD2_ABORT 0x002
1230#define JBD2_ACK_ERR 0x004
1231#define JBD2_FLUSHED 0x008
1232#define JBD2_LOADED 0x010
1233#define JBD2_BARRIER 0x020
1234#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040
1235
1236
1237#define JBD2_REC_ERR 0x080
1238
1239
1240
1241
1242
1243
1244
1245extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
1246extern void __jbd2_journal_refile_buffer(struct journal_head *);
1247extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1248extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1249extern void __journal_free_buffer(struct journal_head *bh);
1250extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1251extern void __journal_clean_data_list(transaction_t *transaction);
1252static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
1253{
1254 list_add_tail(&bh->b_assoc_buffers, head);
1255}
1256static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
1257{
1258 list_del_init(&bh->b_assoc_buffers);
1259}
1260
1261
1262struct buffer_head *jbd2_journal_get_descriptor_buffer(transaction_t *, int);
1263void jbd2_descriptor_block_csum_set(journal_t *, struct buffer_head *);
1264int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1265int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1266 unsigned long *block);
1267int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1268void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1269
1270
1271extern void jbd2_journal_commit_transaction(journal_t *);
1272
1273
1274void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
1275int __jbd2_journal_remove_checkpoint(struct journal_head *);
1276void jbd2_journal_destroy_checkpoint(journal_t *journal);
1277void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
1278
1279
1280
1281
1282
1283
1284struct jbd2_buffer_trigger_type {
1285
1286
1287
1288
1289
1290
1291 void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
1292 struct buffer_head *bh, void *mapped_data,
1293 size_t size);
1294
1295
1296
1297
1298
1299 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1300 struct buffer_head *bh);
1301};
1302
1303extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1304 void *mapped_data,
1305 struct jbd2_buffer_trigger_type *triggers);
1306extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1307 struct jbd2_buffer_trigger_type *triggers);
1308
1309
1310extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1311 struct journal_head *jh_in,
1312 struct buffer_head **bh_out,
1313 sector_t blocknr);
1314
1315
1316extern void __wait_on_journal (journal_t *);
1317
1318
1319extern void jbd2_journal_destroy_transaction_cache(void);
1320extern int jbd2_journal_init_transaction_cache(void);
1321extern void jbd2_journal_free_transaction(transaction_t *);
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334static inline handle_t *journal_current_handle(void)
1335{
1336 return current->journal_info;
1337}
1338
1339
1340
1341
1342
1343
1344
1345extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1346extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
1347 gfp_t gfp_mask, unsigned int type,
1348 unsigned int line_no);
1349extern int jbd2_journal_restart(handle_t *, int nblocks);
1350extern int jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
1351extern int jbd2_journal_start_reserved(handle_t *handle,
1352 unsigned int type, unsigned int line_no);
1353extern void jbd2_journal_free_reserved(handle_t *handle);
1354extern int jbd2_journal_extend (handle_t *, int nblocks);
1355extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1356extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1357extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1358void jbd2_journal_set_triggers(struct buffer_head *,
1359 struct jbd2_buffer_trigger_type *type);
1360extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1361extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1362extern void journal_sync_buffer (struct buffer_head *);
1363extern int jbd2_journal_invalidatepage(journal_t *,
1364 struct page *, unsigned int, unsigned int);
1365extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1366extern int jbd2_journal_stop(handle_t *);
1367extern int jbd2_journal_flush (journal_t *);
1368extern void jbd2_journal_lock_updates (journal_t *);
1369extern void jbd2_journal_unlock_updates (journal_t *);
1370
1371extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1372 struct block_device *fs_dev,
1373 unsigned long long start, int len, int bsize);
1374extern journal_t * jbd2_journal_init_inode (struct inode *);
1375extern int jbd2_journal_update_format (journal_t *);
1376extern int jbd2_journal_check_used_features
1377 (journal_t *, unsigned long, unsigned long, unsigned long);
1378extern int jbd2_journal_check_available_features
1379 (journal_t *, unsigned long, unsigned long, unsigned long);
1380extern int jbd2_journal_set_features
1381 (journal_t *, unsigned long, unsigned long, unsigned long);
1382extern void jbd2_journal_clear_features
1383 (journal_t *, unsigned long, unsigned long, unsigned long);
1384extern int jbd2_journal_load (journal_t *journal);
1385extern int jbd2_journal_destroy (journal_t *);
1386extern int jbd2_journal_recover (journal_t *journal);
1387extern int jbd2_journal_wipe (journal_t *, int);
1388extern int jbd2_journal_skip_recovery (journal_t *);
1389extern void jbd2_journal_update_sb_errno(journal_t *);
1390extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1391 unsigned long, int);
1392extern void __jbd2_journal_abort_hard (journal_t *);
1393extern void jbd2_journal_abort (journal_t *, int);
1394extern int jbd2_journal_errno (journal_t *);
1395extern void jbd2_journal_ack_err (journal_t *);
1396extern int jbd2_journal_clear_err (journal_t *);
1397extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1398extern int jbd2_journal_force_commit(journal_t *);
1399extern int jbd2_journal_force_commit_nested(journal_t *);
1400extern int jbd2_journal_inode_add_write(handle_t *handle, struct jbd2_inode *inode);
1401extern int jbd2_journal_inode_add_wait(handle_t *handle, struct jbd2_inode *inode);
1402extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1403 struct jbd2_inode *inode, loff_t new_size);
1404extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1405extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1406
1407
1408
1409
1410struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1411struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1412void jbd2_journal_put_journal_head(struct journal_head *jh);
1413
1414
1415
1416
1417extern struct kmem_cache *jbd2_handle_cache;
1418
1419static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1420{
1421 return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
1422}
1423
1424static inline void jbd2_free_handle(handle_t *handle)
1425{
1426 kmem_cache_free(jbd2_handle_cache, handle);
1427}
1428
1429
1430
1431
1432
1433extern struct kmem_cache *jbd2_inode_cache;
1434
1435static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1436{
1437 return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1438}
1439
1440static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1441{
1442 kmem_cache_free(jbd2_inode_cache, jinode);
1443}
1444
1445
1446#define JOURNAL_REVOKE_DEFAULT_HASH 256
1447extern int jbd2_journal_init_revoke(journal_t *, int);
1448extern void jbd2_journal_destroy_revoke_caches(void);
1449extern int jbd2_journal_init_revoke_caches(void);
1450
1451extern void jbd2_journal_destroy_revoke(journal_t *);
1452extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1453extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1454extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1455 struct list_head *log_bufs);
1456
1457
1458extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1459extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1460extern void jbd2_journal_clear_revoke(journal_t *);
1461extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1462extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
1463
1464
1465
1466
1467
1468
1469
1470
1471int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1472int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1473int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1474int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1475int jbd2_transaction_committed(journal_t *journal, tid_t tid);
1476int jbd2_complete_transaction(journal_t *journal, tid_t tid);
1477int jbd2_log_do_checkpoint(journal_t *journal);
1478int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1479
1480void __jbd2_log_wait_for_space(journal_t *journal);
1481extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1482extern int jbd2_cleanup_journal_tail(journal_t *);
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494static inline int is_journal_aborted(journal_t *journal)
1495{
1496 return journal->j_flags & JBD2_ABORT;
1497}
1498
1499static inline int is_handle_aborted(handle_t *handle)
1500{
1501 if (handle->h_aborted || !handle->h_transaction)
1502 return 1;
1503 return is_journal_aborted(handle->h_transaction->t_journal);
1504}
1505
1506static inline void jbd2_journal_abort_handle(handle_t *handle)
1507{
1508 handle->h_aborted = 1;
1509}
1510
1511#endif
1512
1513
1514
1515
1516static inline int tid_gt(tid_t x, tid_t y)
1517{
1518 int difference = (x - y);
1519 return (difference > 0);
1520}
1521
1522static inline int tid_geq(tid_t x, tid_t y)
1523{
1524 int difference = (x - y);
1525 return (difference >= 0);
1526}
1527
1528extern int jbd2_journal_blocks_per_page(struct inode *inode);
1529extern size_t journal_tag_bytes(journal_t *journal);
1530
1531static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
1532{
1533 return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
1534}
1535
1536static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
1537{
1538 WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
1539 journal->j_chksum_driver == NULL);
1540
1541 return journal->j_chksum_driver != NULL;
1542}
1543
1544
1545
1546
1547
1548#define JBD2_CONTROL_BLOCKS_SHIFT 5
1549
1550
1551
1552
1553
1554static inline int jbd2_space_needed(journal_t *journal)
1555{
1556 int nblocks = journal->j_max_transaction_buffers;
1557 return nblocks + (nblocks >> JBD2_CONTROL_BLOCKS_SHIFT);
1558}
1559
1560
1561
1562
1563static inline unsigned long jbd2_log_space_left(journal_t *journal)
1564{
1565
1566 unsigned long free = journal->j_free - 32;
1567
1568 if (journal->j_committing_transaction) {
1569 unsigned long committing = atomic_read(&journal->
1570 j_committing_transaction->t_outstanding_credits);
1571
1572
1573 free -= committing + (committing >> JBD2_CONTROL_BLOCKS_SHIFT);
1574 }
1575 return free;
1576}
1577
1578
1579
1580
1581
1582
1583#define BJ_None 0
1584#define BJ_Metadata 1
1585#define BJ_Forget 2
1586#define BJ_Shadow 3
1587#define BJ_Reserved 4
1588#define BJ_Types 5
1589
1590extern int jbd_blocks_per_page(struct inode *inode);
1591
1592
1593#define JBD_MAX_CHECKSUM_SIZE 4
1594
1595static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1596 const void *address, unsigned int length)
1597{
1598 struct {
1599 struct shash_desc shash;
1600 char ctx[JBD_MAX_CHECKSUM_SIZE];
1601 } desc;
1602 int err;
1603
1604 BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
1605 JBD_MAX_CHECKSUM_SIZE);
1606
1607 desc.shash.tfm = journal->j_chksum_driver;
1608 desc.shash.flags = 0;
1609 *(u32 *)desc.ctx = crc;
1610
1611 err = crypto_shash_update(&desc.shash, address, length);
1612 BUG_ON(err);
1613
1614 return *(u32 *)desc.ctx;
1615}
1616
1617
1618static inline tid_t jbd2_get_latest_transaction(journal_t *journal)
1619{
1620 tid_t tid;
1621
1622 read_lock(&journal->j_state_lock);
1623 tid = journal->j_commit_request;
1624 if (journal->j_running_transaction)
1625 tid = journal->j_running_transaction->t_tid;
1626 read_unlock(&journal->j_state_lock);
1627 return tid;
1628}
1629
1630#ifdef __KERNEL__
1631
1632#define buffer_trace_init(bh) do {} while (0)
1633#define print_buffer_fields(bh) do {} while (0)
1634#define print_buffer_trace(bh) do {} while (0)
1635#define BUFFER_TRACE(bh, info) do {} while (0)
1636#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1637#define JBUFFER_TRACE(jh, info) do {} while (0)
1638
1639#endif
1640
1641#define EFSBADCRC EBADMSG
1642#define EFSCORRUPTED EUCLEAN
1643
1644#endif
1645