Merge branch 'linus' into x86/threadinfo
[linux-2.6] / fs / gfs2 / glops.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/gfs2_ondisk.h>
15 #include <linux/lm_interface.h>
16
17 #include "gfs2.h"
18 #include "incore.h"
19 #include "bmap.h"
20 #include "glock.h"
21 #include "glops.h"
22 #include "inode.h"
23 #include "log.h"
24 #include "meta_io.h"
25 #include "recovery.h"
26 #include "rgrp.h"
27 #include "util.h"
28 #include "trans.h"
29
30 /**
31  * ail_empty_gl - remove all buffers for a given lock from the AIL
32  * @gl: the glock
33  *
34  * None of the buffers should be dirty, locked, or pinned.
35  */
36
37 static void gfs2_ail_empty_gl(struct gfs2_glock *gl)
38 {
39         struct gfs2_sbd *sdp = gl->gl_sbd;
40         unsigned int blocks;
41         struct list_head *head = &gl->gl_ail_list;
42         struct gfs2_bufdata *bd;
43         struct buffer_head *bh;
44         int error;
45
46         blocks = atomic_read(&gl->gl_ail_count);
47         if (!blocks)
48                 return;
49
50         error = gfs2_trans_begin(sdp, 0, blocks);
51         if (gfs2_assert_withdraw(sdp, !error))
52                 return;
53
54         gfs2_log_lock(sdp);
55         while (!list_empty(head)) {
56                 bd = list_entry(head->next, struct gfs2_bufdata,
57                                 bd_ail_gl_list);
58                 bh = bd->bd_bh;
59                 gfs2_remove_from_ail(bd);
60                 bd->bd_bh = NULL;
61                 bh->b_private = NULL;
62                 bd->bd_blkno = bh->b_blocknr;
63                 gfs2_assert_withdraw(sdp, !buffer_busy(bh));
64                 gfs2_trans_add_revoke(sdp, bd);
65         }
66         gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));
67         gfs2_log_unlock(sdp);
68
69         gfs2_trans_end(sdp);
70         gfs2_log_flush(sdp, NULL);
71 }
72
73 /**
74  * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
75  * @gl: the glock
76  *
77  */
78
79 static void gfs2_pte_inval(struct gfs2_glock *gl)
80 {
81         struct gfs2_inode *ip;
82         struct inode *inode;
83
84         ip = gl->gl_object;
85         inode = &ip->i_inode;
86         if (!ip || !S_ISREG(inode->i_mode))
87                 return;
88
89         unmap_shared_mapping_range(inode->i_mapping, 0, 0);
90         if (test_bit(GIF_SW_PAGED, &ip->i_flags))
91                 set_bit(GLF_DIRTY, &gl->gl_flags);
92
93 }
94
95 /**
96  * meta_go_sync - sync out the metadata for this glock
97  * @gl: the glock
98  *
99  * Called when demoting or unlocking an EX glock.  We must flush
100  * to disk all dirty buffers/pages relating to this glock, and must not
101  * not return to caller to demote/unlock the glock until I/O is complete.
102  */
103
104 static void meta_go_sync(struct gfs2_glock *gl)
105 {
106         if (gl->gl_state != LM_ST_EXCLUSIVE)
107                 return;
108
109         if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) {
110                 gfs2_log_flush(gl->gl_sbd, gl);
111                 gfs2_meta_sync(gl);
112                 gfs2_ail_empty_gl(gl);
113         }
114 }
115
116 /**
117  * meta_go_inval - invalidate the metadata for this glock
118  * @gl: the glock
119  * @flags:
120  *
121  */
122
123 static void meta_go_inval(struct gfs2_glock *gl, int flags)
124 {
125         if (!(flags & DIO_METADATA))
126                 return;
127
128         gfs2_meta_inval(gl);
129         if (gl->gl_object == GFS2_I(gl->gl_sbd->sd_rindex))
130                 gl->gl_sbd->sd_rindex_uptodate = 0;
131         else if (gl->gl_ops == &gfs2_rgrp_glops && gl->gl_object) {
132                 struct gfs2_rgrpd *rgd = (struct gfs2_rgrpd *)gl->gl_object;
133
134                 rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
135         }
136 }
137
138 /**
139  * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
140  * @gl: the glock protecting the inode
141  *
142  */
143
144 static void inode_go_sync(struct gfs2_glock *gl)
145 {
146         struct gfs2_inode *ip = gl->gl_object;
147         struct address_space *metamapping = gl->gl_aspace->i_mapping;
148         int error;
149
150         if (gl->gl_state != LM_ST_UNLOCKED)
151                 gfs2_pte_inval(gl);
152         if (gl->gl_state != LM_ST_EXCLUSIVE)
153                 return;
154
155         if (ip && !S_ISREG(ip->i_inode.i_mode))
156                 ip = NULL;
157
158         if (test_bit(GLF_DIRTY, &gl->gl_flags)) {
159                 gfs2_log_flush(gl->gl_sbd, gl);
160                 filemap_fdatawrite(metamapping);
161                 if (ip) {
162                         struct address_space *mapping = ip->i_inode.i_mapping;
163                         filemap_fdatawrite(mapping);
164                         error = filemap_fdatawait(mapping);
165                         mapping_set_error(mapping, error);
166                 }
167                 error = filemap_fdatawait(metamapping);
168                 mapping_set_error(metamapping, error);
169                 clear_bit(GLF_DIRTY, &gl->gl_flags);
170                 gfs2_ail_empty_gl(gl);
171         }
172 }
173
174 /**
175  * inode_go_xmote_bh - After promoting/demoting a glock
176  * @gl: the glock
177  *
178  */
179
180 static void inode_go_xmote_bh(struct gfs2_glock *gl)
181 {
182         struct gfs2_holder *gh = gl->gl_req_gh;
183         struct buffer_head *bh;
184         int error;
185
186         if (gl->gl_state != LM_ST_UNLOCKED &&
187             (!gh || !(gh->gh_flags & GL_SKIP))) {
188                 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh);
189                 if (!error)
190                         brelse(bh);
191         }
192 }
193
194 /**
195  * inode_go_inval - prepare a inode glock to be released
196  * @gl: the glock
197  * @flags:
198  *
199  */
200
201 static void inode_go_inval(struct gfs2_glock *gl, int flags)
202 {
203         struct gfs2_inode *ip = gl->gl_object;
204         int meta = (flags & DIO_METADATA);
205
206         if (meta) {
207                 gfs2_meta_inval(gl);
208                 if (ip)
209                         set_bit(GIF_INVALID, &ip->i_flags);
210         }
211
212         if (ip && S_ISREG(ip->i_inode.i_mode))
213                 truncate_inode_pages(ip->i_inode.i_mapping, 0);
214 }
215
216 /**
217  * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
218  * @gl: the glock
219  *
220  * Returns: 1 if it's ok
221  */
222
223 static int inode_go_demote_ok(struct gfs2_glock *gl)
224 {
225         struct gfs2_sbd *sdp = gl->gl_sbd;
226         int demote = 0;
227
228         if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
229                 demote = 1;
230         else if (!sdp->sd_args.ar_localcaching &&
231                  time_after_eq(jiffies, gl->gl_stamp +
232                                gfs2_tune_get(sdp, gt_demote_secs) * HZ))
233                 demote = 1;
234
235         return demote;
236 }
237
238 /**
239  * inode_go_lock - operation done after an inode lock is locked by a process
240  * @gl: the glock
241  * @flags:
242  *
243  * Returns: errno
244  */
245
246 static int inode_go_lock(struct gfs2_holder *gh)
247 {
248         struct gfs2_glock *gl = gh->gh_gl;
249         struct gfs2_inode *ip = gl->gl_object;
250         int error = 0;
251
252         if (!ip || (gh->gh_flags & GL_SKIP))
253                 return 0;
254
255         if (test_bit(GIF_INVALID, &ip->i_flags)) {
256                 error = gfs2_inode_refresh(ip);
257                 if (error)
258                         return error;
259         }
260
261         if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
262             (gl->gl_state == LM_ST_EXCLUSIVE) &&
263             (gh->gh_state == LM_ST_EXCLUSIVE))
264                 error = gfs2_truncatei_resume(ip);
265
266         return error;
267 }
268
269 /**
270  * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
271  * @gl: the glock
272  *
273  * Returns: 1 if it's ok
274  */
275
276 static int rgrp_go_demote_ok(struct gfs2_glock *gl)
277 {
278         return !gl->gl_aspace->i_mapping->nrpages;
279 }
280
281 /**
282  * rgrp_go_lock - operation done after an rgrp lock is locked by
283  *    a first holder on this node.
284  * @gl: the glock
285  * @flags:
286  *
287  * Returns: errno
288  */
289
290 static int rgrp_go_lock(struct gfs2_holder *gh)
291 {
292         return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
293 }
294
295 /**
296  * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
297  *    a last holder on this node.
298  * @gl: the glock
299  * @flags:
300  *
301  */
302
303 static void rgrp_go_unlock(struct gfs2_holder *gh)
304 {
305         gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
306 }
307
308 /**
309  * trans_go_sync - promote/demote the transaction glock
310  * @gl: the glock
311  * @state: the requested state
312  * @flags:
313  *
314  */
315
316 static void trans_go_sync(struct gfs2_glock *gl)
317 {
318         struct gfs2_sbd *sdp = gl->gl_sbd;
319
320         if (gl->gl_state != LM_ST_UNLOCKED &&
321             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
322                 gfs2_meta_syncfs(sdp);
323                 gfs2_log_shutdown(sdp);
324         }
325 }
326
327 /**
328  * trans_go_xmote_bh - After promoting/demoting the transaction glock
329  * @gl: the glock
330  *
331  */
332
333 static void trans_go_xmote_bh(struct gfs2_glock *gl)
334 {
335         struct gfs2_sbd *sdp = gl->gl_sbd;
336         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
337         struct gfs2_glock *j_gl = ip->i_gl;
338         struct gfs2_log_header_host head;
339         int error;
340
341         if (gl->gl_state != LM_ST_UNLOCKED &&
342             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
343                 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
344
345                 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
346                 if (error)
347                         gfs2_consist(sdp);
348                 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
349                         gfs2_consist(sdp);
350
351                 /*  Initialize some head of the log stuff  */
352                 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
353                         sdp->sd_log_sequence = head.lh_sequence + 1;
354                         gfs2_log_pointers_init(sdp, head.lh_blkno);
355                 }
356         }
357 }
358
359 /**
360  * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
361  * @gl: the glock
362  *
363  * Returns: 1 if it's ok
364  */
365
366 static int quota_go_demote_ok(struct gfs2_glock *gl)
367 {
368         return !atomic_read(&gl->gl_lvb_count);
369 }
370
371 const struct gfs2_glock_operations gfs2_meta_glops = {
372         .go_xmote_th = meta_go_sync,
373         .go_type = LM_TYPE_META,
374 };
375
376 const struct gfs2_glock_operations gfs2_inode_glops = {
377         .go_xmote_th = inode_go_sync,
378         .go_xmote_bh = inode_go_xmote_bh,
379         .go_inval = inode_go_inval,
380         .go_demote_ok = inode_go_demote_ok,
381         .go_lock = inode_go_lock,
382         .go_type = LM_TYPE_INODE,
383         .go_min_hold_time = HZ / 10,
384 };
385
386 const struct gfs2_glock_operations gfs2_rgrp_glops = {
387         .go_xmote_th = meta_go_sync,
388         .go_inval = meta_go_inval,
389         .go_demote_ok = rgrp_go_demote_ok,
390         .go_lock = rgrp_go_lock,
391         .go_unlock = rgrp_go_unlock,
392         .go_type = LM_TYPE_RGRP,
393         .go_min_hold_time = HZ / 10,
394 };
395
396 const struct gfs2_glock_operations gfs2_trans_glops = {
397         .go_xmote_th = trans_go_sync,
398         .go_xmote_bh = trans_go_xmote_bh,
399         .go_type = LM_TYPE_NONDISK,
400 };
401
402 const struct gfs2_glock_operations gfs2_iopen_glops = {
403         .go_type = LM_TYPE_IOPEN,
404 };
405
406 const struct gfs2_glock_operations gfs2_flock_glops = {
407         .go_type = LM_TYPE_FLOCK,
408 };
409
410 const struct gfs2_glock_operations gfs2_nondisk_glops = {
411         .go_type = LM_TYPE_NONDISK,
412 };
413
414 const struct gfs2_glock_operations gfs2_quota_glops = {
415         .go_demote_ok = quota_go_demote_ok,
416         .go_type = LM_TYPE_QUOTA,
417 };
418
419 const struct gfs2_glock_operations gfs2_journal_glops = {
420         .go_type = LM_TYPE_JOURNAL,
421 };
422