110f03d66f4bd0ee1e2da2a089e213bd7ba706c5
[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(NULL, 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
142         if (ip && !S_ISREG(ip->i_inode.i_mode))
143                 ip = NULL;
144
145         if (test_bit(GLF_DIRTY, &gl->gl_flags)) {
146                 if (ip && !gfs2_is_jdata(ip))
147                         filemap_fdatawrite(ip->i_inode.i_mapping);
148                 gfs2_log_flush(gl->gl_sbd, gl);
149                 if (ip && gfs2_is_jdata(ip))
150                         filemap_fdatawrite(ip->i_inode.i_mapping);
151                 gfs2_meta_sync(gl);
152                 if (ip) {
153                         struct address_space *mapping = ip->i_inode.i_mapping;
154                         int error = filemap_fdatawait(mapping);
155                         mapping_set_error(mapping, error);
156                 }
157                 clear_bit(GLF_DIRTY, &gl->gl_flags);
158                 gfs2_ail_empty_gl(gl);
159         }
160 }
161
162 /**
163  * inode_go_xmote_th - promote/demote a glock
164  * @gl: the glock
165  * @state: the requested state
166  * @flags:
167  *
168  */
169
170 static void inode_go_xmote_th(struct gfs2_glock *gl)
171 {
172         if (gl->gl_state != LM_ST_UNLOCKED)
173                 gfs2_pte_inval(gl);
174         if (gl->gl_state == LM_ST_EXCLUSIVE)
175                 inode_go_sync(gl);
176 }
177
178 /**
179  * inode_go_xmote_bh - After promoting/demoting a glock
180  * @gl: the glock
181  *
182  */
183
184 static void inode_go_xmote_bh(struct gfs2_glock *gl)
185 {
186         struct gfs2_holder *gh = gl->gl_req_gh;
187         struct buffer_head *bh;
188         int error;
189
190         if (gl->gl_state != LM_ST_UNLOCKED &&
191             (!gh || !(gh->gh_flags & GL_SKIP))) {
192                 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh);
193                 if (!error)
194                         brelse(bh);
195         }
196 }
197
198 /**
199  * inode_go_drop_th - unlock a glock
200  * @gl: the glock
201  *
202  * Invoked from rq_demote().
203  * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
204  * is being purged from our node's glock cache; we're dropping lock.
205  */
206
207 static void inode_go_drop_th(struct gfs2_glock *gl)
208 {
209         gfs2_pte_inval(gl);
210         if (gl->gl_state == LM_ST_EXCLUSIVE)
211                 inode_go_sync(gl);
212 }
213
214 /**
215  * inode_go_inval - prepare a inode glock to be released
216  * @gl: the glock
217  * @flags:
218  *
219  */
220
221 static void inode_go_inval(struct gfs2_glock *gl, int flags)
222 {
223         struct gfs2_inode *ip = gl->gl_object;
224         int meta = (flags & DIO_METADATA);
225
226         if (meta) {
227                 gfs2_meta_inval(gl);
228                 if (ip)
229                         set_bit(GIF_INVALID, &ip->i_flags);
230         }
231
232         if (ip && S_ISREG(ip->i_inode.i_mode))
233                 truncate_inode_pages(ip->i_inode.i_mapping, 0);
234 }
235
236 /**
237  * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
238  * @gl: the glock
239  *
240  * Returns: 1 if it's ok
241  */
242
243 static int inode_go_demote_ok(struct gfs2_glock *gl)
244 {
245         struct gfs2_sbd *sdp = gl->gl_sbd;
246         int demote = 0;
247
248         if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
249                 demote = 1;
250         else if (!sdp->sd_args.ar_localcaching &&
251                  time_after_eq(jiffies, gl->gl_stamp +
252                                gfs2_tune_get(sdp, gt_demote_secs) * HZ))
253                 demote = 1;
254
255         return demote;
256 }
257
258 /**
259  * inode_go_lock - operation done after an inode lock is locked by a process
260  * @gl: the glock
261  * @flags:
262  *
263  * Returns: errno
264  */
265
266 static int inode_go_lock(struct gfs2_holder *gh)
267 {
268         struct gfs2_glock *gl = gh->gh_gl;
269         struct gfs2_inode *ip = gl->gl_object;
270         int error = 0;
271
272         if (!ip)
273                 return 0;
274
275         if (test_bit(GIF_INVALID, &ip->i_flags)) {
276                 error = gfs2_inode_refresh(ip);
277                 if (error)
278                         return error;
279         }
280
281         if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
282             (gl->gl_state == LM_ST_EXCLUSIVE) &&
283             (gh->gh_state == LM_ST_EXCLUSIVE))
284                 error = gfs2_truncatei_resume(ip);
285
286         return error;
287 }
288
289 /**
290  * inode_go_unlock - operation done before an inode lock is unlocked by a
291  *                   process
292  * @gl: the glock
293  * @flags:
294  *
295  */
296
297 static void inode_go_unlock(struct gfs2_holder *gh)
298 {
299         struct gfs2_glock *gl = gh->gh_gl;
300         struct gfs2_inode *ip = gl->gl_object;
301
302         if (ip)
303                 gfs2_meta_cache_flush(ip);
304 }
305
306 /**
307  * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
308  * @gl: the glock
309  *
310  * Returns: 1 if it's ok
311  */
312
313 static int rgrp_go_demote_ok(struct gfs2_glock *gl)
314 {
315         return !gl->gl_aspace->i_mapping->nrpages;
316 }
317
318 /**
319  * rgrp_go_lock - operation done after an rgrp lock is locked by
320  *    a first holder on this node.
321  * @gl: the glock
322  * @flags:
323  *
324  * Returns: errno
325  */
326
327 static int rgrp_go_lock(struct gfs2_holder *gh)
328 {
329         return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
330 }
331
332 /**
333  * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
334  *    a last holder on this node.
335  * @gl: the glock
336  * @flags:
337  *
338  */
339
340 static void rgrp_go_unlock(struct gfs2_holder *gh)
341 {
342         gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
343 }
344
345 /**
346  * trans_go_xmote_th - promote/demote the transaction glock
347  * @gl: the glock
348  * @state: the requested state
349  * @flags:
350  *
351  */
352
353 static void trans_go_xmote_th(struct gfs2_glock *gl)
354 {
355         struct gfs2_sbd *sdp = gl->gl_sbd;
356
357         if (gl->gl_state != LM_ST_UNLOCKED &&
358             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
359                 gfs2_meta_syncfs(sdp);
360                 gfs2_log_shutdown(sdp);
361         }
362 }
363
364 /**
365  * trans_go_xmote_bh - After promoting/demoting the transaction glock
366  * @gl: the glock
367  *
368  */
369
370 static void trans_go_xmote_bh(struct gfs2_glock *gl)
371 {
372         struct gfs2_sbd *sdp = gl->gl_sbd;
373         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
374         struct gfs2_glock *j_gl = ip->i_gl;
375         struct gfs2_log_header_host head;
376         int error;
377
378         if (gl->gl_state != LM_ST_UNLOCKED &&
379             test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
380                 gfs2_meta_cache_flush(GFS2_I(sdp->sd_jdesc->jd_inode));
381                 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
382
383                 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
384                 if (error)
385                         gfs2_consist(sdp);
386                 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
387                         gfs2_consist(sdp);
388
389                 /*  Initialize some head of the log stuff  */
390                 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
391                         sdp->sd_log_sequence = head.lh_sequence + 1;
392                         gfs2_log_pointers_init(sdp, head.lh_blkno);
393                 }
394         }
395 }
396
397 /**
398  * trans_go_drop_th - unlock the transaction glock
399  * @gl: the glock
400  *
401  * We want to sync the device even with localcaching.  Remember
402  * that localcaching journal replay only marks buffers dirty.
403  */
404
405 static void trans_go_drop_th(struct gfs2_glock *gl)
406 {
407         struct gfs2_sbd *sdp = gl->gl_sbd;
408
409         if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
410                 gfs2_meta_syncfs(sdp);
411                 gfs2_log_shutdown(sdp);
412         }
413 }
414
415 /**
416  * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
417  * @gl: the glock
418  *
419  * Returns: 1 if it's ok
420  */
421
422 static int quota_go_demote_ok(struct gfs2_glock *gl)
423 {
424         return !atomic_read(&gl->gl_lvb_count);
425 }
426
427 const struct gfs2_glock_operations gfs2_meta_glops = {
428         .go_xmote_th = meta_go_sync,
429         .go_drop_th = meta_go_sync,
430         .go_type = LM_TYPE_META,
431 };
432
433 const struct gfs2_glock_operations gfs2_inode_glops = {
434         .go_xmote_th = inode_go_xmote_th,
435         .go_xmote_bh = inode_go_xmote_bh,
436         .go_drop_th = inode_go_drop_th,
437         .go_inval = inode_go_inval,
438         .go_demote_ok = inode_go_demote_ok,
439         .go_lock = inode_go_lock,
440         .go_unlock = inode_go_unlock,
441         .go_type = LM_TYPE_INODE,
442         .go_min_hold_time = HZ / 10,
443 };
444
445 const struct gfs2_glock_operations gfs2_rgrp_glops = {
446         .go_xmote_th = meta_go_sync,
447         .go_drop_th = meta_go_sync,
448         .go_inval = meta_go_inval,
449         .go_demote_ok = rgrp_go_demote_ok,
450         .go_lock = rgrp_go_lock,
451         .go_unlock = rgrp_go_unlock,
452         .go_type = LM_TYPE_RGRP,
453         .go_min_hold_time = HZ / 10,
454 };
455
456 const struct gfs2_glock_operations gfs2_trans_glops = {
457         .go_xmote_th = trans_go_xmote_th,
458         .go_xmote_bh = trans_go_xmote_bh,
459         .go_drop_th = trans_go_drop_th,
460         .go_type = LM_TYPE_NONDISK,
461 };
462
463 const struct gfs2_glock_operations gfs2_iopen_glops = {
464         .go_type = LM_TYPE_IOPEN,
465 };
466
467 const struct gfs2_glock_operations gfs2_flock_glops = {
468         .go_type = LM_TYPE_FLOCK,
469 };
470
471 const struct gfs2_glock_operations gfs2_nondisk_glops = {
472         .go_type = LM_TYPE_NONDISK,
473 };
474
475 const struct gfs2_glock_operations gfs2_quota_glops = {
476         .go_demote_ok = quota_go_demote_ok,
477         .go_type = LM_TYPE_QUOTA,
478 };
479
480 const struct gfs2_glock_operations gfs2_journal_glops = {
481         .go_type = LM_TYPE_JOURNAL,
482 };
483