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_JournalHead,
317 BH_Shadow,
318 BH_Verified,
319 BH_JBDPrivateStart,
320};
321
322BUFFER_FNS(JBD, jbd)
323BUFFER_FNS(JWrite, jwrite)
324BUFFER_FNS(JBDDirty, jbddirty)
325TAS_BUFFER_FNS(JBDDirty, jbddirty)
326BUFFER_FNS(Revoked, revoked)
327TAS_BUFFER_FNS(Revoked, revoked)
328BUFFER_FNS(RevokeValid, revokevalid)
329TAS_BUFFER_FNS(RevokeValid, revokevalid)
330BUFFER_FNS(Freed, freed)
331BUFFER_FNS(Shadow, shadow)
332BUFFER_FNS(Verified, verified)
333
334static inline struct buffer_head *jh2bh(struct journal_head *jh)
335{
336 return jh->b_bh;
337}
338
339static inline struct journal_head *bh2jh(struct buffer_head *bh)
340{
341 return bh->b_private;
342}
343
344static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
345{
346 bit_spin_lock(BH_JournalHead, &bh->b_state);
347}
348
349static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
350{
351 bit_spin_unlock(BH_JournalHead, &bh->b_state);
352}
353
354#define J_ASSERT(assert) BUG_ON(!(assert))
355
356#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
357#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
358
359#if defined(JBD2_PARANOID_IOFAIL)
360#define J_EXPECT(expr, why...) J_ASSERT(expr)
361#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
362#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
363#else
364#define __journal_expect(expr, why...) \
365 ({ \
366 int val = (expr); \
367 if (!val) { \
368 printk(KERN_ERR \
369 "JBD2 unexpected failure: %s: %s;\n", \
370 __func__, #expr); \
371 printk(KERN_ERR why "\n"); \
372 } \
373 val; \
374 })
375#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
376#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
377#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
378#endif
379
380
381#define __JI_COMMIT_RUNNING 0
382#define __JI_WRITE_DATA 1
383#define __JI_WAIT_DATA 2
384
385
386
387
388
389
390#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
391
392#define JI_WRITE_DATA (1 << __JI_WRITE_DATA)
393
394#define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
395
396
397
398
399
400struct jbd2_inode {
401
402
403
404
405
406
407 transaction_t *i_transaction;
408
409
410
411
412
413
414
415 transaction_t *i_next_transaction;
416
417
418
419
420 struct list_head i_list;
421
422
423
424
425
426
427 struct inode *i_vfs_inode;
428
429
430
431
432 unsigned long i_flags;
433
434
435
436
437
438
439
440 loff_t i_dirty_start;
441
442
443
444
445
446
447
448 loff_t i_dirty_end;
449};
450
451struct jbd2_revoke_table_s;
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
478
479
480struct jbd2_journal_handle
481{
482 union {
483 transaction_t *h_transaction;
484
485 journal_t *h_journal;
486 };
487
488 handle_t *h_rsv_handle;
489 int h_total_credits;
490 int h_revoke_credits;
491 int h_revoke_credits_requested;
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
672
673 atomic_t t_outstanding_credits;
674
675
676
677
678
679 atomic_t t_outstanding_revokes;
680
681
682
683
684 atomic_t t_handle_count;
685
686
687
688
689
690 transaction_t *t_cpnext, *t_cpprev;
691
692
693
694
695
696 unsigned long t_expires;
697
698
699
700
701 ktime_t t_start_time;
702
703
704
705
706
707 unsigned int t_synchronous_commit:1;
708
709
710 int t_need_data_flush;
711
712
713
714
715
716 struct list_head t_private_list;
717};
718
719struct transaction_run_stats_s {
720 unsigned long rs_wait;
721 unsigned long rs_request_delay;
722 unsigned long rs_running;
723 unsigned long rs_locked;
724 unsigned long rs_flushing;
725 unsigned long rs_logging;
726
727 __u32 rs_handle_count;
728 __u32 rs_blocks;
729 __u32 rs_blocks_logged;
730};
731
732struct transaction_stats_s {
733 unsigned long ts_tid;
734 unsigned long ts_requested;
735 struct transaction_run_stats_s run;
736};
737
738static inline unsigned long
739jbd2_time_diff(unsigned long start, unsigned long end)
740{
741 if (end >= start)
742 return end - start;
743
744 return end + (MAX_JIFFY_OFFSET - start);
745}
746
747#define JBD2_NR_BATCH 64
748
749
750
751
752
753struct journal_s
754{
755
756
757
758 unsigned long j_flags;
759
760
761
762
763
764
765
766 int j_errno;
767
768
769
770
771 struct buffer_head *j_sb_buffer;
772
773
774
775
776 journal_superblock_t *j_superblock;
777
778
779
780
781 int j_format_version;
782
783
784
785
786 rwlock_t j_state_lock;
787
788
789
790
791
792
793 int j_barrier_count;
794
795
796
797
798 struct mutex j_barrier;
799
800
801
802
803
804
805
806 transaction_t *j_running_transaction;
807
808
809
810
811
812
813
814 transaction_t *j_committing_transaction;
815
816
817
818
819
820
821
822 transaction_t *j_checkpoint_transactions;
823
824
825
826
827
828
829
830 wait_queue_head_t j_wait_transaction_locked;
831
832
833
834
835 wait_queue_head_t j_wait_done_commit;
836
837
838
839
840 wait_queue_head_t j_wait_commit;
841
842
843
844
845 wait_queue_head_t j_wait_updates;
846
847
848
849
850
851
852 wait_queue_head_t j_wait_reserved;
853
854
855
856
857
858
859 struct mutex j_checkpoint_mutex;
860
861
862
863
864
865
866
867
868
869 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
870
871
872
873
874
875
876
877 unsigned long j_head;
878
879
880
881
882
883
884
885 unsigned long j_tail;
886
887
888
889
890
891
892
893 unsigned long j_free;
894
895
896
897
898
899
900
901 unsigned long j_first;
902
903
904
905
906
907
908
909 unsigned long j_last;
910
911
912
913
914 struct block_device *j_dev;
915
916
917
918
919 int j_blocksize;
920
921
922
923
924
925
926 unsigned long long j_blk_offset;
927
928
929
930
931 char j_devname[BDEVNAME_SIZE+24];
932
933
934
935
936
937
938
939 struct block_device *j_fs_dev;
940
941
942
943
944 unsigned int j_maxlen;
945
946
947
948
949
950
951 atomic_t j_reserved_credits;
952
953
954
955
956 spinlock_t j_list_lock;
957
958
959
960
961
962
963
964 struct inode *j_inode;
965
966
967
968
969
970
971 tid_t j_tail_sequence;
972
973
974
975
976
977
978 tid_t j_transaction_sequence;
979
980
981
982
983
984
985
986 tid_t j_commit_sequence;
987
988
989
990
991
992
993
994 tid_t j_commit_request;
995
996
997
998
999
1000
1001
1002
1003
1004 __u8 j_uuid[16];
1005
1006
1007
1008
1009 struct task_struct *j_task;
1010
1011
1012
1013
1014
1015
1016
1017 int j_max_transaction_buffers;
1018
1019
1020
1021
1022
1023
1024 int j_revoke_records_per_block;
1025
1026
1027
1028
1029
1030
1031 unsigned long j_commit_interval;
1032
1033
1034
1035
1036 struct timer_list j_commit_timer;
1037
1038
1039
1040
1041 spinlock_t j_revoke_lock;
1042
1043
1044
1045
1046
1047
1048
1049 struct jbd2_revoke_table_s *j_revoke;
1050
1051
1052
1053
1054 struct jbd2_revoke_table_s *j_revoke_table[2];
1055
1056
1057
1058
1059 struct buffer_head **j_wbuf;
1060
1061
1062
1063
1064
1065
1066 int j_wbufsize;
1067
1068
1069
1070
1071
1072
1073
1074 pid_t j_last_sync_writer;
1075
1076
1077
1078
1079
1080
1081
1082 u64 j_average_commit_time;
1083
1084
1085
1086
1087
1088
1089
1090 u32 j_min_batch_time;
1091
1092
1093
1094
1095
1096
1097
1098 u32 j_max_batch_time;
1099
1100
1101
1102
1103
1104
1105 void (*j_commit_callback)(journal_t *,
1106 transaction_t *);
1107
1108
1109
1110
1111
1112
1113
1114
1115 spinlock_t j_history_lock;
1116
1117
1118
1119
1120 struct proc_dir_entry *j_proc_entry;
1121
1122
1123
1124
1125 struct transaction_stats_s j_stats;
1126
1127
1128
1129
1130 unsigned int j_failed_commit;
1131
1132
1133
1134
1135
1136
1137
1138 void *j_private;
1139
1140
1141
1142
1143
1144
1145 struct crypto_shash *j_chksum_driver;
1146
1147
1148
1149
1150
1151
1152 __u32 j_csum_seed;
1153
1154#ifdef CONFIG_DEBUG_LOCK_ALLOC
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165 struct lockdep_map j_trans_commit_map;
1166#endif
1167};
1168
1169#define jbd2_might_wait_for_commit(j) \
1170 do { \
1171 rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
1172 rwsem_release(&j->j_trans_commit_map, _THIS_IP_); \
1173 } while (0)
1174
1175
1176#define JBD2_FEATURE_COMPAT_FUNCS(name, flagname) \
1177static inline bool jbd2_has_feature_##name(journal_t *j) \
1178{ \
1179 return ((j)->j_format_version >= 2 && \
1180 ((j)->j_superblock->s_feature_compat & \
1181 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname)) != 0); \
1182} \
1183static inline void jbd2_set_feature_##name(journal_t *j) \
1184{ \
1185 (j)->j_superblock->s_feature_compat |= \
1186 cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1187} \
1188static inline void jbd2_clear_feature_##name(journal_t *j) \
1189{ \
1190 (j)->j_superblock->s_feature_compat &= \
1191 ~cpu_to_be32(JBD2_FEATURE_COMPAT_##flagname); \
1192}
1193
1194#define JBD2_FEATURE_RO_COMPAT_FUNCS(name, flagname) \
1195static inline bool jbd2_has_feature_##name(journal_t *j) \
1196{ \
1197 return ((j)->j_format_version >= 2 && \
1198 ((j)->j_superblock->s_feature_ro_compat & \
1199 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname)) != 0); \
1200} \
1201static inline void jbd2_set_feature_##name(journal_t *j) \
1202{ \
1203 (j)->j_superblock->s_feature_ro_compat |= \
1204 cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1205} \
1206static inline void jbd2_clear_feature_##name(journal_t *j) \
1207{ \
1208 (j)->j_superblock->s_feature_ro_compat &= \
1209 ~cpu_to_be32(JBD2_FEATURE_RO_COMPAT_##flagname); \
1210}
1211
1212#define JBD2_FEATURE_INCOMPAT_FUNCS(name, flagname) \
1213static inline bool jbd2_has_feature_##name(journal_t *j) \
1214{ \
1215 return ((j)->j_format_version >= 2 && \
1216 ((j)->j_superblock->s_feature_incompat & \
1217 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname)) != 0); \
1218} \
1219static inline void jbd2_set_feature_##name(journal_t *j) \
1220{ \
1221 (j)->j_superblock->s_feature_incompat |= \
1222 cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1223} \
1224static inline void jbd2_clear_feature_##name(journal_t *j) \
1225{ \
1226 (j)->j_superblock->s_feature_incompat &= \
1227 ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_##flagname); \
1228}
1229
1230JBD2_FEATURE_COMPAT_FUNCS(checksum, CHECKSUM)
1231
1232JBD2_FEATURE_INCOMPAT_FUNCS(revoke, REVOKE)
1233JBD2_FEATURE_INCOMPAT_FUNCS(64bit, 64BIT)
1234JBD2_FEATURE_INCOMPAT_FUNCS(async_commit, ASYNC_COMMIT)
1235JBD2_FEATURE_INCOMPAT_FUNCS(csum2, CSUM_V2)
1236JBD2_FEATURE_INCOMPAT_FUNCS(csum3, CSUM_V3)
1237
1238
1239
1240
1241#define JBD2_UNMOUNT 0x001
1242#define JBD2_ABORT 0x002
1243#define JBD2_ACK_ERR 0x004
1244#define JBD2_FLUSHED 0x008
1245#define JBD2_LOADED 0x010
1246#define JBD2_BARRIER 0x020
1247#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040
1248
1249
1250#define JBD2_REC_ERR 0x080
1251
1252
1253
1254
1255
1256
1257
1258extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
1259extern bool __jbd2_journal_refile_buffer(struct journal_head *);
1260extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1261extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1262extern void __journal_free_buffer(struct journal_head *bh);
1263extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1264extern void __journal_clean_data_list(transaction_t *transaction);
1265static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
1266{
1267 list_add_tail(&bh->b_assoc_buffers, head);
1268}
1269static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
1270{
1271 list_del_init(&bh->b_assoc_buffers);
1272}
1273
1274
1275struct buffer_head *jbd2_journal_get_descriptor_buffer(transaction_t *, int);
1276void jbd2_descriptor_block_csum_set(journal_t *, struct buffer_head *);
1277int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
1278int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
1279 unsigned long *block);
1280int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1281void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
1282
1283
1284extern void jbd2_journal_commit_transaction(journal_t *);
1285
1286
1287void __jbd2_journal_clean_checkpoint_list(journal_t *journal, bool destroy);
1288int __jbd2_journal_remove_checkpoint(struct journal_head *);
1289void jbd2_journal_destroy_checkpoint(journal_t *journal);
1290void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
1291
1292
1293
1294
1295
1296
1297struct jbd2_buffer_trigger_type {
1298
1299
1300
1301
1302
1303
1304 void (*t_frozen)(struct jbd2_buffer_trigger_type *type,
1305 struct buffer_head *bh, void *mapped_data,
1306 size_t size);
1307
1308
1309
1310
1311
1312 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1313 struct buffer_head *bh);
1314};
1315
1316extern void jbd2_buffer_frozen_trigger(struct journal_head *jh,
1317 void *mapped_data,
1318 struct jbd2_buffer_trigger_type *triggers);
1319extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1320 struct jbd2_buffer_trigger_type *triggers);
1321
1322
1323extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1324 struct journal_head *jh_in,
1325 struct buffer_head **bh_out,
1326 sector_t blocknr);
1327
1328
1329extern void __wait_on_journal (journal_t *);
1330
1331
1332extern void jbd2_journal_destroy_transaction_cache(void);
1333extern int __init jbd2_journal_init_transaction_cache(void);
1334extern void jbd2_journal_free_transaction(transaction_t *);
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347static inline handle_t *journal_current_handle(void)
1348{
1349 return current->journal_info;
1350}
1351
1352
1353
1354
1355
1356
1357
1358extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1359extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
1360 int revoke_records, gfp_t gfp_mask,
1361 unsigned int type, unsigned int line_no);
1362extern int jbd2_journal_restart(handle_t *, int nblocks);
1363extern int jbd2__journal_restart(handle_t *, int nblocks,
1364 int revoke_records, gfp_t gfp_mask);
1365extern int jbd2_journal_start_reserved(handle_t *handle,
1366 unsigned int type, unsigned int line_no);
1367extern void jbd2_journal_free_reserved(handle_t *handle);
1368extern int jbd2_journal_extend(handle_t *handle, int nblocks,
1369 int revoke_records);
1370extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1371extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1372extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1373void jbd2_journal_set_triggers(struct buffer_head *,
1374 struct jbd2_buffer_trigger_type *type);
1375extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1376extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1377extern int jbd2_journal_invalidatepage(journal_t *,
1378 struct page *, unsigned int, unsigned int);
1379extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1380extern int jbd2_journal_stop(handle_t *);
1381extern int jbd2_journal_flush (journal_t *);
1382extern void jbd2_journal_lock_updates (journal_t *);
1383extern void jbd2_journal_unlock_updates (journal_t *);
1384
1385extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1386 struct block_device *fs_dev,
1387 unsigned long long start, int len, int bsize);
1388extern journal_t * jbd2_journal_init_inode (struct inode *);
1389extern int jbd2_journal_update_format (journal_t *);
1390extern int jbd2_journal_check_used_features
1391 (journal_t *, unsigned long, unsigned long, unsigned long);
1392extern int jbd2_journal_check_available_features
1393 (journal_t *, unsigned long, unsigned long, unsigned long);
1394extern int jbd2_journal_set_features
1395 (journal_t *, unsigned long, unsigned long, unsigned long);
1396extern void jbd2_journal_clear_features
1397 (journal_t *, unsigned long, unsigned long, unsigned long);
1398extern int jbd2_journal_load (journal_t *journal);
1399extern int jbd2_journal_destroy (journal_t *);
1400extern int jbd2_journal_recover (journal_t *journal);
1401extern int jbd2_journal_wipe (journal_t *, int);
1402extern int jbd2_journal_skip_recovery (journal_t *);
1403extern void jbd2_journal_update_sb_errno(journal_t *);
1404extern int jbd2_journal_update_sb_log_tail (journal_t *, tid_t,
1405 unsigned long, int);
1406extern void __jbd2_journal_abort_hard (journal_t *);
1407extern void jbd2_journal_abort (journal_t *, int);
1408extern int jbd2_journal_errno (journal_t *);
1409extern void jbd2_journal_ack_err (journal_t *);
1410extern int jbd2_journal_clear_err (journal_t *);
1411extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1412extern int jbd2_journal_force_commit(journal_t *);
1413extern int jbd2_journal_force_commit_nested(journal_t *);
1414extern int jbd2_journal_inode_ranged_write(handle_t *handle,
1415 struct jbd2_inode *inode, loff_t start_byte,
1416 loff_t length);
1417extern int jbd2_journal_inode_ranged_wait(handle_t *handle,
1418 struct jbd2_inode *inode, loff_t start_byte,
1419 loff_t length);
1420extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1421 struct jbd2_inode *inode, loff_t new_size);
1422extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1423extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1424
1425
1426
1427
1428struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1429struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1430void jbd2_journal_put_journal_head(struct journal_head *jh);
1431
1432
1433
1434
1435extern struct kmem_cache *jbd2_handle_cache;
1436
1437static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1438{
1439 return kmem_cache_zalloc(jbd2_handle_cache, gfp_flags);
1440}
1441
1442static inline void jbd2_free_handle(handle_t *handle)
1443{
1444 kmem_cache_free(jbd2_handle_cache, handle);
1445}
1446
1447
1448
1449
1450
1451extern struct kmem_cache *jbd2_inode_cache;
1452
1453static inline struct jbd2_inode *jbd2_alloc_inode(gfp_t gfp_flags)
1454{
1455 return kmem_cache_alloc(jbd2_inode_cache, gfp_flags);
1456}
1457
1458static inline void jbd2_free_inode(struct jbd2_inode *jinode)
1459{
1460 kmem_cache_free(jbd2_inode_cache, jinode);
1461}
1462
1463
1464#define JOURNAL_REVOKE_DEFAULT_HASH 256
1465extern int jbd2_journal_init_revoke(journal_t *, int);
1466extern void jbd2_journal_destroy_revoke_record_cache(void);
1467extern void jbd2_journal_destroy_revoke_table_cache(void);
1468extern int __init jbd2_journal_init_revoke_record_cache(void);
1469extern int __init jbd2_journal_init_revoke_table_cache(void);
1470
1471extern void jbd2_journal_destroy_revoke(journal_t *);
1472extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1473extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1474extern void jbd2_journal_write_revoke_records(transaction_t *transaction,
1475 struct list_head *log_bufs);
1476
1477
1478extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1479extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1480extern void jbd2_journal_clear_revoke(journal_t *);
1481extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1482extern void jbd2_clear_buffer_revoked_flags(journal_t *journal);
1483
1484
1485
1486
1487
1488
1489
1490
1491int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1492int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1493int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1494int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1495int jbd2_transaction_committed(journal_t *journal, tid_t tid);
1496int jbd2_complete_transaction(journal_t *journal, tid_t tid);
1497int jbd2_log_do_checkpoint(journal_t *journal);
1498int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid);
1499
1500void __jbd2_log_wait_for_space(journal_t *journal);
1501extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1502extern int jbd2_cleanup_journal_tail(journal_t *);
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514static inline int is_journal_aborted(journal_t *journal)
1515{
1516 return journal->j_flags & JBD2_ABORT;
1517}
1518
1519static inline int is_handle_aborted(handle_t *handle)
1520{
1521 if (handle->h_aborted || !handle->h_transaction)
1522 return 1;
1523 return is_journal_aborted(handle->h_transaction->t_journal);
1524}
1525
1526static inline void jbd2_journal_abort_handle(handle_t *handle)
1527{
1528 handle->h_aborted = 1;
1529}
1530
1531#endif
1532
1533
1534
1535
1536static inline int tid_gt(tid_t x, tid_t y)
1537{
1538 int difference = (x - y);
1539 return (difference > 0);
1540}
1541
1542static inline int tid_geq(tid_t x, tid_t y)
1543{
1544 int difference = (x - y);
1545 return (difference >= 0);
1546}
1547
1548extern int jbd2_journal_blocks_per_page(struct inode *inode);
1549extern size_t journal_tag_bytes(journal_t *journal);
1550
1551static inline bool jbd2_journal_has_csum_v2or3_feature(journal_t *j)
1552{
1553 return jbd2_has_feature_csum2(j) || jbd2_has_feature_csum3(j);
1554}
1555
1556static inline int jbd2_journal_has_csum_v2or3(journal_t *journal)
1557{
1558 WARN_ON_ONCE(jbd2_journal_has_csum_v2or3_feature(journal) &&
1559 journal->j_chksum_driver == NULL);
1560
1561 return journal->j_chksum_driver != NULL;
1562}
1563
1564
1565
1566
1567static inline unsigned long jbd2_log_space_left(journal_t *journal)
1568{
1569
1570 long free = journal->j_free - 32;
1571
1572 if (journal->j_committing_transaction) {
1573 free -= atomic_read(&journal->
1574 j_committing_transaction->t_outstanding_credits);
1575 }
1576 return max_t(long, free, 0);
1577}
1578
1579
1580
1581
1582
1583
1584#define BJ_None 0
1585#define BJ_Metadata 1
1586#define BJ_Forget 2
1587#define BJ_Shadow 3
1588#define BJ_Reserved 4
1589#define BJ_Types 5
1590
1591extern int jbd_blocks_per_page(struct inode *inode);
1592
1593
1594#define JBD_MAX_CHECKSUM_SIZE 4
1595
1596static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
1597 const void *address, unsigned int length)
1598{
1599 struct {
1600 struct shash_desc shash;
1601 char ctx[JBD_MAX_CHECKSUM_SIZE];
1602 } desc;
1603 int err;
1604
1605 BUG_ON(crypto_shash_descsize(journal->j_chksum_driver) >
1606 JBD_MAX_CHECKSUM_SIZE);
1607
1608 desc.shash.tfm = journal->j_chksum_driver;
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
1630static inline int jbd2_handle_buffer_credits(handle_t *handle)
1631{
1632 journal_t *journal;
1633
1634 if (!handle->h_reserved)
1635 journal = handle->h_transaction->t_journal;
1636 else
1637 journal = handle->h_journal;
1638
1639 return handle->h_total_credits -
1640 DIV_ROUND_UP(handle->h_revoke_credits_requested,
1641 journal->j_revoke_records_per_block);
1642}
1643
1644#ifdef __KERNEL__
1645
1646#define buffer_trace_init(bh) do {} while (0)
1647#define print_buffer_fields(bh) do {} while (0)
1648#define print_buffer_trace(bh) do {} while (0)
1649#define BUFFER_TRACE(bh, info) do {} while (0)
1650#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1651#define JBUFFER_TRACE(jh, info) do {} while (0)
1652
1653#endif
1654
1655#define EFSBADCRC EBADMSG
1656#define EFSCORRUPTED EUCLEAN
1657
1658#endif
1659