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