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