blob: 8522d3aa64fc6032e81abf0cafae92a7f0e002c1 [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 Whitehouse3042a2cc2007-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 Whitehouse3042a2cc2007-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 Whitehouse3042a2cc2007-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 Whitehouse3042a2cc2007-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
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000204static int inode_go_demote_ok(const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000205{
206 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000207 if (sdp->sd_jindex == gl->gl_object || sdp->sd_rindex == gl->gl_object)
208 return 0;
209 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000210}
211
212/**
213 * inode_go_lock - operation done after an inode lock is locked by a process
214 * @gl: the glock
215 * @flags:
216 *
217 * Returns: errno
218 */
219
220static int inode_go_lock(struct gfs2_holder *gh)
221{
222 struct gfs2_glock *gl = gh->gh_gl;
Steven Whitehouse813e0c462008-11-18 13:38:48 +0000223 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500224 struct gfs2_inode *ip = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000225 int error = 0;
226
Bob Peterson091806ed2008-04-29 12:35:48 -0500227 if (!ip || (gh->gh_flags & GL_SKIP))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000228 return 0;
229
Steven Whitehousebfded272006-11-01 16:05:38 -0500230 if (test_bit(GIF_INVALID, &ip->i_flags)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000231 error = gfs2_inode_refresh(ip);
232 if (error)
233 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000234 }
235
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000236 if ((ip->i_diskflags & GFS2_DIF_TRUNC_IN_PROG) &&
David Teiglandb3b94fa2006-01-16 16:50:04 +0000237 (gl->gl_state == LM_ST_EXCLUSIVE) &&
Steven Whitehouse813e0c462008-11-18 13:38:48 +0000238 (gh->gh_state == LM_ST_EXCLUSIVE)) {
239 spin_lock(&sdp->sd_trunc_lock);
240 if (list_empty(&ip->i_trunc_list))
241 list_add(&sdp->sd_trunc_list, &ip->i_trunc_list);
242 spin_unlock(&sdp->sd_trunc_lock);
243 wake_up(&sdp->sd_quota_wait);
244 return 1;
245 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000246
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;
Steven Whitehousefa75ced2008-11-10 10:10:12 +0000263 gfs2_print_dbg(seq, " I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu/%llu\n",
Steven Whitehouse6802e342008-05-21 17:03:22 +0100264 (unsigned long long)ip->i_no_formal_ino,
265 (unsigned long long)ip->i_no_addr,
Steven Whitehousefa75ced2008-11-10 10:10:12 +0000266 IF2DT(ip->i_inode.i_mode), ip->i_flags,
267 (unsigned int)ip->i_diskflags,
268 (unsigned long long)ip->i_inode.i_size,
269 (unsigned long long)ip->i_disksize);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100270 return 0;
271}
272
273/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000274 * rgrp_go_demote_ok - Check to see if it's ok to unlock a RG's glock
275 * @gl: the glock
276 *
277 * Returns: 1 if it's ok
278 */
279
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000280static int rgrp_go_demote_ok(const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000281{
282 return !gl->gl_aspace->i_mapping->nrpages;
283}
284
285/**
286 * rgrp_go_lock - operation done after an rgrp lock is locked by
287 * a first holder on this node.
288 * @gl: the glock
289 * @flags:
290 *
291 * Returns: errno
292 */
293
294static int rgrp_go_lock(struct gfs2_holder *gh)
295{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500296 return gfs2_rgrp_bh_get(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000297}
298
299/**
300 * rgrp_go_unlock - operation done before an rgrp lock is unlocked by
301 * a last holder on this node.
302 * @gl: the glock
303 * @flags:
304 *
305 */
306
307static void rgrp_go_unlock(struct gfs2_holder *gh)
308{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500309 gfs2_rgrp_bh_put(gh->gh_gl->gl_object);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000310}
311
312/**
Steven Whitehouse6802e342008-05-21 17:03:22 +0100313 * rgrp_go_dump - print out an rgrp
314 * @seq: The iterator
315 * @gl: The glock in question
316 *
317 */
318
319static int rgrp_go_dump(struct seq_file *seq, const struct gfs2_glock *gl)
320{
321 const struct gfs2_rgrpd *rgd = gl->gl_object;
322 if (rgd == NULL)
323 return 0;
Steven Whitehousefa75ced2008-11-10 10:10:12 +0000324 gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u\n",
325 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
326 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes);
Steven Whitehouse6802e342008-05-21 17:03:22 +0100327 return 0;
328}
329
330/**
Steven Whitehouse3042a2cc2007-11-02 08:39:34 +0000331 * trans_go_sync - promote/demote the transaction glock
David Teiglandb3b94fa2006-01-16 16:50:04 +0000332 * @gl: the glock
333 * @state: the requested state
334 * @flags:
335 *
336 */
337
Steven Whitehouse3042a2cc2007-11-02 08:39:34 +0000338static void trans_go_sync(struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000339{
340 struct gfs2_sbd *sdp = gl->gl_sbd;
341
342 if (gl->gl_state != LM_ST_UNLOCKED &&
343 test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
344 gfs2_meta_syncfs(sdp);
345 gfs2_log_shutdown(sdp);
346 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000347}
348
349/**
350 * trans_go_xmote_bh - After promoting/demoting the transaction glock
351 * @gl: the glock
352 *
353 */
354
Steven Whitehouse6802e342008-05-21 17:03:22 +0100355static int trans_go_xmote_bh(struct gfs2_glock *gl, struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000356{
357 struct gfs2_sbd *sdp = gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400358 struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500359 struct gfs2_glock *j_gl = ip->i_gl;
Al Viro55167622006-10-13 21:47:13 -0400360 struct gfs2_log_header_host head;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000361 int error;
362
Steven Whitehouse6802e342008-05-21 17:03:22 +0100363 if (test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
Steven Whitehouse1a14d3a2006-11-20 10:37:45 -0500364 j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000365
366 error = gfs2_find_jhead(sdp->sd_jdesc, &head);
367 if (error)
368 gfs2_consist(sdp);
369 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT))
370 gfs2_consist(sdp);
371
372 /* Initialize some head of the log stuff */
373 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) {
374 sdp->sd_log_sequence = head.lh_sequence + 1;
375 gfs2_log_pointers_init(sdp, head.lh_blkno);
376 }
377 }
Steven Whitehouse6802e342008-05-21 17:03:22 +0100378 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000379}
380
381/**
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000382 * trans_go_demote_ok
383 * @gl: the glock
384 *
385 * Always returns 0
386 */
387
388static int trans_go_demote_ok(const struct gfs2_glock *gl)
389{
390 return 0;
391}
392
393/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000394 * quota_go_demote_ok - Check to see if it's ok to unlock a quota glock
395 * @gl: the glock
396 *
397 * Returns: 1 if it's ok
398 */
399
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000400static int quota_go_demote_ok(const struct gfs2_glock *gl)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000401{
402 return !atomic_read(&gl->gl_lvb_count);
403}
404
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400405const struct gfs2_glock_operations gfs2_meta_glops = {
Steven Whitehouseb5d32be2007-01-22 12:15:34 -0500406 .go_xmote_th = meta_go_sync,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400407 .go_type = LM_TYPE_META,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000408};
409
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400410const struct gfs2_glock_operations gfs2_inode_glops = {
Steven Whitehouse3042a2cc2007-11-02 08:39:34 +0000411 .go_xmote_th = inode_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000412 .go_inval = inode_go_inval,
413 .go_demote_ok = inode_go_demote_ok,
414 .go_lock = inode_go_lock,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100415 .go_dump = inode_go_dump,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400416 .go_type = LM_TYPE_INODE,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100417 .go_min_hold_time = HZ / 5,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000418};
419
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400420const struct gfs2_glock_operations gfs2_rgrp_glops = {
Steven Whitehousecad5b932007-02-28 14:03:00 +0000421 .go_xmote_th = meta_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422 .go_inval = meta_go_inval,
423 .go_demote_ok = rgrp_go_demote_ok,
424 .go_lock = rgrp_go_lock,
425 .go_unlock = rgrp_go_unlock,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100426 .go_dump = rgrp_go_dump,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400427 .go_type = LM_TYPE_RGRP,
Steven Whitehouse6802e342008-05-21 17:03:22 +0100428 .go_min_hold_time = HZ / 5,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000429};
430
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400431const struct gfs2_glock_operations gfs2_trans_glops = {
Steven Whitehouse3042a2cc2007-11-02 08:39:34 +0000432 .go_xmote_th = trans_go_sync,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000433 .go_xmote_bh = trans_go_xmote_bh,
Steven Whitehouse97cc10252008-11-20 13:39:47 +0000434 .go_demote_ok = trans_go_demote_ok,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400435 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000436};
437
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400438const struct gfs2_glock_operations gfs2_iopen_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400439 .go_type = LM_TYPE_IOPEN,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000440};
441
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400442const struct gfs2_glock_operations gfs2_flock_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400443 .go_type = LM_TYPE_FLOCK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000444};
445
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400446const struct gfs2_glock_operations gfs2_nondisk_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400447 .go_type = LM_TYPE_NONDISK,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000448};
449
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400450const struct gfs2_glock_operations gfs2_quota_glops = {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000451 .go_demote_ok = quota_go_demote_ok,
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400452 .go_type = LM_TYPE_QUOTA,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000453};
454
Steven Whitehouse8fb4b532006-08-30 09:30:00 -0400455const struct gfs2_glock_operations gfs2_journal_glops = {
Steven Whitehouseea67eed2006-09-05 10:53:09 -0400456 .go_type = LM_TYPE_JOURNAL,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000457};
458