xref: /openbmc/linux/fs/gfs2/glops.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
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 	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 }
80 
81 /**
82  * gfs2_pte_inval - Sync and invalidate all PTEs associated with a glock
83  * @gl: the glock
84  *
85  */
86 
87 static 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;
94 	if (!ip || !S_ISREG(inode->i_mode))
95 		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 /**
109  * meta_go_sync - sync out the metadata for this glock
110  * @gl: the glock
111  *
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 
117 static void meta_go_sync(struct gfs2_glock *gl)
118 {
119 	if (gl->gl_state != LM_ST_EXCLUSIVE)
120 		return;
121 
122 	if (test_and_clear_bit(GLF_DIRTY, &gl->gl_flags)) {
123 		gfs2_log_flush(gl->gl_sbd, gl);
124 		gfs2_meta_sync(gl);
125 		gfs2_ail_empty_gl(gl);
126 	}
127 }
128 
129 /**
130  * meta_go_inval - invalidate the metadata for this glock
131  * @gl: the glock
132  * @flags:
133  *
134  */
135 
136 static 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 /**
146  * inode_go_sync - Sync the dirty data and/or metadata for an inode glock
147  * @gl: the glock protecting the inode
148  *
149  */
150 
151 static 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);
166 			mapping_set_error(mapping, error);
167 		}
168 		clear_bit(GLF_DIRTY, &gl->gl_flags);
169 		gfs2_ail_empty_gl(gl);
170 	}
171 }
172 
173 /**
174  * inode_go_xmote_th - promote/demote a glock
175  * @gl: the glock
176  * @state: the requested state
177  * @flags:
178  *
179  */
180 
181 static void inode_go_xmote_th(struct gfs2_glock *gl)
182 {
183 	if (gl->gl_state != LM_ST_UNLOCKED)
184 		gfs2_pte_inval(gl);
185 	if (gl->gl_state == LM_ST_EXCLUSIVE)
186 		inode_go_sync(gl);
187 }
188 
189 /**
190  * inode_go_xmote_bh - After promoting/demoting a glock
191  * @gl: the glock
192  *
193  */
194 
195 static 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))) {
203 		error = gfs2_meta_read(gl, gl->gl_name.ln_number, 0, &bh);
204 		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 
218 static void inode_go_drop_th(struct gfs2_glock *gl)
219 {
220 	gfs2_pte_inval(gl);
221 	if (gl->gl_state == LM_ST_EXCLUSIVE)
222 		inode_go_sync(gl);
223 }
224 
225 /**
226  * inode_go_inval - prepare a inode glock to be released
227  * @gl: the glock
228  * @flags:
229  *
230  */
231 
232 static void inode_go_inval(struct gfs2_glock *gl, int flags)
233 {
234 	struct gfs2_inode *ip = gl->gl_object;
235 	int meta = (flags & DIO_METADATA);
236 
237 	if (meta) {
238 		gfs2_meta_inval(gl);
239 		if (ip)
240 			set_bit(GIF_INVALID, &ip->i_flags);
241 	}
242 
243 	if (ip && S_ISREG(ip->i_inode.i_mode)) {
244 		truncate_inode_pages(ip->i_inode.i_mapping, 0);
245 		clear_bit(GIF_PAGED, &ip->i_flags);
246 	}
247 }
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 
256 static int inode_go_demote_ok(struct gfs2_glock *gl)
257 {
258 	struct gfs2_sbd *sdp = gl->gl_sbd;
259 	int demote = 0;
260 
261 	if (!gl->gl_object && !gl->gl_aspace->i_mapping->nrpages)
262 		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 
279 static int inode_go_lock(struct gfs2_holder *gh)
280 {
281 	struct gfs2_glock *gl = gh->gh_gl;
282 	struct gfs2_inode *ip = gl->gl_object;
283 	int error = 0;
284 
285 	if (!ip)
286 		return 0;
287 
288 	if (test_bit(GIF_INVALID, &ip->i_flags)) {
289 		error = gfs2_inode_refresh(ip);
290 		if (error)
291 			return error;
292 	}
293 
294 	if ((ip->i_di.di_flags & GFS2_DIF_TRUNC_IN_PROG) &&
295 	    (gl->gl_state == LM_ST_EXCLUSIVE) &&
296 	    (gh->gh_state == LM_ST_EXCLUSIVE))
297 		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 
310 static void inode_go_unlock(struct gfs2_holder *gh)
311 {
312 	struct gfs2_glock *gl = gh->gh_gl;
313 	struct gfs2_inode *ip = gl->gl_object;
314 
315 	if (ip)
316 		gfs2_meta_cache_flush(ip);
317 }
318 
319 /**
320  * 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 
326 static 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 
340 static int rgrp_go_lock(struct gfs2_holder *gh)
341 {
342 	return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
343 }
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 
353 static void rgrp_go_unlock(struct gfs2_holder *gh)
354 {
355 	gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
356 }
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 
366 static void trans_go_xmote_th(struct gfs2_glock *gl)
367 {
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 	}
375 }
376 
377 /**
378  * trans_go_xmote_bh - After promoting/demoting the transaction glock
379  * @gl: the glock
380  *
381  */
382 
383 static void trans_go_xmote_bh(struct gfs2_glock *gl)
384 {
385 	struct gfs2_sbd *sdp = gl->gl_sbd;
386 	struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
387 	struct gfs2_glock *j_gl = ip->i_gl;
388 	struct gfs2_log_header_host head;
389 	int error;
390 
391 	if (gl->gl_state != LM_ST_UNLOCKED &&
392 	    test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
393 		gfs2_meta_cache_flush(GFS2_I(sdp->sd_jdesc->jd_inode));
394 		j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
395 
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 
418 static 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 	}
426 }
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 
435 static int quota_go_demote_ok(struct gfs2_glock *gl)
436 {
437 	return !atomic_read(&gl->gl_lvb_count);
438 }
439 
440 const struct gfs2_glock_operations gfs2_meta_glops = {
441 	.go_xmote_th = meta_go_sync,
442 	.go_drop_th = meta_go_sync,
443 	.go_type = LM_TYPE_META,
444 };
445 
446 const struct gfs2_glock_operations gfs2_inode_glops = {
447 	.go_xmote_th = inode_go_xmote_th,
448 	.go_xmote_bh = inode_go_xmote_bh,
449 	.go_drop_th = inode_go_drop_th,
450 	.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,
454 	.go_type = LM_TYPE_INODE,
455 };
456 
457 const struct gfs2_glock_operations gfs2_rgrp_glops = {
458 	.go_xmote_th = meta_go_sync,
459 	.go_drop_th = meta_go_sync,
460 	.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,
464 	.go_type = LM_TYPE_RGRP,
465 };
466 
467 const struct gfs2_glock_operations gfs2_trans_glops = {
468 	.go_xmote_th = trans_go_xmote_th,
469 	.go_xmote_bh = trans_go_xmote_bh,
470 	.go_drop_th = trans_go_drop_th,
471 	.go_type = LM_TYPE_NONDISK,
472 };
473 
474 const struct gfs2_glock_operations gfs2_iopen_glops = {
475 	.go_type = LM_TYPE_IOPEN,
476 };
477 
478 const struct gfs2_glock_operations gfs2_flock_glops = {
479 	.go_type = LM_TYPE_FLOCK,
480 };
481 
482 const struct gfs2_glock_operations gfs2_nondisk_glops = {
483 	.go_type = LM_TYPE_NONDISK,
484 };
485 
486 const struct gfs2_glock_operations gfs2_quota_glops = {
487 	.go_demote_ok = quota_go_demote_ok,
488 	.go_type = LM_TYPE_QUOTA,
489 };
490 
491 const struct gfs2_glock_operations gfs2_journal_glops = {
492 	.go_type = LM_TYPE_JOURNAL,
493 };
494 
495