xref: /openbmc/linux/fs/gfs2/glops.c (revision f42b3800)
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)
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 
423