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