ext4: code cleanup
[linux-2.6] / fs / ext4 / ext4_jbd2.c
1 /*
2  * Interface between ext4 and JBD
3  */
4
5 #include "ext4_jbd2.h"
6
7 int __ext4_journal_get_undo_access(const char *where, handle_t *handle,
8                                 struct buffer_head *bh)
9 {
10         int err = 0;
11
12         if (ext4_handle_valid(handle)) {
13                 err = jbd2_journal_get_undo_access(handle, bh);
14                 if (err)
15                         ext4_journal_abort_handle(where, __func__, bh,
16                                                   handle, err);
17         }
18         return err;
19 }
20
21 int __ext4_journal_get_write_access(const char *where, handle_t *handle,
22                                 struct buffer_head *bh)
23 {
24         int err = 0;
25
26         if (ext4_handle_valid(handle)) {
27                 err = jbd2_journal_get_write_access(handle, bh);
28                 if (err)
29                         ext4_journal_abort_handle(where, __func__, bh,
30                                                   handle, err);
31         }
32         return err;
33 }
34
35 int __ext4_journal_forget(const char *where, handle_t *handle,
36                                 struct buffer_head *bh)
37 {
38         int err = 0;
39
40         if (ext4_handle_valid(handle)) {
41                 err = jbd2_journal_forget(handle, bh);
42                 if (err)
43                         ext4_journal_abort_handle(where, __func__, bh,
44                                                   handle, err);
45         }
46         return err;
47 }
48
49 int __ext4_journal_revoke(const char *where, handle_t *handle,
50                                 ext4_fsblk_t blocknr, struct buffer_head *bh)
51 {
52         int err = 0;
53
54         if (ext4_handle_valid(handle)) {
55                 err = jbd2_journal_revoke(handle, blocknr, bh);
56                 if (err)
57                         ext4_journal_abort_handle(where, __func__, bh,
58                                                   handle, err);
59         }
60         return err;
61 }
62
63 int __ext4_journal_get_create_access(const char *where,
64                                 handle_t *handle, struct buffer_head *bh)
65 {
66         int err = 0;
67
68         if (ext4_handle_valid(handle)) {
69                 err = jbd2_journal_get_create_access(handle, bh);
70                 if (err)
71                         ext4_journal_abort_handle(where, __func__, bh,
72                                                   handle, err);
73         }
74         return err;
75 }
76
77 int __ext4_handle_dirty_metadata(const char *where, handle_t *handle,
78                                  struct inode *inode, struct buffer_head *bh)
79 {
80         int err = 0;
81
82         if (ext4_handle_valid(handle)) {
83                 err = jbd2_journal_dirty_metadata(handle, bh);
84                 if (err)
85                         ext4_journal_abort_handle(where, __func__, bh,
86                                                   handle, err);
87         } else {
88                 mark_buffer_dirty(bh);
89                 if (inode && inode_needs_sync(inode)) {
90                         sync_dirty_buffer(bh);
91                         if (buffer_req(bh) && !buffer_uptodate(bh)) {
92                                 ext4_error(inode->i_sb, __func__,
93                                            "IO error syncing inode, "
94                                            "inode=%lu, block=%llu",
95                                            inode->i_ino,
96                                            (unsigned long long) bh->b_blocknr);
97                                 err = -EIO;
98                         }
99                 }
100         }
101         return err;
102 }