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