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