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#define jfs_debug jbd_debug
24#else
25
26#include <linux/types.h>
27#include <linux/buffer_head.h>
28#include <linux/journal-head.h>
29#include <linux/stddef.h>
30#include <linux/bit_spinlock.h>
31#include <linux/mutex.h>
32#include <linux/timer.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 u8 jbd2_journal_enable_debug;
59
60#define jbd_debug(n, f, a...) \
61 do { \
62 if ((n) <= jbd2_journal_enable_debug) { \
63 printk (KERN_DEBUG "(%s, %d): %s: ", \
64 __FILE__, __LINE__, __func__); \
65 printk (f, ## a); \
66 } \
67 } while (0)
68#else
69#define jbd_debug(f, a...)
70#endif
71
72static inline void *jbd2_alloc(size_t size, gfp_t flags)
73{
74 return (void *)__get_free_pages(flags, get_order(size));
75}
76
77static inline void jbd2_free(void *ptr, size_t size)
78{
79 free_pages((unsigned long)ptr, get_order(size));
80};
81
82#define JBD2_MIN_JOURNAL_BLOCKS 1024
83
84#ifdef __KERNEL__
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103typedef struct handle_s handle_t;
104
105
106
107
108
109
110
111
112
113
114
115
116
117typedef struct journal_s journal_t;
118#endif
119
120
121
122
123
124#define JBD2_MAGIC_NUMBER 0xc03b3998U
125
126
127
128
129
130
131
132
133
134#define JBD2_DESCRIPTOR_BLOCK 1
135#define JBD2_COMMIT_BLOCK 2
136#define JBD2_SUPERBLOCK_V1 3
137#define JBD2_SUPERBLOCK_V2 4
138#define JBD2_REVOKE_BLOCK 5
139
140
141
142
143typedef struct journal_header_s
144{
145 __be32 h_magic;
146 __be32 h_blocktype;
147 __be32 h_sequence;
148} journal_header_t;
149
150
151
152
153#define JBD2_CRC32_CHKSUM 1
154#define JBD2_MD5_CHKSUM 2
155#define JBD2_SHA1_CHKSUM 3
156
157#define JBD2_CRC32_CHKSUM_SIZE 4
158
159#define JBD2_CHECKSUM_BYTES (32 / sizeof(u32))
160
161
162
163struct commit_header {
164 __be32 h_magic;
165 __be32 h_blocktype;
166 __be32 h_sequence;
167 unsigned char h_chksum_type;
168 unsigned char h_chksum_size;
169 unsigned char h_padding[2];
170 __be32 h_chksum[JBD2_CHECKSUM_BYTES];
171 __be64 h_commit_sec;
172 __be32 h_commit_nsec;
173};
174
175
176
177
178
179
180
181typedef struct journal_block_tag_s
182{
183 __be32 t_blocknr;
184 __be32 t_flags;
185 __be32 t_blocknr_high;
186} journal_block_tag_t;
187
188#define JBD2_TAG_SIZE32 (offsetof(journal_block_tag_t, t_blocknr_high))
189#define JBD2_TAG_SIZE64 (sizeof(journal_block_tag_t))
190
191
192
193
194
195typedef struct jbd2_journal_revoke_header_s
196{
197 journal_header_t r_header;
198 __be32 r_count;
199} jbd2_journal_revoke_header_t;
200
201
202
203#define JBD2_FLAG_ESCAPE 1
204#define JBD2_FLAG_SAME_UUID 2
205#define JBD2_FLAG_DELETED 4
206#define JBD2_FLAG_LAST_TAG 8
207
208
209
210
211
212typedef struct journal_superblock_s
213{
214
215 journal_header_t s_header;
216
217
218
219 __be32 s_blocksize;
220 __be32 s_maxlen;
221 __be32 s_first;
222
223
224
225 __be32 s_sequence;
226 __be32 s_start;
227
228
229
230 __be32 s_errno;
231
232
233
234 __be32 s_feature_compat;
235 __be32 s_feature_incompat;
236 __be32 s_feature_ro_compat;
237
238 __u8 s_uuid[16];
239
240
241 __be32 s_nr_users;
242
243 __be32 s_dynsuper;
244
245
246 __be32 s_max_transaction;
247 __be32 s_max_trans_data;
248
249
250 __u32 s_padding[44];
251
252
253 __u8 s_users[16*48];
254
255} journal_superblock_t;
256
257#define JBD2_HAS_COMPAT_FEATURE(j,mask) \
258 ((j)->j_format_version >= 2 && \
259 ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
260#define JBD2_HAS_RO_COMPAT_FEATURE(j,mask) \
261 ((j)->j_format_version >= 2 && \
262 ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
263#define JBD2_HAS_INCOMPAT_FEATURE(j,mask) \
264 ((j)->j_format_version >= 2 && \
265 ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
266
267#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001
268
269#define JBD2_FEATURE_INCOMPAT_REVOKE 0x00000001
270#define JBD2_FEATURE_INCOMPAT_64BIT 0x00000002
271#define JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT 0x00000004
272
273
274#define JBD2_KNOWN_COMPAT_FEATURES JBD2_FEATURE_COMPAT_CHECKSUM
275#define JBD2_KNOWN_ROCOMPAT_FEATURES 0
276#define JBD2_KNOWN_INCOMPAT_FEATURES (JBD2_FEATURE_INCOMPAT_REVOKE | \
277 JBD2_FEATURE_INCOMPAT_64BIT | \
278 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)
279
280#ifdef __KERNEL__
281
282#include <linux/fs.h>
283#include <linux/sched.h>
284
285#define J_ASSERT(assert) BUG_ON(!(assert))
286
287#if defined(CONFIG_BUFFER_DEBUG)
288void buffer_assertion_failure(struct buffer_head *bh);
289#define J_ASSERT_BH(bh, expr) \
290 do { \
291 if (!(expr)) \
292 buffer_assertion_failure(bh); \
293 J_ASSERT(expr); \
294 } while (0)
295#define J_ASSERT_JH(jh, expr) J_ASSERT_BH(jh2bh(jh), expr)
296#else
297#define J_ASSERT_BH(bh, expr) J_ASSERT(expr)
298#define J_ASSERT_JH(jh, expr) J_ASSERT(expr)
299#endif
300
301#if defined(JBD2_PARANOID_IOFAIL)
302#define J_EXPECT(expr, why...) J_ASSERT(expr)
303#define J_EXPECT_BH(bh, expr, why...) J_ASSERT_BH(bh, expr)
304#define J_EXPECT_JH(jh, expr, why...) J_ASSERT_JH(jh, expr)
305#else
306#define __journal_expect(expr, why...) \
307 ({ \
308 int val = (expr); \
309 if (!val) { \
310 printk(KERN_ERR \
311 "JBD2 unexpected failure: %s: %s;\n", \
312 __func__, #expr); \
313 printk(KERN_ERR why "\n"); \
314 } \
315 val; \
316 })
317#define J_EXPECT(expr, why...) __journal_expect(expr, ## why)
318#define J_EXPECT_BH(bh, expr, why...) __journal_expect(expr, ## why)
319#define J_EXPECT_JH(jh, expr, why...) __journal_expect(expr, ## why)
320#endif
321
322enum jbd_state_bits {
323 BH_JBD
324 = BH_PrivateStart,
325 BH_JWrite,
326 BH_Freed,
327 BH_Revoked,
328 BH_RevokeValid,
329 BH_JBDDirty,
330 BH_State,
331 BH_JournalHead,
332 BH_Unshadow,
333 BH_JBDPrivateStart,
334};
335
336BUFFER_FNS(JBD, jbd)
337BUFFER_FNS(JWrite, jwrite)
338BUFFER_FNS(JBDDirty, jbddirty)
339TAS_BUFFER_FNS(JBDDirty, jbddirty)
340BUFFER_FNS(Revoked, revoked)
341TAS_BUFFER_FNS(Revoked, revoked)
342BUFFER_FNS(RevokeValid, revokevalid)
343TAS_BUFFER_FNS(RevokeValid, revokevalid)
344BUFFER_FNS(Freed, freed)
345
346static inline struct buffer_head *jh2bh(struct journal_head *jh)
347{
348 return jh->b_bh;
349}
350
351static inline struct journal_head *bh2jh(struct buffer_head *bh)
352{
353 return bh->b_private;
354}
355
356static inline void jbd_lock_bh_state(struct buffer_head *bh)
357{
358 bit_spin_lock(BH_State, &bh->b_state);
359}
360
361static inline int jbd_trylock_bh_state(struct buffer_head *bh)
362{
363 return bit_spin_trylock(BH_State, &bh->b_state);
364}
365
366static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
367{
368 return bit_spin_is_locked(BH_State, &bh->b_state);
369}
370
371static inline void jbd_unlock_bh_state(struct buffer_head *bh)
372{
373 bit_spin_unlock(BH_State, &bh->b_state);
374}
375
376static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
377{
378 bit_spin_lock(BH_JournalHead, &bh->b_state);
379}
380
381static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
382{
383 bit_spin_unlock(BH_JournalHead, &bh->b_state);
384}
385
386
387#define __JI_COMMIT_RUNNING 0
388
389
390
391
392#define JI_COMMIT_RUNNING (1 << __JI_COMMIT_RUNNING)
393
394
395
396
397
398struct jbd2_inode {
399
400
401 transaction_t *i_transaction;
402
403
404
405 transaction_t *i_next_transaction;
406
407
408 struct list_head i_list;
409
410
411
412 struct inode *i_vfs_inode;
413
414
415 unsigned int i_flags;
416};
417
418struct jbd2_revoke_table_s;
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436struct handle_s
437{
438
439 transaction_t *h_transaction;
440
441
442 int h_buffer_credits;
443
444
445 int h_ref;
446
447
448
449 int h_err;
450
451
452 unsigned int h_sync: 1;
453 unsigned int h_jdata: 1;
454 unsigned int h_aborted: 1;
455
456#ifdef CONFIG_DEBUG_LOCK_ALLOC
457 struct lockdep_map h_lockdep_map;
458#endif
459};
460
461
462
463
464
465struct transaction_chp_stats_s {
466 unsigned long cs_chp_time;
467 __u32 cs_forced_to_close;
468 __u32 cs_written;
469 __u32 cs_dropped;
470};
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508struct transaction_s
509{
510
511 journal_t *t_journal;
512
513
514 tid_t t_tid;
515
516
517
518
519
520
521
522
523
524 enum {
525 T_RUNNING,
526 T_LOCKED,
527 T_RUNDOWN,
528 T_FLUSH,
529 T_COMMIT,
530 T_FINISHED
531 } t_state;
532
533
534
535
536 unsigned long t_log_start;
537
538
539 int t_nr_buffers;
540
541
542
543
544
545 struct journal_head *t_reserved_list;
546
547
548
549
550
551 struct journal_head *t_buffers;
552
553
554
555
556
557
558 struct journal_head *t_forget;
559
560
561
562
563
564 struct journal_head *t_checkpoint_list;
565
566
567
568
569
570 struct journal_head *t_checkpoint_io_list;
571
572
573
574
575
576 struct journal_head *t_iobuf_list;
577
578
579
580
581
582
583 struct journal_head *t_shadow_list;
584
585
586
587
588
589 struct journal_head *t_log_list;
590
591
592
593
594
595 struct list_head t_inode_list;
596
597
598
599
600 spinlock_t t_handle_lock;
601
602
603
604
605 unsigned long t_max_wait;
606
607
608
609
610 unsigned long t_start;
611
612
613
614
615 struct transaction_chp_stats_s t_chp_stats;
616
617
618
619
620
621 int t_updates;
622
623
624
625
626
627 int t_outstanding_credits;
628
629
630
631
632
633 transaction_t *t_cpnext, *t_cpprev;
634
635
636
637
638
639 unsigned long t_expires;
640
641
642
643
644 ktime_t t_start_time;
645
646
647
648
649 int t_handle_count;
650
651
652
653
654
655 unsigned int t_synchronous_commit:1;
656
657
658
659
660
661 struct list_head t_private_list;
662};
663
664struct transaction_run_stats_s {
665 unsigned long rs_wait;
666 unsigned long rs_running;
667 unsigned long rs_locked;
668 unsigned long rs_flushing;
669 unsigned long rs_logging;
670
671 __u32 rs_handle_count;
672 __u32 rs_blocks;
673 __u32 rs_blocks_logged;
674};
675
676struct transaction_stats_s {
677 unsigned long ts_tid;
678 struct transaction_run_stats_s run;
679};
680
681static inline unsigned long
682jbd2_time_diff(unsigned long start, unsigned long end)
683{
684 if (end >= start)
685 return end - start;
686
687 return end + (MAX_JIFFY_OFFSET - start);
688}
689
690#define JBD2_NR_BATCH 64
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
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762struct journal_s
763{
764
765 unsigned long j_flags;
766
767
768
769
770
771 int j_errno;
772
773
774 struct buffer_head *j_sb_buffer;
775 journal_superblock_t *j_superblock;
776
777
778 int j_format_version;
779
780
781
782
783 spinlock_t j_state_lock;
784
785
786
787
788 int j_barrier_count;
789
790
791 struct mutex j_barrier;
792
793
794
795
796
797 transaction_t *j_running_transaction;
798
799
800
801
802
803 transaction_t *j_committing_transaction;
804
805
806
807
808
809 transaction_t *j_checkpoint_transactions;
810
811
812
813
814
815 wait_queue_head_t j_wait_transaction_locked;
816
817
818 wait_queue_head_t j_wait_logspace;
819
820
821 wait_queue_head_t j_wait_done_commit;
822
823
824 wait_queue_head_t j_wait_checkpoint;
825
826
827 wait_queue_head_t j_wait_commit;
828
829
830 wait_queue_head_t j_wait_updates;
831
832
833 struct mutex j_checkpoint_mutex;
834
835
836
837
838
839
840
841 struct buffer_head *j_chkpt_bhs[JBD2_NR_BATCH];
842
843
844
845
846
847 unsigned long j_head;
848
849
850
851
852
853 unsigned long j_tail;
854
855
856
857
858
859 unsigned long j_free;
860
861
862
863
864
865 unsigned long j_first;
866 unsigned long j_last;
867
868
869
870
871
872 struct block_device *j_dev;
873 int j_blocksize;
874 unsigned long long j_blk_offset;
875 char j_devname[BDEVNAME_SIZE+24];
876
877
878
879
880
881 struct block_device *j_fs_dev;
882
883
884 unsigned int j_maxlen;
885
886
887
888
889 spinlock_t j_list_lock;
890
891
892
893
894 struct inode *j_inode;
895
896
897
898
899 tid_t j_tail_sequence;
900
901
902
903
904 tid_t j_transaction_sequence;
905
906
907
908
909
910 tid_t j_commit_sequence;
911
912
913
914
915
916 tid_t j_commit_request;
917
918
919
920
921
922
923
924 __u8 j_uuid[16];
925
926
927 struct task_struct *j_task;
928
929
930
931
932
933 int j_max_transaction_buffers;
934
935
936
937
938 unsigned long j_commit_interval;
939
940
941 struct timer_list j_commit_timer;
942
943
944
945
946
947 spinlock_t j_revoke_lock;
948 struct jbd2_revoke_table_s *j_revoke;
949 struct jbd2_revoke_table_s *j_revoke_table[2];
950
951
952
953
954 struct buffer_head **j_wbuf;
955 int j_wbufsize;
956
957
958
959
960
961 pid_t j_last_sync_writer;
962
963
964
965
966
967 u64 j_average_commit_time;
968
969
970
971
972
973
974 u32 j_min_batch_time;
975 u32 j_max_batch_time;
976
977
978 void (*j_commit_callback)(journal_t *,
979 transaction_t *);
980
981
982
983
984 spinlock_t j_history_lock;
985 struct proc_dir_entry *j_proc_entry;
986 struct transaction_stats_s j_stats;
987
988
989 unsigned int j_failed_commit;
990
991
992
993
994
995 void *j_private;
996};
997
998
999
1000
1001#define JBD2_UNMOUNT 0x001
1002#define JBD2_ABORT 0x002
1003#define JBD2_ACK_ERR 0x004
1004#define JBD2_FLUSHED 0x008
1005#define JBD2_LOADED 0x010
1006#define JBD2_BARRIER 0x020
1007#define JBD2_ABORT_ON_SYNCDATA_ERR 0x040
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
1018extern void __jbd2_journal_unfile_buffer(struct journal_head *);
1019extern void __jbd2_journal_refile_buffer(struct journal_head *);
1020extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
1021extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1022extern void __journal_free_buffer(struct journal_head *bh);
1023extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
1024extern void __journal_clean_data_list(transaction_t *transaction);
1025
1026
1027extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
1028int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
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 void (*t_commit)(struct jbd2_buffer_trigger_type *type,
1050 struct buffer_head *bh, void *mapped_data,
1051 size_t size);
1052
1053
1054
1055
1056
1057 void (*t_abort)(struct jbd2_buffer_trigger_type *type,
1058 struct buffer_head *bh);
1059};
1060
1061extern void jbd2_buffer_commit_trigger(struct journal_head *jh,
1062 void *mapped_data,
1063 struct jbd2_buffer_trigger_type *triggers);
1064extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
1065 struct jbd2_buffer_trigger_type *triggers);
1066
1067
1068extern int
1069jbd2_journal_write_metadata_buffer(transaction_t *transaction,
1070 struct journal_head *jh_in,
1071 struct journal_head **jh_out,
1072 unsigned long long blocknr);
1073
1074
1075extern void __wait_on_journal (journal_t *);
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088static inline handle_t *journal_current_handle(void)
1089{
1090 return current->journal_info;
1091}
1092
1093
1094
1095
1096
1097
1098
1099extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
1100extern int jbd2_journal_restart (handle_t *, int nblocks);
1101extern int jbd2_journal_extend (handle_t *, int nblocks);
1102extern int jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
1103extern int jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
1104extern int jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
1105void jbd2_journal_set_triggers(struct buffer_head *,
1106 struct jbd2_buffer_trigger_type *type);
1107extern int jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
1108extern void jbd2_journal_release_buffer (handle_t *, struct buffer_head *);
1109extern int jbd2_journal_forget (handle_t *, struct buffer_head *);
1110extern void journal_sync_buffer (struct buffer_head *);
1111extern void jbd2_journal_invalidatepage(journal_t *,
1112 struct page *, unsigned long);
1113extern int jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
1114extern int jbd2_journal_stop(handle_t *);
1115extern int jbd2_journal_flush (journal_t *);
1116extern void jbd2_journal_lock_updates (journal_t *);
1117extern void jbd2_journal_unlock_updates (journal_t *);
1118
1119extern journal_t * jbd2_journal_init_dev(struct block_device *bdev,
1120 struct block_device *fs_dev,
1121 unsigned long long start, int len, int bsize);
1122extern journal_t * jbd2_journal_init_inode (struct inode *);
1123extern int jbd2_journal_update_format (journal_t *);
1124extern int jbd2_journal_check_used_features
1125 (journal_t *, unsigned long, unsigned long, unsigned long);
1126extern int jbd2_journal_check_available_features
1127 (journal_t *, unsigned long, unsigned long, unsigned long);
1128extern int jbd2_journal_set_features
1129 (journal_t *, unsigned long, unsigned long, unsigned long);
1130extern void jbd2_journal_clear_features
1131 (journal_t *, unsigned long, unsigned long, unsigned long);
1132extern int jbd2_journal_load (journal_t *journal);
1133extern int jbd2_journal_destroy (journal_t *);
1134extern int jbd2_journal_recover (journal_t *journal);
1135extern int jbd2_journal_wipe (journal_t *, int);
1136extern int jbd2_journal_skip_recovery (journal_t *);
1137extern void jbd2_journal_update_superblock (journal_t *, int);
1138extern void __jbd2_journal_abort_hard (journal_t *);
1139extern void jbd2_journal_abort (journal_t *, int);
1140extern int jbd2_journal_errno (journal_t *);
1141extern void jbd2_journal_ack_err (journal_t *);
1142extern int jbd2_journal_clear_err (journal_t *);
1143extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
1144extern int jbd2_journal_force_commit(journal_t *);
1145extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
1146extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
1147 struct jbd2_inode *inode, loff_t new_size);
1148extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
1149extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
1150
1151
1152
1153
1154struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
1155struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
1156void jbd2_journal_remove_journal_head(struct buffer_head *bh);
1157void jbd2_journal_put_journal_head(struct journal_head *jh);
1158
1159
1160
1161
1162extern struct kmem_cache *jbd2_handle_cache;
1163
1164static inline handle_t *jbd2_alloc_handle(gfp_t gfp_flags)
1165{
1166 return kmem_cache_alloc(jbd2_handle_cache, gfp_flags);
1167}
1168
1169static inline void jbd2_free_handle(handle_t *handle)
1170{
1171 kmem_cache_free(jbd2_handle_cache, handle);
1172}
1173
1174
1175#define JOURNAL_REVOKE_DEFAULT_HASH 256
1176extern int jbd2_journal_init_revoke(journal_t *, int);
1177extern void jbd2_journal_destroy_revoke_caches(void);
1178extern int jbd2_journal_init_revoke_caches(void);
1179
1180extern void jbd2_journal_destroy_revoke(journal_t *);
1181extern int jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
1182extern int jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
1183extern void jbd2_journal_write_revoke_records(journal_t *,
1184 transaction_t *, int);
1185
1186
1187extern int jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
1188extern int jbd2_journal_test_revoke(journal_t *, unsigned long long, tid_t);
1189extern void jbd2_journal_clear_revoke(journal_t *);
1190extern void jbd2_journal_switch_revoke_table(journal_t *journal);
1191
1192
1193
1194
1195
1196
1197
1198
1199int __jbd2_log_space_left(journal_t *);
1200int jbd2_log_start_commit(journal_t *journal, tid_t tid);
1201int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
1202int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
1203int jbd2_journal_force_commit_nested(journal_t *journal);
1204int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
1205int jbd2_log_do_checkpoint(journal_t *journal);
1206
1207void __jbd2_log_wait_for_space(journal_t *journal);
1208extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
1209extern int jbd2_cleanup_journal_tail(journal_t *);
1210
1211
1212
1213#define jbd_ENOSYS() \
1214do { \
1215 printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
1216 current->state = TASK_UNINTERRUPTIBLE; \
1217 schedule(); \
1218} while (1)
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230static inline int is_journal_aborted(journal_t *journal)
1231{
1232 return journal->j_flags & JBD2_ABORT;
1233}
1234
1235static inline int is_handle_aborted(handle_t *handle)
1236{
1237 if (handle->h_aborted)
1238 return 1;
1239 return is_journal_aborted(handle->h_transaction->t_journal);
1240}
1241
1242static inline void jbd2_journal_abort_handle(handle_t *handle)
1243{
1244 handle->h_aborted = 1;
1245}
1246
1247#endif
1248
1249
1250
1251
1252static inline int tid_gt(tid_t x, tid_t y)
1253{
1254 int difference = (x - y);
1255 return (difference > 0);
1256}
1257
1258static inline int tid_geq(tid_t x, tid_t y)
1259{
1260 int difference = (x - y);
1261 return (difference >= 0);
1262}
1263
1264extern int jbd2_journal_blocks_per_page(struct inode *inode);
1265extern size_t journal_tag_bytes(journal_t *journal);
1266
1267
1268
1269
1270
1271static inline int jbd_space_needed(journal_t *journal)
1272{
1273 int nblocks = journal->j_max_transaction_buffers;
1274 if (journal->j_committing_transaction)
1275 nblocks += journal->j_committing_transaction->
1276 t_outstanding_credits;
1277 return nblocks;
1278}
1279
1280
1281
1282
1283
1284
1285#define BJ_None 0
1286#define BJ_Metadata 1
1287#define BJ_Forget 2
1288#define BJ_IO 3
1289#define BJ_Shadow 4
1290#define BJ_LogCtl 5
1291#define BJ_Reserved 6
1292#define BJ_Types 7
1293
1294extern int jbd_blocks_per_page(struct inode *inode);
1295
1296#ifdef __KERNEL__
1297
1298#define buffer_trace_init(bh) do {} while (0)
1299#define print_buffer_fields(bh) do {} while (0)
1300#define print_buffer_trace(bh) do {} while (0)
1301#define BUFFER_TRACE(bh, info) do {} while (0)
1302#define BUFFER_TRACE2(bh, bh2, info) do {} while (0)
1303#define JBUFFER_TRACE(jh, info) do {} while (0)
1304
1305
1306
1307
1308
1309extern const char *jbd2_dev_to_name(dev_t device);
1310
1311#endif
1312
1313#endif
1314