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