blob: c6c318c2a0f6d11cc23781d88f3f9c3666fa0ec2 [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Petersoncf45b752008-01-31 10:31:39 -06003 * Copyright (C) 2004-2008 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>
Steven Whitehouse6802e342008-05-21 17:03:22 +010016#include <linux/bio.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000017
18#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000020#include "bmap.h"
21#include "glock.h"
22#include "glops.h"
23#include "inode.h"
24#include "log.h"
25#include "meta_io.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000026#include "recovery.h"
27#include "rgrp.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050028#include "util.h"
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040029#include "trans.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000030
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040031/**
32 * ail_empty_gl - remove all buffers for a given lock from the AIL
33 * @gl: the glock
34 *
35 * None of the buffers should be dirty, locked, or pinned.
36 */
37
38static void gfs2_ail_empty_gl(struct gfs2_glock *gl)
39{
40 struct gfs2_sbd *sdp = gl->gl_sbd;
41 unsigned int blocks;
42 struct list_head *head = &gl->gl_ail_list;
43 struct gfs2_bufdata *bd;
44 struct buffer_head *bh;
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040045 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;
Steven Whitehousef91a0d32007-10-15 16:29:05 +010060 gfs2_remove_from_ail(bd);
Steven Whitehouse1ad38c42007-09-03 11:01:33 +010061 bd->bd_bh = NULL;
62 bh->b_private = NULL;
63 bd->bd_blkno = bh->b_blocknr;
64 gfs2_assert_withdraw(sdp, !buffer_busy(bh));
65 gfs2_trans_add_revoke(sdp, bd);
Steven Whitehouseddacfaf2006-10-03 11:10:41 -040066 }
67 gfs2_assert_withdraw(sdp, !atomic_read(&gl->gl_ail_count));
68 gfs2_log_unlock(sdp);
69
70 gfs2_trans_end(sdp);
71 gfs2_log_flush(sdp, NULL);
72}
Steven Whitehouseba7f7292006-07-26 11:27:10 -040073
74/**
75 * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
76 * @gl: the glock
77 *
78 */
79
80static void gfs2_pte_inval(struct gfs2_glock *gl)
81{
82 struct gfs2_inode *ip;
83 struct inode *inode;
84
85 ip = gl->gl_object;
86 inode = &ip->i_inode;
Steven Whitehouseb60623c2006-11-01 12:22:46 -050087 if (!ip || !S_ISREG(inode->i_mode))
Steven Whitehouseba7f7292006-07-26 11:27:10 -040088 return;
89
Steven Whitehouseba7f7292006-07-26 11:27:10 -040090 unmap_shared_mapping_range(inode->i_mapping, 0, 0);
Steven Whitehouseba7f7292006-07-26 11:27:10 -040091 if (test_bit(GIF_SW_PAGED, &ip->i_flags))
92 set_bit(GLF_DIRTY, &gl->gl_flags);
93
Steven Whitehouseba7f7292006-07-26 11:27:10 -040094}
95
96/**
David Teiglandb3b94fa2006-01-16 16:50:04 +000097 * meta_go_sync - sync out the metadata for this glock
98 * @gl: the glock
David Teiglandb3b94fa2006-01-16 16:50:04 +000099 *
100 * Called when demoting or unlocking an EX glock. We must flush
101 * to disk all dirty buffers/pages relating to this glock, and must not
102 * not return to caller to demote/unlock the glock until I/O is complete.
103 */
104
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500105static void meta_go_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000106{
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500107 if (gl->gl_state != LM_ST_EXCLUSIVE)
108 return;
109
David Teiglandb3b94fa2006-01-16 16:50:04 +0000110 if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) {
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400111 gfs2_log_flush(gl->gl_sbd, gl);
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400112 gfs2_meta_sync(gl);
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500113 gfs2_ail_empty_gl(gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000114 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000115}
116
117/**
118 * meta_go_inval - invalidate the metadata for this glock
119 * @gl: the glock
120 * @flags:
121 *
122 */
123
124static void meta_go_inval(struct gfs2_glock *gl, int flags)
125{
126 if (!(flags & DIO_METADATA))
127 return;
128
129 gfs2_meta_inval(gl);
Bob Petersoncf45b752008-01-31 10:31:39 -0600130 if (gl->gl_object == GFS2_I(gl->gl_sbd->sd_rindex))
131 gl->gl_sbd->sd_rindex_uptodate = 0;
132 else if (gl->gl_ops == &gfs2_rgrp_glops && gl->gl_object) {
133 struct gfs2_rgrpd *rgd = (struct gfs2_rgrpd *)gl->gl_object;
134
135 rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
136 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000137}
138
139/**
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500140 * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
141 * @gl: the glock protecting the inode
142 *
143 */
144
145static void inode_go_sync(struct gfs2_glock *gl)
146{
147 struct gfs2_inode *ip = gl->gl_object;
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000148 struct address_space *metamapping = gl->gl_aspace->i_mapping;
149 int error;
150
151 if (gl->gl_state != LM_ST_UNLOCKED)
152 gfs2_pte_inval(gl);
153 if (gl->gl_state != LM_ST_EXCLUSIVE)
154 return;
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500155
156 if (ip && !S_ISREG(ip->i_inode.i_mode))
157 ip = NULL;
158
159 if (test_bit(GLF_DIRTY, &gl->gl_flags)) {
Benjamin Marzinskib524fe62007-05-02 09:44:03 -0500160 gfs2_log_flush(gl->gl_sbd, gl);
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000161 filemap_fdatawrite(metamapping);
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500162 if (ip) {
163 struct address_space *mapping = ip->i_inode.i_mapping;
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000164 filemap_fdatawrite(mapping);
165 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 }
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000168 error = filemap_fdatawait(metamapping);
169 mapping_set_error(metamapping, error);
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500170 clear_bit(GLF_DIRTY, &gl->gl_flags);
171 gfs2_ail_empty_gl(gl);
172 }
173}
174
175/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000176 * inode_go_inval - prepare a inode glock to be released
177 * @gl: the glock
178 * @flags:
179 *
180 */
181
182static void inode_go_inval(struct gfs2_glock *gl, int flags)
183{
Steven Whitehouseb0041572006-11-23 10:51:34 -0500184 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000185 int meta = (flags & DIO_METADATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000186
187 if (meta) {
188 gfs2_meta_inval(gl);
Steven Whitehouseb0041572006-11-23 10:51:34 -0500189 if (ip)
190 set_bit(GIF_INVALID, &ip->i_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000191 }
Steven Whitehouseb0041572006-11-23 10:51:34 -0500192
Steven Whitehouse3cc3f712007-10-15 15:40:33 +0100193 if (ip && S_ISREG(ip->i_inode.i_mode))
Steven Whitehouseb0041572006-11-23 10:51:34 -0500194 truncate_inode_pages(ip->i_inode.i_mapping, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000195}
196
197/**
198 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
199 * @gl: the glock
200 *
201 * Returns: 1 if it's ok
202 */
203
204static int inode_go_demote_ok(struct gfs2_glock *gl)
205{
206 struct gfs2_sbd *sdp = gl->gl_sbd;
207 int demote = 0;
208
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500209 if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000210 demote = 1;
211 else if (!sdp->sd_args.ar_localcaching &&
212 time_after_eq(jiffies, gl->gl_stamp +
213 gfs2_tune_get(sdp, gt_demote_secs) * HZ))
214 demote = 1;
215
216 return demote;
217}
218
219/**
220 * inode_go_lock - operation done after an inode lock is locked by a process
221 * @gl: the glock
222 * @flags:
223 *
224 * Returns: errno
225 */
226
227static int inode_go_lock(struct gfs2_holder *gh)
228{
229 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500230 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000231 int error = 0;
232
Bob Peterson091806ed2008-04-29 12:35:48 -0500233 if (!ip || (gh->gh_flags & GL_SKIP))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000234 return 0;
235
Steven Whitehousebfded272006-11-01 16:05:38 -0500236 if (test_bit(GIF_INVALID, &ip->i_flags)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000237 error = gfs2_inode_refresh(ip);
238 if (error)
239 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000240 }
241
242 if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
243 (gl->gl_state == LM_ST_EXCLUSIVE) &&
Steven Whitehouse1c0f4872007-01-22 12:10:39 -0500244 (gh->gh_state == LM_ST_EXCLUSIVE))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000245 error = gfs2_truncatei_resume(ip);
246
247 return error;
248}
249
250/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100251 * inode_go_dump - print information about an inode
252 * @seq: The iterator
253 * @ip: the inode
254 *
255 * Returns: 0 on success, -ENOBUFS when we run out of space
256 */
257
258static int inode_go_dump(struct seq_file *seq, const struct gfs2_glock *gl)
259{
260 const struct gfs2_inode *ip = gl->gl_object;
261 if (ip == NULL)
262 return 0;
263 gfs2_print_dbg(seq, " I: n:%llu/%llu t:%u f:0x%08lx\n",
264 (unsigned long long)ip->i_no_formal_ino,
265 (unsigned long long)ip->i_no_addr,
266 IF2DT(ip->i_inode.i_mode), ip->i_flags);
267 return 0;
268}
269
270/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000271 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
272 * @gl: the glock
273 *
274 * Returns: 1 if it's ok
275 */
276
277static int rgrp_go_demote_ok(struct gfs2_glock *gl)
278{
279 return !gl->gl_aspace->i_mapping->nrpages;
280}
281
282/**
283 * rgrp_go_lock - operation done after an rgrp lock is locked by
284 * a first holder on this node.
285 * @gl: the glock
286 * @flags:
287 *
288 * Returns: errno
289 */
290
291static int rgrp_go_lock(struct gfs2_holder *gh)
292{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500293 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000294}
295
296/**
297 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
298 * a last holder on this node.
299 * @gl: the glock
300 * @flags:
301 *
302 */
303
304static void rgrp_go_unlock(struct gfs2_holder *gh)
305{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500306 gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000307}
308
309/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100310 * rgrp_go_dump - print out an rgrp
311 * @seq: The iterator
312 * @gl: The glock in question
313 *
314 */
315
316static int rgrp_go_dump(struct seq_file *seq, const struct gfs2_glock *gl)
317{
318 const struct gfs2_rgrpd *rgd = gl->gl_object;
319 if (rgd == NULL)
320 return 0;
321 gfs2_print_dbg(seq, " R: n:%llu\n", (unsigned long long)rgd->rd_addr);
322 return 0;
323}
324
325/**
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000326 * trans_go_sync - promote/demote the transaction glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000327 * @gl: the glock
328 * @state: the requested state
329 * @flags:
330 *
331 */
332
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000333static void trans_go_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000334{
335 struct gfs2_sbd *sdp = gl->gl_sbd;
336
337 if (gl->gl_state != LM_ST_UNLOCKED &&
338 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
339 gfs2_meta_syncfs(sdp);
340 gfs2_log_shutdown(sdp);
341 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000342}
343
344/**
345 * trans_go_xmote_bh - After promoting/demoting the transaction glock
346 * @gl: the glock
347 *
348 */
349
Steven Whitehouse6802e342008-05-21 17:03:22 +0100350static int trans_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000351{
352 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400353 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500354 struct gfs2_glock *j_gl = ip->i_gl;
Al Viro55167622006-10-13 21:47:13 -0400355 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000356 int error;
357
Steven Whitehouse6802e342008-05-21 17:03:22 +0100358 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500359 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000360
361 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
362 if (error)
363 gfs2_consist(sdp);
364 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
365 gfs2_consist(sdp);
366
367 /* Initialize some head of the log stuff */
368 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
369 sdp->sd_log_sequence = head.lh_sequence + 1;
370 gfs2_log_pointers_init(sdp, head.lh_blkno);
371 }
372 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100373 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000374}
375
376/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000377 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
378 * @gl: the glock
379 *
380 * Returns: 1 if it's ok
381 */
382
383static int quota_go_demote_ok(struct gfs2_glock *gl)
384{
385 return !atomic_read(&gl->gl_lvb_count);
386}
387
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400388const struct gfs2_glock_operations gfs2_meta_glops = {
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500389 .go_xmote_th = meta_go_sync,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400390 .go_type = LM_TYPE_META,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000391};
392
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400393const struct gfs2_glock_operations gfs2_inode_glops = {
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000394 .go_xmote_th = inode_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000395 .go_inval = inode_go_inval,
396 .go_demote_ok = inode_go_demote_ok,
397 .go_lock = inode_go_lock,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100398 .go_dump = inode_go_dump,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400399 .go_type = LM_TYPE_INODE,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100400 .go_min_hold_time = HZ / 5,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000401};
402
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400403const struct gfs2_glock_operations gfs2_rgrp_glops = {
Steven Whitehousecad5b932007-02-28 14:03:00 +0000404 .go_xmote_th = meta_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000405 .go_inval = meta_go_inval,
406 .go_demote_ok = rgrp_go_demote_ok,
407 .go_lock = rgrp_go_lock,
408 .go_unlock = rgrp_go_unlock,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100409 .go_dump = rgrp_go_dump,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400410 .go_type = LM_TYPE_RGRP,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100411 .go_min_hold_time = HZ / 5,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000412};
413
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400414const struct gfs2_glock_operations gfs2_trans_glops = {
Steven Whitehouse3042a2c2007-11-02 08:39:34 +0000415 .go_xmote_th = trans_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000416 .go_xmote_bh = trans_go_xmote_bh,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400417 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000418};
419
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400420const struct gfs2_glock_operations gfs2_iopen_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400421 .go_type = LM_TYPE_IOPEN,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422};
423
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400424const struct gfs2_glock_operations gfs2_flock_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400425 .go_type = LM_TYPE_FLOCK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000426};
427
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400428const struct gfs2_glock_operations gfs2_nondisk_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400429 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000430};
431
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400432const struct gfs2_glock_operations gfs2_quota_glops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000433 .go_demote_ok = quota_go_demote_ok,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400434 .go_type = LM_TYPE_QUOTA,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000435};
436
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400437const struct gfs2_glock_operations gfs2_journal_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400438 .go_type = LM_TYPE_JOURNAL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000439};
440