c663b7a0f410a3c9c2a6c2136a722be8cf429b09
[linux-2.6.git] / fs / gfs2 / glops.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 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         gl->gl_vn++;
130 }
131
132 /**
133  * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
134  * @gl: the glock protecting the inode
135  *
136  */
137
138 static void inode_go_sync(struct gfs2_glock *gl)
139 {
140         struct gfs2_inode *ip = gl->gl_object;
141         struct address_space *metamapping = gl->gl_aspace->i_mapping;
142         int error;
143
144         if (gl->gl_state != LM_ST_UNLOCKED)
145                 gfs2_pte_inval(gl);
146         if (gl->gl_state != LM_ST_EXCLUSIVE)
147                 return;
148
149         if (ip && !S_ISREG(ip->i_inode.i_mode))
150                 ip = NULL;
151
152         if (test_bit(GLF_DIRTY, &gl->gl_flags)) {
153                 gfs2_log_flush(gl->gl_sbd, gl);
154                 filemap_fdatawrite(metamapping);
155                 if (ip) {
156                         struct address_space *mapping = ip->i_inode.i_mapping;
157                         filemap_fdatawrite(mapping);
158                         error = filemap_fdatawait(mapping);
159                         mapping_set_error(mapping, error);
160                 }
161                 error = filemap_fdatawait(metamapping);
162                 mapping_set_error(metamapping, error);
163                 clear_bit(GLF_DIRTY, &gl->gl_flags);
164                 gfs2_ail_empty_gl(gl);
165         }
166 }
167
168 /**
169  * inode_go_xmote_bh - After promoting/demoting a glock
170  * @gl: the glock
171  *
172  */
173
174 static void inode_go_xmote_bh(struct gfs2_glock *gl)
175 {
176         struct gfs2_holder *gh = gl->gl_req_gh;
177         struct buffer_head *bh;
178         int error;
179
180         if (gl->gl_state != LM_ST_UNLOCKED &&
181             (!gh || !(gh->gh_flags & GL_SKIP))) {
182                 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh);
183                 if (!error)
184                         brelse(bh);
185         }
186 }
187
188 /**
189  * inode_go_inval - prepare a inode glock to be released
190  * @gl: the glock
191  * @flags:
192  *
193  */
194
195 static void inode_go_inval(struct gfs2_glock *gl, int flags)
196 {
197         struct gfs2_inode *ip = gl->gl_object;
198         int meta = (flags & DIO_METADATA);
199
200         if (meta) {
201                 gfs2_meta_inval(gl);
202                 if (ip)
203                         set_bit(GIF_INVALID, &ip->i_flags);
204         }
205
206         if (ip && S_ISREG(ip->i_inode.i_mode))
207                 truncate_inode_pages(ip->i_inode.i_mapping, 0);
208 }
209
210 /**
211  * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
212  * @gl: the glock
213  *
214  * Returns: 1 if it's ok
215  */
216
217 static int inode_go_demote_ok(struct gfs2_glock *gl)
218 {
219         struct gfs2_sbd *sdp = gl->gl_sbd;
220         int demote = 0;
221
222         if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
223                 demote = 1;
224         else if (!sdp->sd_args.ar_localcaching &&
225                  time_after_eq(jiffies, gl->gl_stamp +
226                                gfs2_tune_get(sdp, gt_demote_secs) * HZ))
227                 demote = 1;
228
229         return demote;
230 }
231
232 /**
233  * inode_go_lock - operation done after an inode lock is locked by a process
234  * @gl: the glock
235  * @flags:
236  *
237  * Returns: errno
238  */
239
240 static int inode_go_lock(struct gfs2_holder *gh)
241 {
242         struct gfs2_glock *gl = gh->gh_gl;
243         struct gfs2_inode *ip = gl->gl_object;
244         int error = 0;
245
246         if (!ip)
247                 return 0;
248
249         if (test_bit(GIF_INVALID, &ip->i_flags)) {
250                 error = gfs2_inode_refresh(ip);
251                 if (error)
252                         return error;
253         }
254
255         if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
256             (gl->gl_state == LM_ST_EXCLUSIVE) &&
257             (gh->gh_state == LM_ST_EXCLUSIVE))
258                 error = gfs2_truncatei_resume(ip);
259
260         return error;
261 }
262
263 /**
264  * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
265  * @gl: the glock
266  *
267  * Returns: 1 if it's ok
268  */
269
270 static int rgrp_go_demote_ok(struct gfs2_glock *gl)
271 {
272         return !gl->gl_aspace->i_mapping->nrpages;
273 }
274
275 /**
276  * rgrp_go_lock - operation done after an rgrp lock is locked by
277  *    a first holder on this node.
278  * @gl: the glock
279  * @flags:
280  *
281  * Returns: errno
282  */
283
284 static int rgrp_go_lock(struct gfs2_holder *gh)
285 {
286         return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
287 }
288
289 /**
290  * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
291  *    a last holder on this node.
292  * @gl: the glock
293  * @flags:
294  *
295  */
296
297 static void rgrp_go_unlock(struct gfs2_holder *gh)
298 {
299         gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
300 }
301
302 /**
303  * trans_go_sync - promote/demote the transaction glock
304  * @gl: the glock
305  * @state: the requested state
306  * @flags:
307  *
308  */
309
310 static void trans_go_sync(struct gfs2_glock *gl)
311 {
312         struct gfs2_sbd *sdp = gl->gl_sbd;
313
314         if (gl->gl_state != LM_ST_UNLOCKED &&
315             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
316                 gfs2_meta_syncfs(sdp);
317                 gfs2_log_shutdown(sdp);
318         }
319 }
320
321 /**
322  * trans_go_xmote_bh - After promoting/demoting the transaction glock
323  * @gl: the glock
324  *
325  */
326
327 static void trans_go_xmote_bh(struct gfs2_glock *gl)
328 {
329         struct gfs2_sbd *sdp = gl->gl_sbd;
330         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
331         struct gfs2_glock *j_gl = ip->i_gl;
332         struct gfs2_log_header_host head;
333         int error;
334
335         if (gl->gl_state != LM_ST_UNLOCKED &&
336             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
337                 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
338
339                 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
340                 if (error)
341                         gfs2_consist(sdp);
342                 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
343                         gfs2_consist(sdp);
344
345                 /*  Initialize some head of the log stuff  */
346                 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
347                         sdp->sd_log_sequence = head.lh_sequence + 1;
348                         gfs2_log_pointers_init(sdp, head.lh_blkno);
349                 }
350         }
351 }
352
353 /**
354  * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
355  * @gl: the glock
356  *
357  * Returns: 1 if it's ok
358  */
359
360 static int quota_go_demote_ok(struct gfs2_glock *gl)
361 {
362         return !atomic_read(&gl->gl_lvb_count);
363 }
364
365 const struct gfs2_glock_operations gfs2_meta_glops = {
366         .go_xmote_th = meta_go_sync,
367         .go_type = LM_TYPE_META,
368 };
369
370 const struct gfs2_glock_operations gfs2_inode_glops = {
371         .go_xmote_th = inode_go_sync,
372         .go_xmote_bh = inode_go_xmote_bh,
373         .go_inval = inode_go_inval,
374         .go_demote_ok = inode_go_demote_ok,
375         .go_lock = inode_go_lock,
376         .go_type = LM_TYPE_INODE,
377         .go_min_hold_time = HZ / 10,
378 };
379
380 const struct gfs2_glock_operations gfs2_rgrp_glops = {
381         .go_xmote_th = meta_go_sync,
382         .go_inval = meta_go_inval,
383         .go_demote_ok = rgrp_go_demote_ok,
384         .go_lock = rgrp_go_lock,
385         .go_unlock = rgrp_go_unlock,
386         .go_type = LM_TYPE_RGRP,
387         .go_min_hold_time = HZ / 10,
388 };
389
390 const struct gfs2_glock_operations gfs2_trans_glops = {
391         .go_xmote_th = trans_go_sync,
392         .go_xmote_bh = trans_go_xmote_bh,
393         .go_type = LM_TYPE_NONDISK,
394 };
395
396 const struct gfs2_glock_operations gfs2_iopen_glops = {
397         .go_type = LM_TYPE_IOPEN,
398 };
399
400 const struct gfs2_glock_operations gfs2_flock_glops = {
401         .go_type = LM_TYPE_FLOCK,
402 };
403
404 const struct gfs2_glock_operations gfs2_nondisk_glops = {
405         .go_type = LM_TYPE_NONDISK,
406 };
407
408 const struct gfs2_glock_operations gfs2_quota_glops = {
409         .go_demote_ok = quota_go_demote_ok,
410         .go_type = LM_TYPE_QUOTA,
411 };
412
413 const struct gfs2_glock_operations gfs2_journal_glops = {
414         .go_type = LM_TYPE_JOURNAL,
415 };
416