1
2
3
4
5
6
7
8
9
10#include <linux/sched.h>
11#include <linux/slab.h>
12#include <linux/spinlock.h>
13#include <linux/completion.h>
14#include <linux/buffer_head.h>
15#include <linux/kallsyms.h>
16#include <linux/gfs2_ondisk.h>
17
18#include "gfs2.h"
19#include "incore.h"
20#include "glock.h"
21#include "inode.h"
22#include "log.h"
23#include "lops.h"
24#include "meta_io.h"
25#include "trans.h"
26#include "util.h"
27#include "trace_gfs2.h"
28
29int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
30 unsigned int revokes)
31{
32 struct gfs2_trans *tr;
33 int error;
34
35 BUG_ON(current->journal_info);
36 BUG_ON(blocks == 0 && revokes == 0);
37
38 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
39 return -EROFS;
40
41 tr = kzalloc(sizeof(struct gfs2_trans), GFP_NOFS);
42 if (!tr)
43 return -ENOMEM;
44
45 tr->tr_ip = (unsigned long)__builtin_return_address(0);
46 tr->tr_blocks = blocks;
47 tr->tr_revokes = revokes;
48 tr->tr_reserved = 1;
49 if (blocks)
50 tr->tr_reserved += 6 + blocks;
51 if (revokes)
52 tr->tr_reserved += gfs2_struct2blk(sdp, revokes,
53 sizeof(u64));
54 sb_start_intwrite(sdp->sd_vfs);
55 gfs2_holder_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &tr->tr_t_gh);
56
57 error = gfs2_glock_nq(&tr->tr_t_gh);
58 if (error)
59 goto fail_holder_uninit;
60
61 error = gfs2_log_reserve(sdp, tr->tr_reserved);
62 if (error)
63 goto fail_gunlock;
64
65 current->journal_info = tr;
66
67 return 0;
68
69fail_gunlock:
70 gfs2_glock_dq(&tr->tr_t_gh);
71
72fail_holder_uninit:
73 sb_end_intwrite(sdp->sd_vfs);
74 gfs2_holder_uninit(&tr->tr_t_gh);
75 kfree(tr);
76
77 return error;
78}
79
80
81
82
83
84
85
86
87static void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks)
88{
89
90 atomic_add(blks, &sdp->sd_log_blks_free);
91 trace_gfs2_log_blocks(sdp, blks);
92 gfs2_assert_withdraw(sdp, atomic_read(&sdp->sd_log_blks_free) <=
93 sdp->sd_jdesc->jd_blocks);
94 up_read(&sdp->sd_log_flush_lock);
95}
96
97static void gfs2_print_trans(const struct gfs2_trans *tr)
98{
99 printk(KERN_WARNING "GFS2: Transaction created at: %pSR\n",
100 (void *)tr->tr_ip);
101 printk(KERN_WARNING "GFS2: blocks=%u revokes=%u reserved=%u touched=%d\n",
102 tr->tr_blocks, tr->tr_revokes, tr->tr_reserved, tr->tr_touched);
103 printk(KERN_WARNING "GFS2: Buf %u/%u Databuf %u/%u Revoke %u/%u\n",
104 tr->tr_num_buf_new, tr->tr_num_buf_rm,
105 tr->tr_num_databuf_new, tr->tr_num_databuf_rm,
106 tr->tr_num_revoke, tr->tr_num_revoke_rm);
107}
108
109void gfs2_trans_end(struct gfs2_sbd *sdp)
110{
111 struct gfs2_trans *tr = current->journal_info;
112 s64 nbuf;
113 BUG_ON(!tr);
114 current->journal_info = NULL;
115
116 if (!tr->tr_touched) {
117 gfs2_log_release(sdp, tr->tr_reserved);
118 if (tr->tr_t_gh.gh_gl) {
119 gfs2_glock_dq(&tr->tr_t_gh);
120 gfs2_holder_uninit(&tr->tr_t_gh);
121 kfree(tr);
122 }
123 sb_end_intwrite(sdp->sd_vfs);
124 return;
125 }
126
127 nbuf = tr->tr_num_buf_new + tr->tr_num_databuf_new;
128 nbuf -= tr->tr_num_buf_rm;
129 nbuf -= tr->tr_num_databuf_rm;
130
131 if (gfs2_assert_withdraw(sdp, (nbuf <= tr->tr_blocks) &&
132 (tr->tr_num_revoke <= tr->tr_revokes)))
133 gfs2_print_trans(tr);
134
135 gfs2_log_commit(sdp, tr);
136 if (tr->tr_t_gh.gh_gl) {
137 gfs2_glock_dq(&tr->tr_t_gh);
138 gfs2_holder_uninit(&tr->tr_t_gh);
139 if (!tr->tr_attached)
140 kfree(tr);
141 }
142 up_read(&sdp->sd_log_flush_lock);
143
144 if (sdp->sd_vfs->s_flags & MS_SYNCHRONOUS)
145 gfs2_log_flush(sdp, NULL);
146 sb_end_intwrite(sdp->sd_vfs);
147}
148
149static struct gfs2_bufdata *gfs2_alloc_bufdata(struct gfs2_glock *gl,
150 struct buffer_head *bh,
151 const struct gfs2_log_operations *lops)
152{
153 struct gfs2_bufdata *bd;
154
155 bd = kmem_cache_zalloc(gfs2_bufdata_cachep, GFP_NOFS | __GFP_NOFAIL);
156 bd->bd_bh = bh;
157 bd->bd_gl = gl;
158 bd->bd_ops = lops;
159 INIT_LIST_HEAD(&bd->bd_list);
160 bh->b_private = bd;
161 return bd;
162}
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182void gfs2_trans_add_data(struct gfs2_glock *gl, struct buffer_head *bh)
183{
184 struct gfs2_trans *tr = current->journal_info;
185 struct gfs2_sbd *sdp = gl->gl_sbd;
186 struct address_space *mapping = bh->b_page->mapping;
187 struct gfs2_inode *ip = GFS2_I(mapping->host);
188 struct gfs2_bufdata *bd;
189
190 if (!gfs2_is_jdata(ip)) {
191 gfs2_ordered_add_inode(ip);
192 return;
193 }
194
195 lock_buffer(bh);
196 gfs2_log_lock(sdp);
197 bd = bh->b_private;
198 if (bd == NULL) {
199 gfs2_log_unlock(sdp);
200 unlock_buffer(bh);
201 if (bh->b_private == NULL)
202 bd = gfs2_alloc_bufdata(gl, bh, &gfs2_databuf_lops);
203 lock_buffer(bh);
204 gfs2_log_lock(sdp);
205 }
206 gfs2_assert(sdp, bd->bd_gl == gl);
207 tr->tr_touched = 1;
208 if (list_empty(&bd->bd_list)) {
209 set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
210 set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
211 gfs2_pin(sdp, bd->bd_bh);
212 tr->tr_num_databuf_new++;
213 sdp->sd_log_num_databuf++;
214 list_add_tail(&bd->bd_list, &sdp->sd_log_le_databuf);
215 }
216 gfs2_log_unlock(sdp);
217 unlock_buffer(bh);
218}
219
220static void meta_lo_add(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
221{
222 struct gfs2_meta_header *mh;
223 struct gfs2_trans *tr;
224
225 tr = current->journal_info;
226 tr->tr_touched = 1;
227 if (!list_empty(&bd->bd_list))
228 return;
229 set_bit(GLF_LFLUSH, &bd->bd_gl->gl_flags);
230 set_bit(GLF_DIRTY, &bd->bd_gl->gl_flags);
231 mh = (struct gfs2_meta_header *)bd->bd_bh->b_data;
232 if (unlikely(mh->mh_magic != cpu_to_be32(GFS2_MAGIC))) {
233 printk(KERN_ERR
234 "Attempting to add uninitialised block to journal (inplace block=%lld)\n",
235 (unsigned long long)bd->bd_bh->b_blocknr);
236 BUG();
237 }
238 gfs2_pin(sdp, bd->bd_bh);
239 mh->__pad0 = cpu_to_be64(0);
240 mh->mh_jid = cpu_to_be32(sdp->sd_jdesc->jd_jid);
241 sdp->sd_log_num_buf++;
242 list_add(&bd->bd_list, &sdp->sd_log_le_buf);
243 tr->tr_num_buf_new++;
244}
245
246void gfs2_trans_add_meta(struct gfs2_glock *gl, struct buffer_head *bh)
247{
248
249 struct gfs2_sbd *sdp = gl->gl_sbd;
250 struct gfs2_bufdata *bd;
251
252 lock_buffer(bh);
253 gfs2_log_lock(sdp);
254 bd = bh->b_private;
255 if (bd == NULL) {
256 gfs2_log_unlock(sdp);
257 unlock_buffer(bh);
258 lock_page(bh->b_page);
259 if (bh->b_private == NULL)
260 bd = gfs2_alloc_bufdata(gl, bh, &gfs2_buf_lops);
261 unlock_page(bh->b_page);
262 lock_buffer(bh);
263 gfs2_log_lock(sdp);
264 }
265 gfs2_assert(sdp, bd->bd_gl == gl);
266 meta_lo_add(sdp, bd);
267 gfs2_log_unlock(sdp);
268 unlock_buffer(bh);
269}
270
271void gfs2_trans_add_revoke(struct gfs2_sbd *sdp, struct gfs2_bufdata *bd)
272{
273 struct gfs2_trans *tr = current->journal_info;
274
275 BUG_ON(!list_empty(&bd->bd_list));
276 gfs2_add_revoke(sdp, bd);
277 tr->tr_touched = 1;
278 tr->tr_num_revoke++;
279}
280
281void gfs2_trans_add_unrevoke(struct gfs2_sbd *sdp, u64 blkno, unsigned int len)
282{
283 struct gfs2_bufdata *bd, *tmp;
284 struct gfs2_trans *tr = current->journal_info;
285 unsigned int n = len;
286
287 gfs2_log_lock(sdp);
288 list_for_each_entry_safe(bd, tmp, &sdp->sd_log_le_revoke, bd_list) {
289 if ((bd->bd_blkno >= blkno) && (bd->bd_blkno < (blkno + len))) {
290 list_del_init(&bd->bd_list);
291 gfs2_assert_withdraw(sdp, sdp->sd_log_num_revoke);
292 sdp->sd_log_num_revoke--;
293 kmem_cache_free(gfs2_bufdata_cachep, bd);
294 tr->tr_num_revoke_rm++;
295 if (--n == 0)
296 break;
297 }
298 }
299 gfs2_log_unlock(sdp);
300}
301
302