1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
7 #include <linux/spinlock.h>
8 #include <linux/completion.h>
9 #include <linux/buffer_head.h>
10 #include <linux/gfs2_ondisk.h>
11 #include <linux/bio.h>
12 #include <linux/posix_acl.h>
13 #include <linux/security.h>
30 struct workqueue_struct
*gfs2_freeze_wq
;
32 extern struct workqueue_struct
*gfs2_control_wq
;
34 static void gfs2_ail_error(struct gfs2_glock
*gl
, const struct buffer_head
*bh
)
36 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
39 "AIL buffer %p: blocknr %llu state 0x%08lx mapping %p page "
41 bh
, (unsigned long long)bh
->b_blocknr
, bh
->b_state
,
42 bh
->b_folio
->mapping
, bh
->b_folio
->flags
);
43 fs_err(sdp
, "AIL glock %u:%llu mapping %p\n",
44 gl
->gl_name
.ln_type
, gl
->gl_name
.ln_number
,
45 gfs2_glock2aspace(gl
));
46 gfs2_lm(sdp
, "AIL error\n");
47 gfs2_withdraw_delayed(sdp
);
51 * __gfs2_ail_flush - remove all buffers for a given lock from the AIL
53 * @fsync: set when called from fsync (not all buffers will be clean)
54 * @nr_revokes: Number of buffers to revoke
56 * None of the buffers should be dirty, locked, or pinned.
59 static void __gfs2_ail_flush(struct gfs2_glock
*gl
, bool fsync
,
60 unsigned int nr_revokes
)
62 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
63 struct list_head
*head
= &gl
->gl_ail_list
;
64 struct gfs2_bufdata
*bd
, *tmp
;
65 struct buffer_head
*bh
;
66 const unsigned long b_state
= (1UL << BH_Dirty
)|(1UL << BH_Pinned
)|(1UL << BH_Lock
);
69 spin_lock(&sdp
->sd_ail_lock
);
70 list_for_each_entry_safe_reverse(bd
, tmp
, head
, bd_ail_gl_list
) {
74 if (bh
->b_state
& b_state
) {
77 gfs2_ail_error(gl
, bh
);
79 gfs2_trans_add_revoke(sdp
, bd
);
82 GLOCK_BUG_ON(gl
, !fsync
&& atomic_read(&gl
->gl_ail_count
));
83 spin_unlock(&sdp
->sd_ail_lock
);
88 static int gfs2_ail_empty_gl(struct gfs2_glock
*gl
)
90 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
95 revokes
= atomic_read(&gl
->gl_ail_count
);
102 * We have nothing on the ail, but there could be revokes on
103 * the sdp revoke queue, in which case, we still want to flush
104 * the log and wait for it to finish.
106 * If the sdp revoke list is empty too, we might still have an
107 * io outstanding for writing revokes, so we should wait for
108 * it before returning.
110 * If none of these conditions are true, our revokes are all
111 * flushed and we can return.
114 have_revokes
= !list_empty(&sdp
->sd_log_revokes
);
115 log_in_flight
= atomic_read(&sdp
->sd_log_in_flight
);
116 gfs2_log_unlock(sdp
);
124 memset(&tr
, 0, sizeof(tr
));
125 set_bit(TR_ONSTACK
, &tr
.tr_flags
);
126 ret
= __gfs2_trans_begin(&tr
, sdp
, 0, revokes
, _RET_IP_
);
128 fs_err(sdp
, "Transaction error %d: Unable to write revokes.", ret
);
131 __gfs2_ail_flush(gl
, 0, revokes
);
136 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
137 GFS2_LFC_AIL_EMPTY_GL
);
141 void gfs2_ail_flush(struct gfs2_glock
*gl
, bool fsync
)
143 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
144 unsigned int revokes
= atomic_read(&gl
->gl_ail_count
);
150 ret
= gfs2_trans_begin(sdp
, 0, revokes
);
153 __gfs2_ail_flush(gl
, fsync
, revokes
);
155 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
160 * gfs2_rgrp_metasync - sync out the metadata of a resource group
161 * @gl: the glock protecting the resource group
165 static int gfs2_rgrp_metasync(struct gfs2_glock
*gl
)
167 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
168 struct address_space
*metamapping
= &sdp
->sd_aspace
;
169 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
170 const unsigned bsize
= sdp
->sd_sb
.sb_bsize
;
171 loff_t start
= (rgd
->rd_addr
* bsize
) & PAGE_MASK
;
172 loff_t end
= PAGE_ALIGN((rgd
->rd_addr
+ rgd
->rd_length
) * bsize
) - 1;
175 filemap_fdatawrite_range(metamapping
, start
, end
);
176 error
= filemap_fdatawait_range(metamapping
, start
, end
);
177 WARN_ON_ONCE(error
&& !gfs2_withdrawn(sdp
));
178 mapping_set_error(metamapping
, error
);
185 * rgrp_go_sync - sync out the metadata for this glock
188 * Called when demoting or unlocking an EX glock. We must flush
189 * to disk all dirty buffers/pages relating to this glock, and must not
190 * return to caller to demote/unlock the glock until I/O is complete.
193 static int rgrp_go_sync(struct gfs2_glock
*gl
)
195 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
196 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
199 if (!rgd
|| !test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
201 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
203 gfs2_log_flush(sdp
, gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
204 GFS2_LFC_RGRP_GO_SYNC
);
205 error
= gfs2_rgrp_metasync(gl
);
207 error
= gfs2_ail_empty_gl(gl
);
208 gfs2_free_clones(rgd
);
213 * rgrp_go_inval - invalidate the metadata for this glock
217 * We never used LM_ST_DEFERRED with resource groups, so that we
218 * should always see the metadata flag set here.
222 static void rgrp_go_inval(struct gfs2_glock
*gl
, int flags
)
224 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
225 struct address_space
*mapping
= &sdp
->sd_aspace
;
226 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
227 const unsigned bsize
= sdp
->sd_sb
.sb_bsize
;
232 start
= (rgd
->rd_addr
* bsize
) & PAGE_MASK
;
233 end
= PAGE_ALIGN((rgd
->rd_addr
+ rgd
->rd_length
) * bsize
) - 1;
234 gfs2_rgrp_brelse(rgd
);
235 WARN_ON_ONCE(!(flags
& DIO_METADATA
));
236 truncate_inode_pages_range(mapping
, start
, end
);
239 static void gfs2_rgrp_go_dump(struct seq_file
*seq
, const struct gfs2_glock
*gl
,
240 const char *fs_id_buf
)
242 struct gfs2_rgrpd
*rgd
= gl
->gl_object
;
245 gfs2_rgrp_dump(seq
, rgd
, fs_id_buf
);
248 static struct gfs2_inode
*gfs2_glock2inode(struct gfs2_glock
*gl
)
250 struct gfs2_inode
*ip
;
252 spin_lock(&gl
->gl_lockref
.lock
);
255 set_bit(GIF_GLOP_PENDING
, &ip
->i_flags
);
256 spin_unlock(&gl
->gl_lockref
.lock
);
260 struct gfs2_rgrpd
*gfs2_glock2rgrp(struct gfs2_glock
*gl
)
262 struct gfs2_rgrpd
*rgd
;
264 spin_lock(&gl
->gl_lockref
.lock
);
266 spin_unlock(&gl
->gl_lockref
.lock
);
271 static void gfs2_clear_glop_pending(struct gfs2_inode
*ip
)
276 clear_bit_unlock(GIF_GLOP_PENDING
, &ip
->i_flags
);
277 wake_up_bit(&ip
->i_flags
, GIF_GLOP_PENDING
);
281 * gfs2_inode_metasync - sync out the metadata of an inode
282 * @gl: the glock protecting the inode
285 int gfs2_inode_metasync(struct gfs2_glock
*gl
)
287 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
290 filemap_fdatawrite(metamapping
);
291 error
= filemap_fdatawait(metamapping
);
293 gfs2_io_error(gl
->gl_name
.ln_sbd
);
298 * inode_go_sync - Sync the dirty metadata of an inode
299 * @gl: the glock protecting the inode
303 static int inode_go_sync(struct gfs2_glock
*gl
)
305 struct gfs2_inode
*ip
= gfs2_glock2inode(gl
);
306 int isreg
= ip
&& S_ISREG(ip
->i_inode
.i_mode
);
307 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
311 if (test_and_clear_bit(GIF_SW_PAGED
, &ip
->i_flags
))
312 unmap_shared_mapping_range(ip
->i_inode
.i_mapping
, 0, 0);
313 inode_dio_wait(&ip
->i_inode
);
315 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
318 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
320 gfs2_log_flush(gl
->gl_name
.ln_sbd
, gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
321 GFS2_LFC_INODE_GO_SYNC
);
322 filemap_fdatawrite(metamapping
);
324 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
325 filemap_fdatawrite(mapping
);
326 error
= filemap_fdatawait(mapping
);
327 mapping_set_error(mapping
, error
);
329 ret
= gfs2_inode_metasync(gl
);
332 ret
= gfs2_ail_empty_gl(gl
);
336 * Writeback of the data mapping may cause the dirty flag to be set
337 * so we have to clear it again here.
339 smp_mb__before_atomic();
340 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
343 gfs2_clear_glop_pending(ip
);
348 * inode_go_inval - prepare a inode glock to be released
352 * Normally we invalidate everything, but if we are moving into
353 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we
354 * can keep hold of the metadata, since it won't have changed.
358 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
360 struct gfs2_inode
*ip
= gfs2_glock2inode(gl
);
362 if (flags
& DIO_METADATA
) {
363 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
364 truncate_inode_pages(mapping
, 0);
366 set_bit(GLF_INSTANTIATE_NEEDED
, &gl
->gl_flags
);
367 forget_all_cached_acls(&ip
->i_inode
);
368 security_inode_invalidate_secctx(&ip
->i_inode
);
369 gfs2_dir_hash_inval(ip
);
373 if (ip
== GFS2_I(gl
->gl_name
.ln_sbd
->sd_rindex
)) {
374 gfs2_log_flush(gl
->gl_name
.ln_sbd
, NULL
,
375 GFS2_LOG_HEAD_FLUSH_NORMAL
|
376 GFS2_LFC_INODE_GO_INVAL
);
377 gl
->gl_name
.ln_sbd
->sd_rindex_uptodate
= 0;
379 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
))
380 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
382 gfs2_clear_glop_pending(ip
);
386 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
389 * Returns: 1 if it's ok
392 static int inode_go_demote_ok(const struct gfs2_glock
*gl
)
394 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
396 if (sdp
->sd_jindex
== gl
->gl_object
|| sdp
->sd_rindex
== gl
->gl_object
)
402 static int gfs2_dinode_in(struct gfs2_inode
*ip
, const void *buf
)
404 struct gfs2_sbd
*sdp
= GFS2_SB(&ip
->i_inode
);
405 const struct gfs2_dinode
*str
= buf
;
406 struct timespec64 atime
;
408 umode_t mode
= be32_to_cpu(str
->di_mode
);
409 struct inode
*inode
= &ip
->i_inode
;
410 bool is_new
= inode
->i_state
& I_NEW
;
412 if (unlikely(ip
->i_no_addr
!= be64_to_cpu(str
->di_num
.no_addr
)))
414 if (unlikely(!is_new
&& inode_wrong_type(inode
, mode
)))
416 ip
->i_no_formal_ino
= be64_to_cpu(str
->di_num
.no_formal_ino
);
417 inode
->i_mode
= mode
;
420 switch (mode
& S_IFMT
) {
423 inode
->i_rdev
= MKDEV(be32_to_cpu(str
->di_major
),
424 be32_to_cpu(str
->di_minor
));
429 i_uid_write(inode
, be32_to_cpu(str
->di_uid
));
430 i_gid_write(inode
, be32_to_cpu(str
->di_gid
));
431 set_nlink(inode
, be32_to_cpu(str
->di_nlink
));
432 i_size_write(inode
, be64_to_cpu(str
->di_size
));
433 gfs2_set_inode_blocks(inode
, be64_to_cpu(str
->di_blocks
));
434 atime
.tv_sec
= be64_to_cpu(str
->di_atime
);
435 atime
.tv_nsec
= be32_to_cpu(str
->di_atime_nsec
);
436 if (timespec64_compare(&inode
->i_atime
, &atime
) < 0)
437 inode
->i_atime
= atime
;
438 inode
->i_mtime
.tv_sec
= be64_to_cpu(str
->di_mtime
);
439 inode
->i_mtime
.tv_nsec
= be32_to_cpu(str
->di_mtime_nsec
);
440 inode_set_ctime(inode
, be64_to_cpu(str
->di_ctime
),
441 be32_to_cpu(str
->di_ctime_nsec
));
443 ip
->i_goal
= be64_to_cpu(str
->di_goal_meta
);
444 ip
->i_generation
= be64_to_cpu(str
->di_generation
);
446 ip
->i_diskflags
= be32_to_cpu(str
->di_flags
);
447 ip
->i_eattr
= be64_to_cpu(str
->di_eattr
);
448 /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */
449 gfs2_set_inode_flags(inode
);
450 height
= be16_to_cpu(str
->di_height
);
451 if (unlikely(height
> sdp
->sd_max_height
))
453 ip
->i_height
= (u8
)height
;
455 depth
= be16_to_cpu(str
->di_depth
);
456 if (unlikely(depth
> GFS2_DIR_MAX_DEPTH
))
458 ip
->i_depth
= (u8
)depth
;
459 ip
->i_entries
= be32_to_cpu(str
->di_entries
);
461 if (gfs2_is_stuffed(ip
) && inode
->i_size
> gfs2_max_stuffed_size(ip
))
464 if (S_ISREG(inode
->i_mode
))
465 gfs2_set_aops(inode
);
469 gfs2_consist_inode(ip
);
474 * gfs2_inode_refresh - Refresh the incore copy of the dinode
475 * @ip: The GFS2 inode
480 int gfs2_inode_refresh(struct gfs2_inode
*ip
)
482 struct buffer_head
*dibh
;
485 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
489 error
= gfs2_dinode_in(ip
, dibh
->b_data
);
495 * inode_go_instantiate - read in an inode if necessary
496 * @gh: The glock holder
501 static int inode_go_instantiate(struct gfs2_glock
*gl
)
503 struct gfs2_inode
*ip
= gl
->gl_object
;
505 if (!ip
) /* no inode to populate - read it in later */
508 return gfs2_inode_refresh(ip
);
511 static int inode_go_held(struct gfs2_holder
*gh
)
513 struct gfs2_glock
*gl
= gh
->gh_gl
;
514 struct gfs2_inode
*ip
= gl
->gl_object
;
517 if (!ip
) /* no inode to populate - read it in later */
520 if (gh
->gh_state
!= LM_ST_DEFERRED
)
521 inode_dio_wait(&ip
->i_inode
);
523 if ((ip
->i_diskflags
& GFS2_DIF_TRUNC_IN_PROG
) &&
524 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
525 (gh
->gh_state
== LM_ST_EXCLUSIVE
))
526 error
= gfs2_truncatei_resume(ip
);
532 * inode_go_dump - print information about an inode
535 * @fs_id_buf: file system id (may be empty)
539 static void inode_go_dump(struct seq_file
*seq
, const struct gfs2_glock
*gl
,
540 const char *fs_id_buf
)
542 struct gfs2_inode
*ip
= gl
->gl_object
;
543 const struct inode
*inode
= &ip
->i_inode
;
548 gfs2_print_dbg(seq
, "%s I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu "
549 "p:%lu\n", fs_id_buf
,
550 (unsigned long long)ip
->i_no_formal_ino
,
551 (unsigned long long)ip
->i_no_addr
,
552 IF2DT(inode
->i_mode
), ip
->i_flags
,
553 (unsigned int)ip
->i_diskflags
,
554 (unsigned long long)i_size_read(inode
),
555 inode
->i_data
.nrpages
);
559 * freeze_go_callback - A cluster node is requesting a freeze
561 * @remote: true if this came from a different cluster node
564 static void freeze_go_callback(struct gfs2_glock
*gl
, bool remote
)
566 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
567 struct super_block
*sb
= sdp
->sd_vfs
;
570 (gl
->gl_state
!= LM_ST_SHARED
&&
571 gl
->gl_state
!= LM_ST_UNLOCKED
) ||
572 gl
->gl_demote_state
!= LM_ST_UNLOCKED
)
576 * Try to get an active super block reference to prevent racing with
577 * unmount (see super_trylock_shared()). But note that unmount isn't
578 * the only place where a write lock on s_umount is taken, and we can
579 * fail here because of things like remount as well.
581 if (down_read_trylock(&sb
->s_umount
)) {
582 atomic_inc(&sb
->s_active
);
583 up_read(&sb
->s_umount
);
584 if (!queue_work(gfs2_freeze_wq
, &sdp
->sd_freeze_work
))
585 deactivate_super(sb
);
590 * freeze_go_xmote_bh - After promoting/demoting the freeze glock
593 static int freeze_go_xmote_bh(struct gfs2_glock
*gl
)
595 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
596 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
597 struct gfs2_glock
*j_gl
= ip
->i_gl
;
598 struct gfs2_log_header_host head
;
601 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
602 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
604 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
, false);
605 if (gfs2_assert_withdraw_delayed(sdp
, !error
))
607 if (gfs2_assert_withdraw_delayed(sdp
, head
.lh_flags
&
608 GFS2_LOG_HEAD_UNMOUNT
))
610 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
611 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
617 * freeze_go_demote_ok
623 static int freeze_go_demote_ok(const struct gfs2_glock
*gl
)
629 * iopen_go_callback - schedule the dcache entry for the inode to be deleted
631 * @remote: true if this came from a different cluster node
633 * gl_lockref.lock lock is held while calling this
635 static void iopen_go_callback(struct gfs2_glock
*gl
, bool remote
)
637 struct gfs2_inode
*ip
= gl
->gl_object
;
638 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
640 if (!remote
|| sb_rdonly(sdp
->sd_vfs
) ||
641 test_bit(SDF_KILL
, &sdp
->sd_flags
))
644 if (gl
->gl_demote_state
== LM_ST_UNLOCKED
&&
645 gl
->gl_state
== LM_ST_SHARED
&& ip
) {
646 gl
->gl_lockref
.count
++;
647 if (!gfs2_queue_try_to_evict(gl
))
648 gl
->gl_lockref
.count
--;
653 * inode_go_free - wake up anyone waiting for dlm's unlock ast to free it
654 * @gl: glock being freed
656 * For now, this is only used for the journal inode glock. In withdraw
657 * situations, we need to wait for the glock to be freed so that we know
658 * other nodes may proceed with recovery / journal replay.
660 static void inode_go_free(struct gfs2_glock
*gl
)
662 /* Note that we cannot reference gl_object because it's already set
663 * to NULL by this point in its lifecycle. */
664 if (!test_bit(GLF_FREEING
, &gl
->gl_flags
))
666 clear_bit_unlock(GLF_FREEING
, &gl
->gl_flags
);
667 wake_up_bit(&gl
->gl_flags
, GLF_FREEING
);
671 * nondisk_go_callback - used to signal when a node did a withdraw
672 * @gl: the nondisk glock
673 * @remote: true if this came from a different cluster node
676 static void nondisk_go_callback(struct gfs2_glock
*gl
, bool remote
)
678 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
680 /* Ignore the callback unless it's from another node, and it's the
682 if (!remote
|| gl
->gl_name
.ln_number
!= GFS2_LIVE_LOCK
)
685 /* First order of business is to cancel the demote request. We don't
686 * really want to demote a nondisk glock. At best it's just to inform
687 * us of another node's withdraw. We'll keep it in SH mode. */
688 clear_bit(GLF_DEMOTE
, &gl
->gl_flags
);
689 clear_bit(GLF_PENDING_DEMOTE
, &gl
->gl_flags
);
691 /* Ignore the unlock if we're withdrawn, unmounting, or in recovery. */
692 if (test_bit(SDF_NORECOVERY
, &sdp
->sd_flags
) ||
693 test_bit(SDF_WITHDRAWN
, &sdp
->sd_flags
) ||
694 test_bit(SDF_REMOTE_WITHDRAW
, &sdp
->sd_flags
))
697 /* We only care when a node wants us to unlock, because that means
698 * they want a journal recovered. */
699 if (gl
->gl_demote_state
!= LM_ST_UNLOCKED
)
702 if (sdp
->sd_args
.ar_spectator
) {
703 fs_warn(sdp
, "Spectator node cannot recover journals.\n");
707 fs_warn(sdp
, "Some node has withdrawn; checking for recovery.\n");
708 set_bit(SDF_REMOTE_WITHDRAW
, &sdp
->sd_flags
);
710 * We can't call remote_withdraw directly here or gfs2_recover_journal
711 * because this is called from the glock unlock function and the
712 * remote_withdraw needs to enqueue and dequeue the same "live" glock
713 * we were called from. So we queue it to the control work queue in
716 queue_delayed_work(gfs2_control_wq
, &sdp
->sd_control_work
, 0);
719 const struct gfs2_glock_operations gfs2_meta_glops
= {
720 .go_type
= LM_TYPE_META
,
721 .go_flags
= GLOF_NONDISK
,
724 const struct gfs2_glock_operations gfs2_inode_glops
= {
725 .go_sync
= inode_go_sync
,
726 .go_inval
= inode_go_inval
,
727 .go_demote_ok
= inode_go_demote_ok
,
728 .go_instantiate
= inode_go_instantiate
,
729 .go_held
= inode_go_held
,
730 .go_dump
= inode_go_dump
,
731 .go_type
= LM_TYPE_INODE
,
732 .go_flags
= GLOF_ASPACE
| GLOF_LRU
| GLOF_LVB
,
733 .go_free
= inode_go_free
,
736 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
737 .go_sync
= rgrp_go_sync
,
738 .go_inval
= rgrp_go_inval
,
739 .go_instantiate
= gfs2_rgrp_go_instantiate
,
740 .go_dump
= gfs2_rgrp_go_dump
,
741 .go_type
= LM_TYPE_RGRP
,
742 .go_flags
= GLOF_LVB
,
745 const struct gfs2_glock_operations gfs2_freeze_glops
= {
746 .go_xmote_bh
= freeze_go_xmote_bh
,
747 .go_demote_ok
= freeze_go_demote_ok
,
748 .go_callback
= freeze_go_callback
,
749 .go_type
= LM_TYPE_NONDISK
,
750 .go_flags
= GLOF_NONDISK
,
753 const struct gfs2_glock_operations gfs2_iopen_glops
= {
754 .go_type
= LM_TYPE_IOPEN
,
755 .go_callback
= iopen_go_callback
,
756 .go_dump
= inode_go_dump
,
757 .go_flags
= GLOF_LRU
| GLOF_NONDISK
,
761 const struct gfs2_glock_operations gfs2_flock_glops
= {
762 .go_type
= LM_TYPE_FLOCK
,
763 .go_flags
= GLOF_LRU
| GLOF_NONDISK
,
766 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
767 .go_type
= LM_TYPE_NONDISK
,
768 .go_flags
= GLOF_NONDISK
,
769 .go_callback
= nondisk_go_callback
,
772 const struct gfs2_glock_operations gfs2_quota_glops
= {
773 .go_type
= LM_TYPE_QUOTA
,
774 .go_flags
= GLOF_LVB
| GLOF_LRU
| GLOF_NONDISK
,
777 const struct gfs2_glock_operations gfs2_journal_glops
= {
778 .go_type
= LM_TYPE_JOURNAL
,
779 .go_flags
= GLOF_NONDISK
,
782 const struct gfs2_glock_operations
*gfs2_glops_list
[] = {
783 [LM_TYPE_META
] = &gfs2_meta_glops
,
784 [LM_TYPE_INODE
] = &gfs2_inode_glops
,
785 [LM_TYPE_RGRP
] = &gfs2_rgrp_glops
,
786 [LM_TYPE_IOPEN
] = &gfs2_iopen_glops
,
787 [LM_TYPE_FLOCK
] = &gfs2_flock_glops
,
788 [LM_TYPE_NONDISK
] = &gfs2_nondisk_glops
,
789 [LM_TYPE_QUOTA
] = &gfs2_quota_glops
,
790 [LM_TYPE_JOURNAL
] = &gfs2_journal_glops
,