blob: 7b82657a991096bea7291522f2bd357a5213d24e [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050014#include <linux/gfs2_ondisk.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020015#include <linux/lm_interface.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000016
17#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050018#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000019#include "bmap.h"
20#include "glock.h"
21#include "glops.h"
22#include "inode.h"
23#include "log.h"
24#include "meta_io.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000025#include "recovery.h"
26#include "rgrp.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050027#include "util.h"
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040028#include "trans.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040030/**
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
37static 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 u64 blkno;
45 int error;
46
47 blocks = atomic_read(&gl->gl_ail_count);
48 if (!blocks)
49 return;
50
51 error = gfs2_trans_begin(sdp, 0, blocks);
52 if (gfs2_assert_withdraw(sdp, !error))
53 return;
54
55 gfs2_log_lock(sdp);
56 while (!list_empty(head)) {
57 bd = list_entry(head->next, struct gfs2_bufdata,
58 bd_ail_gl_list);
59 bh = bd->bd_bh;
60 blkno = bh->b_blocknr;
61 gfs2_assert_withdraw(sdp, !buffer_busy(bh));
62
63 bd->bd_ail = NULL;
64 list_del(&bd->bd_ail_st_list);
65 list_del(&bd->bd_ail_gl_list);
66 atomic_dec(&gl->gl_ail_count);
67 brelse(bh);
68 gfs2_log_unlock(sdp);
69
70 gfs2_trans_add_revoke(sdp, blkno);
71
72 gfs2_log_lock(sdp);
73 }
74 gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));
75 gfs2_log_unlock(sdp);
76
77 gfs2_trans_end(sdp);
78 gfs2_log_flush(sdp, NULL);
79}
Steven Whitehouseba7f7292006-07-26 11:27:10 -040080
81/**
82 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
83 * @gl: the glock
84 *
85 */
86
87static void gfs2_pte_inval(struct gfs2_glock *gl)
88{
89 struct gfs2_inode *ip;
90 struct inode *inode;
91
92 ip = gl->gl_object;
93 inode = &ip->i_inode;
Steven Whitehouseb60623c2006-11-01 12:22:46 -050094 if (!ip || !S_ISREG(inode->i_mode))
Steven Whitehouseba7f7292006-07-26 11:27:10 -040095 return;
96
97 if (!test_bit(GIF_PAGED, &ip->i_flags))
98 return;
99
100 unmap_shared_mapping_range(inode->i_mapping, 0, 0);
101
102 if (test_bit(GIF_SW_PAGED, &ip->i_flags))
103 set_bit(GLF_DIRTY, &gl->gl_flags);
104
105 clear_bit(GIF_SW_PAGED, &ip->i_flags);
106}
107
108/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000109 * meta_go_sync - sync out the metadata for this glock
110 * @gl: the glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000111 *
112 * Called when demoting or unlocking an EX glock. We must flush
113 * to disk all dirty buffers/pages relating to this glock, and must not
114 * not return to caller to demote/unlock the glock until I/O is complete.
115 */
116
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500117static void meta_go_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000118{
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500119 if (gl->gl_state != LM_ST_EXCLUSIVE)
120 return;
121
David Teiglandb3b94fa2006-01-16 16:50:04 +0000122 if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) {
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400123 gfs2_log_flush(gl->gl_sbd, gl);
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400124 gfs2_meta_sync(gl);
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500125 gfs2_ail_empty_gl(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000126 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000127}
128
129/**
130 * meta_go_inval - invalidate the metadata for this glock
131 * @gl: the glock
132 * @flags:
133 *
134 */
135
136static void meta_go_inval(struct gfs2_glock *gl, int flags)
137{
138 if (!(flags & DIO_METADATA))
139 return;
140
141 gfs2_meta_inval(gl);
142 gl->gl_vn++;
143}
144
145/**
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500146 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
147 * @gl: the glock protecting the inode
148 *
149 */
150
151static void inode_go_sync(struct gfs2_glock *gl)
152{
153 struct gfs2_inode *ip = gl->gl_object;
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 if (ip)
161 filemap_fdatawrite(ip->i_inode.i_mapping);
162 gfs2_meta_sync(gl);
163 if (ip) {
164 struct address_space *mapping = ip->i_inode.i_mapping;
165 int error = filemap_fdatawait(mapping);
Guillaume Chazarain3e9f45b2007-05-08 00:23:25 -0700166 mapping_set_error(mapping, error);
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500167 }
168 clear_bit(GLF_DIRTY, &gl->gl_flags);
169 gfs2_ail_empty_gl(gl);
170 }
171}
172
173/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000174 * inode_go_xmote_th - promote/demote a glock
175 * @gl: the glock
176 * @state: the requested state
177 * @flags:
178 *
179 */
180
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500181static void inode_go_xmote_th(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000182{
183 if (gl->gl_state != LM_ST_UNLOCKED)
184 gfs2_pte_inval(gl);
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500185 if (gl->gl_state == LM_ST_EXCLUSIVE)
186 inode_go_sync(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000187}
188
189/**
190 * inode_go_xmote_bh - After promoting/demoting a glock
191 * @gl: the glock
192 *
193 */
194
195static void inode_go_xmote_bh(struct gfs2_glock *gl)
196{
197 struct gfs2_holder *gh = gl->gl_req_gh;
198 struct buffer_head *bh;
199 int error;
200
201 if (gl->gl_state != LM_ST_UNLOCKED &&
202 (!gh || !(gh->gh_flags & GL_SKIP))) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400203 error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000204 if (!error)
205 brelse(bh);
206 }
207}
208
209/**
210 * inode_go_drop_th - unlock a glock
211 * @gl: the glock
212 *
213 * Invoked from rq_demote().
214 * Another node needs the lock in EXCLUSIVE mode, or lock (unused for too long)
215 * is being purged from our node's glock cache; we're dropping lock.
216 */
217
218static void inode_go_drop_th(struct gfs2_glock *gl)
219{
220 gfs2_pte_inval(gl);
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500221 if (gl->gl_state == LM_ST_EXCLUSIVE)
222 inode_go_sync(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000223}
224
225/**
226 * inode_go_inval - prepare a inode glock to be released
227 * @gl: the glock
228 * @flags:
229 *
230 */
231
232static void inode_go_inval(struct gfs2_glock *gl, int flags)
233{
Steven Whitehouseb0041572006-11-23 10:51:34 -0500234 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000235 int meta = (flags & DIO_METADATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000236
237 if (meta) {
238 gfs2_meta_inval(gl);
Steven Whitehouseb0041572006-11-23 10:51:34 -0500239 if (ip)
240 set_bit(GIF_INVALID, &ip->i_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000241 }
Steven Whitehouseb0041572006-11-23 10:51:34 -0500242
243 if (ip && S_ISREG(ip->i_inode.i_mode)) {
244 truncate_inode_pages(ip->i_inode.i_mapping, 0);
Steven Whitehouseb0041572006-11-23 10:51:34 -0500245 clear_bit(GIF_PAGED, &ip->i_flags);
246 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000247}
248
249/**
250 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
251 * @gl: the glock
252 *
253 * Returns: 1 if it's ok
254 */
255
256static int inode_go_demote_ok(struct gfs2_glock *gl)
257{
258 struct gfs2_sbd *sdp = gl->gl_sbd;
259 int demote = 0;
260
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500261 if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000262 demote = 1;
263 else if (!sdp->sd_args.ar_localcaching &&
264 time_after_eq(jiffies, gl->gl_stamp +
265 gfs2_tune_get(sdp, gt_demote_secs) * HZ))
266 demote = 1;
267
268 return demote;
269}
270
271/**
272 * inode_go_lock - operation done after an inode lock is locked by a process
273 * @gl: the glock
274 * @flags:
275 *
276 * Returns: errno
277 */
278
279static int inode_go_lock(struct gfs2_holder *gh)
280{
281 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500282 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000283 int error = 0;
284
285 if (!ip)
286 return 0;
287
Steven Whitehousebfded272006-11-01 16:05:38 -0500288 if (test_bit(GIF_INVALID, &ip->i_flags)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000289 error = gfs2_inode_refresh(ip);
290 if (error)
291 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000292 }
293
294 if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
295 (gl->gl_state == LM_ST_EXCLUSIVE) &&
Steven Whitehouse1c0f4872007-01-22 12:10:39 -0500296 (gh->gh_state == LM_ST_EXCLUSIVE))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000297 error = gfs2_truncatei_resume(ip);
298
299 return error;
300}
301
302/**
303 * inode_go_unlock - operation done before an inode lock is unlocked by a
304 * process
305 * @gl: the glock
306 * @flags:
307 *
308 */
309
310static void inode_go_unlock(struct gfs2_holder *gh)
311{
312 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500313 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000314
Steven Whitehouse9e2dbda2006-11-08 15:45:46 -0500315 if (ip)
316 gfs2_meta_cache_flush(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000317}
318
319/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000320 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
321 * @gl: the glock
322 *
323 * Returns: 1 if it's ok
324 */
325
326static int rgrp_go_demote_ok(struct gfs2_glock *gl)
327{
328 return !gl->gl_aspace->i_mapping->nrpages;
329}
330
331/**
332 * rgrp_go_lock - operation done after an rgrp lock is locked by
333 * a first holder on this node.
334 * @gl: the glock
335 * @flags:
336 *
337 * Returns: errno
338 */
339
340static int rgrp_go_lock(struct gfs2_holder *gh)
341{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500342 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000343}
344
345/**
346 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
347 * a last holder on this node.
348 * @gl: the glock
349 * @flags:
350 *
351 */
352
353static void rgrp_go_unlock(struct gfs2_holder *gh)
354{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500355 gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000356}
357
358/**
359 * trans_go_xmote_th - promote/demote the transaction glock
360 * @gl: the glock
361 * @state: the requested state
362 * @flags:
363 *
364 */
365
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500366static void trans_go_xmote_th(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000367{
368 struct gfs2_sbd *sdp = gl->gl_sbd;
369
370 if (gl->gl_state != LM_ST_UNLOCKED &&
371 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
372 gfs2_meta_syncfs(sdp);
373 gfs2_log_shutdown(sdp);
374 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000375}
376
377/**
378 * trans_go_xmote_bh - After promoting/demoting the transaction glock
379 * @gl: the glock
380 *
381 */
382
383static void trans_go_xmote_bh(struct gfs2_glock *gl)
384{
385 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400386 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500387 struct gfs2_glock *j_gl = ip->i_gl;
Al Viro55167622006-10-13 21:47:13 -0400388 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000389 int error;
390
391 if (gl->gl_state != LM_ST_UNLOCKED &&
392 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400393 gfs2_meta_cache_flush(GFS2_I(sdp->sd_jdesc->jd_inode));
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500394 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000395
396 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
397 if (error)
398 gfs2_consist(sdp);
399 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
400 gfs2_consist(sdp);
401
402 /* Initialize some head of the log stuff */
403 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
404 sdp->sd_log_sequence = head.lh_sequence + 1;
405 gfs2_log_pointers_init(sdp, head.lh_blkno);
406 }
407 }
408}
409
410/**
411 * trans_go_drop_th - unlock the transaction glock
412 * @gl: the glock
413 *
414 * We want to sync the device even with localcaching. Remember
415 * that localcaching journal replay only marks buffers dirty.
416 */
417
418static void trans_go_drop_th(struct gfs2_glock *gl)
419{
420 struct gfs2_sbd *sdp = gl->gl_sbd;
421
422 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
423 gfs2_meta_syncfs(sdp);
424 gfs2_log_shutdown(sdp);
425 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000426}
427
428/**
429 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
430 * @gl: the glock
431 *
432 * Returns: 1 if it's ok
433 */
434
435static int quota_go_demote_ok(struct gfs2_glock *gl)
436{
437 return !atomic_read(&gl->gl_lvb_count);
438}
439
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400440const struct gfs2_glock_operations gfs2_meta_glops = {
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500441 .go_xmote_th = meta_go_sync,
442 .go_drop_th = meta_go_sync,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400443 .go_type = LM_TYPE_META,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000444};
445
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400446const struct gfs2_glock_operations gfs2_inode_glops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000447 .go_xmote_th = inode_go_xmote_th,
448 .go_xmote_bh = inode_go_xmote_bh,
449 .go_drop_th = inode_go_drop_th,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000450 .go_inval = inode_go_inval,
451 .go_demote_ok = inode_go_demote_ok,
452 .go_lock = inode_go_lock,
453 .go_unlock = inode_go_unlock,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400454 .go_type = LM_TYPE_INODE,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000455};
456
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400457const struct gfs2_glock_operations gfs2_rgrp_glops = {
Steven Whitehousecad5b932007-02-28 14:03:00 +0000458 .go_xmote_th = meta_go_sync,
459 .go_drop_th = meta_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000460 .go_inval = meta_go_inval,
461 .go_demote_ok = rgrp_go_demote_ok,
462 .go_lock = rgrp_go_lock,
463 .go_unlock = rgrp_go_unlock,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400464 .go_type = LM_TYPE_RGRP,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000465};
466
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400467const struct gfs2_glock_operations gfs2_trans_glops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000468 .go_xmote_th = trans_go_xmote_th,
469 .go_xmote_bh = trans_go_xmote_bh,
470 .go_drop_th = trans_go_drop_th,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400471 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000472};
473
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400474const struct gfs2_glock_operations gfs2_iopen_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400475 .go_type = LM_TYPE_IOPEN,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000476};
477
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400478const struct gfs2_glock_operations gfs2_flock_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400479 .go_type = LM_TYPE_FLOCK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000480};
481
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400482const struct gfs2_glock_operations gfs2_nondisk_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400483 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000484};
485
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400486const struct gfs2_glock_operations gfs2_quota_glops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000487 .go_demote_ok = quota_go_demote_ok,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400488 .go_type = LM_TYPE_QUOTA,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489};
490
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400491const struct gfs2_glock_operations gfs2_journal_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400492 .go_type = LM_TYPE_JOURNAL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000493};
494