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