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_page
->mapping
, bh
->b_page
->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_
);
129 __gfs2_ail_flush(gl
, 0, revokes
);
133 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
134 GFS2_LFC_AIL_EMPTY_GL
);
138 void gfs2_ail_flush(struct gfs2_glock
*gl
, bool fsync
)
140 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
141 unsigned int revokes
= atomic_read(&gl
->gl_ail_count
);
147 ret
= gfs2_trans_begin(sdp
, 0, revokes
);
150 __gfs2_ail_flush(gl
, fsync
, revokes
);
152 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
157 * gfs2_rgrp_metasync - sync out the metadata of a resource group
158 * @gl: the glock protecting the resource group
162 static int gfs2_rgrp_metasync(struct gfs2_glock
*gl
)
164 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
165 struct address_space
*metamapping
= &sdp
->sd_aspace
;
166 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
167 const unsigned bsize
= sdp
->sd_sb
.sb_bsize
;
168 loff_t start
= (rgd
->rd_addr
* bsize
) & PAGE_MASK
;
169 loff_t end
= PAGE_ALIGN((rgd
->rd_addr
+ rgd
->rd_length
) * bsize
) - 1;
172 filemap_fdatawrite_range(metamapping
, start
, end
);
173 error
= filemap_fdatawait_range(metamapping
, start
, end
);
174 WARN_ON_ONCE(error
&& !gfs2_withdrawn(sdp
));
175 mapping_set_error(metamapping
, error
);
182 * rgrp_go_sync - sync out the metadata for this glock
185 * Called when demoting or unlocking an EX glock. We must flush
186 * to disk all dirty buffers/pages relating to this glock, and must not
187 * return to caller to demote/unlock the glock until I/O is complete.
190 static int rgrp_go_sync(struct gfs2_glock
*gl
)
192 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
193 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
196 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
198 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
200 gfs2_log_flush(sdp
, gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
201 GFS2_LFC_RGRP_GO_SYNC
);
202 error
= gfs2_rgrp_metasync(gl
);
204 error
= gfs2_ail_empty_gl(gl
);
205 gfs2_free_clones(rgd
);
210 * rgrp_go_inval - invalidate the metadata for this glock
214 * We never used LM_ST_DEFERRED with resource groups, so that we
215 * should always see the metadata flag set here.
219 static void rgrp_go_inval(struct gfs2_glock
*gl
, int flags
)
221 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
222 struct address_space
*mapping
= &sdp
->sd_aspace
;
223 struct gfs2_rgrpd
*rgd
= gfs2_glock2rgrp(gl
);
224 const unsigned bsize
= sdp
->sd_sb
.sb_bsize
;
225 loff_t start
= (rgd
->rd_addr
* bsize
) & PAGE_MASK
;
226 loff_t end
= PAGE_ALIGN((rgd
->rd_addr
+ rgd
->rd_length
) * bsize
) - 1;
228 gfs2_rgrp_brelse(rgd
);
229 WARN_ON_ONCE(!(flags
& DIO_METADATA
));
230 truncate_inode_pages_range(mapping
, start
, end
);
231 rgd
->rd_flags
&= ~GFS2_RDF_UPTODATE
;
234 static void gfs2_rgrp_go_dump(struct seq_file
*seq
, struct gfs2_glock
*gl
,
235 const char *fs_id_buf
)
237 struct gfs2_rgrpd
*rgd
= gl
->gl_object
;
240 gfs2_rgrp_dump(seq
, rgd
, fs_id_buf
);
243 static struct gfs2_inode
*gfs2_glock2inode(struct gfs2_glock
*gl
)
245 struct gfs2_inode
*ip
;
247 spin_lock(&gl
->gl_lockref
.lock
);
250 set_bit(GIF_GLOP_PENDING
, &ip
->i_flags
);
251 spin_unlock(&gl
->gl_lockref
.lock
);
255 struct gfs2_rgrpd
*gfs2_glock2rgrp(struct gfs2_glock
*gl
)
257 struct gfs2_rgrpd
*rgd
;
259 spin_lock(&gl
->gl_lockref
.lock
);
261 spin_unlock(&gl
->gl_lockref
.lock
);
266 static void gfs2_clear_glop_pending(struct gfs2_inode
*ip
)
271 clear_bit_unlock(GIF_GLOP_PENDING
, &ip
->i_flags
);
272 wake_up_bit(&ip
->i_flags
, GIF_GLOP_PENDING
);
276 * gfs2_inode_metasync - sync out the metadata of an inode
277 * @gl: the glock protecting the inode
280 int gfs2_inode_metasync(struct gfs2_glock
*gl
)
282 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
285 filemap_fdatawrite(metamapping
);
286 error
= filemap_fdatawait(metamapping
);
288 gfs2_io_error(gl
->gl_name
.ln_sbd
);
293 * inode_go_sync - Sync the dirty metadata of an inode
294 * @gl: the glock protecting the inode
298 static int inode_go_sync(struct gfs2_glock
*gl
)
300 struct gfs2_inode
*ip
= gfs2_glock2inode(gl
);
301 int isreg
= ip
&& S_ISREG(ip
->i_inode
.i_mode
);
302 struct address_space
*metamapping
= gfs2_glock2aspace(gl
);
306 if (test_and_clear_bit(GIF_SW_PAGED
, &ip
->i_flags
))
307 unmap_shared_mapping_range(ip
->i_inode
.i_mapping
, 0, 0);
308 inode_dio_wait(&ip
->i_inode
);
310 if (!test_and_clear_bit(GLF_DIRTY
, &gl
->gl_flags
))
313 GLOCK_BUG_ON(gl
, gl
->gl_state
!= LM_ST_EXCLUSIVE
);
315 gfs2_log_flush(gl
->gl_name
.ln_sbd
, gl
, GFS2_LOG_HEAD_FLUSH_NORMAL
|
316 GFS2_LFC_INODE_GO_SYNC
);
317 filemap_fdatawrite(metamapping
);
319 struct address_space
*mapping
= ip
->i_inode
.i_mapping
;
320 filemap_fdatawrite(mapping
);
321 error
= filemap_fdatawait(mapping
);
322 mapping_set_error(mapping
, error
);
324 ret
= gfs2_inode_metasync(gl
);
327 gfs2_ail_empty_gl(gl
);
329 * Writeback of the data mapping may cause the dirty flag to be set
330 * so we have to clear it again here.
332 smp_mb__before_atomic();
333 clear_bit(GLF_DIRTY
, &gl
->gl_flags
);
336 gfs2_clear_glop_pending(ip
);
341 * inode_go_inval - prepare a inode glock to be released
345 * Normally we invalidate everything, but if we are moving into
346 * LM_ST_DEFERRED from LM_ST_SHARED or LM_ST_EXCLUSIVE then we
347 * can keep hold of the metadata, since it won't have changed.
351 static void inode_go_inval(struct gfs2_glock
*gl
, int flags
)
353 struct gfs2_inode
*ip
= gfs2_glock2inode(gl
);
355 if (flags
& DIO_METADATA
) {
356 struct address_space
*mapping
= gfs2_glock2aspace(gl
);
357 truncate_inode_pages(mapping
, 0);
359 set_bit(GIF_INVALID
, &ip
->i_flags
);
360 forget_all_cached_acls(&ip
->i_inode
);
361 security_inode_invalidate_secctx(&ip
->i_inode
);
362 gfs2_dir_hash_inval(ip
);
366 if (ip
== GFS2_I(gl
->gl_name
.ln_sbd
->sd_rindex
)) {
367 gfs2_log_flush(gl
->gl_name
.ln_sbd
, NULL
,
368 GFS2_LOG_HEAD_FLUSH_NORMAL
|
369 GFS2_LFC_INODE_GO_INVAL
);
370 gl
->gl_name
.ln_sbd
->sd_rindex_uptodate
= 0;
372 if (ip
&& S_ISREG(ip
->i_inode
.i_mode
))
373 truncate_inode_pages(ip
->i_inode
.i_mapping
, 0);
375 gfs2_clear_glop_pending(ip
);
379 * inode_go_demote_ok - Check to see if it's ok to unlock an inode glock
382 * Returns: 1 if it's ok
385 static int inode_go_demote_ok(const struct gfs2_glock
*gl
)
387 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
389 if (sdp
->sd_jindex
== gl
->gl_object
|| sdp
->sd_rindex
== gl
->gl_object
)
395 static int gfs2_dinode_in(struct gfs2_inode
*ip
, const void *buf
)
397 const struct gfs2_dinode
*str
= buf
;
398 struct timespec64 atime
;
400 umode_t mode
= be32_to_cpu(str
->di_mode
);
401 bool is_new
= ip
->i_inode
.i_state
& I_NEW
;
403 if (unlikely(ip
->i_no_addr
!= be64_to_cpu(str
->di_num
.no_addr
)))
405 if (unlikely(!is_new
&& inode_wrong_type(&ip
->i_inode
, mode
)))
407 ip
->i_no_formal_ino
= be64_to_cpu(str
->di_num
.no_formal_ino
);
408 ip
->i_inode
.i_mode
= mode
;
410 ip
->i_inode
.i_rdev
= 0;
411 switch (mode
& S_IFMT
) {
414 ip
->i_inode
.i_rdev
= MKDEV(be32_to_cpu(str
->di_major
),
415 be32_to_cpu(str
->di_minor
));
420 i_uid_write(&ip
->i_inode
, be32_to_cpu(str
->di_uid
));
421 i_gid_write(&ip
->i_inode
, be32_to_cpu(str
->di_gid
));
422 set_nlink(&ip
->i_inode
, be32_to_cpu(str
->di_nlink
));
423 i_size_write(&ip
->i_inode
, be64_to_cpu(str
->di_size
));
424 gfs2_set_inode_blocks(&ip
->i_inode
, be64_to_cpu(str
->di_blocks
));
425 atime
.tv_sec
= be64_to_cpu(str
->di_atime
);
426 atime
.tv_nsec
= be32_to_cpu(str
->di_atime_nsec
);
427 if (timespec64_compare(&ip
->i_inode
.i_atime
, &atime
) < 0)
428 ip
->i_inode
.i_atime
= atime
;
429 ip
->i_inode
.i_mtime
.tv_sec
= be64_to_cpu(str
->di_mtime
);
430 ip
->i_inode
.i_mtime
.tv_nsec
= be32_to_cpu(str
->di_mtime_nsec
);
431 ip
->i_inode
.i_ctime
.tv_sec
= be64_to_cpu(str
->di_ctime
);
432 ip
->i_inode
.i_ctime
.tv_nsec
= be32_to_cpu(str
->di_ctime_nsec
);
434 ip
->i_goal
= be64_to_cpu(str
->di_goal_meta
);
435 ip
->i_generation
= be64_to_cpu(str
->di_generation
);
437 ip
->i_diskflags
= be32_to_cpu(str
->di_flags
);
438 ip
->i_eattr
= be64_to_cpu(str
->di_eattr
);
439 /* i_diskflags and i_eattr must be set before gfs2_set_inode_flags() */
440 gfs2_set_inode_flags(&ip
->i_inode
);
441 height
= be16_to_cpu(str
->di_height
);
442 if (unlikely(height
> GFS2_MAX_META_HEIGHT
))
444 ip
->i_height
= (u8
)height
;
446 depth
= be16_to_cpu(str
->di_depth
);
447 if (unlikely(depth
> GFS2_DIR_MAX_DEPTH
))
449 ip
->i_depth
= (u8
)depth
;
450 ip
->i_entries
= be32_to_cpu(str
->di_entries
);
452 if (S_ISREG(ip
->i_inode
.i_mode
))
453 gfs2_set_aops(&ip
->i_inode
);
457 gfs2_consist_inode(ip
);
462 * gfs2_inode_refresh - Refresh the incore copy of the dinode
463 * @ip: The GFS2 inode
468 int gfs2_inode_refresh(struct gfs2_inode
*ip
)
470 struct buffer_head
*dibh
;
473 error
= gfs2_meta_inode_buffer(ip
, &dibh
);
477 error
= gfs2_dinode_in(ip
, dibh
->b_data
);
479 clear_bit(GIF_INVALID
, &ip
->i_flags
);
485 * inode_go_lock - operation done after an inode lock is locked by a process
486 * @gh: The glock holder
491 static int inode_go_lock(struct gfs2_holder
*gh
)
493 struct gfs2_glock
*gl
= gh
->gh_gl
;
494 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
495 struct gfs2_inode
*ip
= gl
->gl_object
;
498 if (!ip
|| (gh
->gh_flags
& GL_SKIP
))
501 if (test_bit(GIF_INVALID
, &ip
->i_flags
)) {
502 error
= gfs2_inode_refresh(ip
);
507 if (gh
->gh_state
!= LM_ST_DEFERRED
)
508 inode_dio_wait(&ip
->i_inode
);
510 if ((ip
->i_diskflags
& GFS2_DIF_TRUNC_IN_PROG
) &&
511 (gl
->gl_state
== LM_ST_EXCLUSIVE
) &&
512 (gh
->gh_state
== LM_ST_EXCLUSIVE
)) {
513 spin_lock(&sdp
->sd_trunc_lock
);
514 if (list_empty(&ip
->i_trunc_list
))
515 list_add(&ip
->i_trunc_list
, &sdp
->sd_trunc_list
);
516 spin_unlock(&sdp
->sd_trunc_lock
);
517 wake_up(&sdp
->sd_quota_wait
);
525 * inode_go_dump - print information about an inode
528 * @fs_id_buf: file system id (may be empty)
532 static void inode_go_dump(struct seq_file
*seq
, struct gfs2_glock
*gl
,
533 const char *fs_id_buf
)
535 struct gfs2_inode
*ip
= gl
->gl_object
;
536 struct inode
*inode
= &ip
->i_inode
;
537 unsigned long nrpages
;
542 xa_lock_irq(&inode
->i_data
.i_pages
);
543 nrpages
= inode
->i_data
.nrpages
;
544 xa_unlock_irq(&inode
->i_data
.i_pages
);
546 gfs2_print_dbg(seq
, "%s I: n:%llu/%llu t:%u f:0x%02lx d:0x%08x s:%llu "
547 "p:%lu\n", fs_id_buf
,
548 (unsigned long long)ip
->i_no_formal_ino
,
549 (unsigned long long)ip
->i_no_addr
,
550 IF2DT(ip
->i_inode
.i_mode
), ip
->i_flags
,
551 (unsigned int)ip
->i_diskflags
,
552 (unsigned long long)i_size_read(inode
), nrpages
);
556 * freeze_go_sync - promote/demote the freeze glock
560 static int freeze_go_sync(struct gfs2_glock
*gl
)
563 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
566 * We need to check gl_state == LM_ST_SHARED here and not gl_req ==
567 * LM_ST_EXCLUSIVE. That's because when any node does a freeze,
568 * all the nodes should have the freeze glock in SH mode and they all
569 * call do_xmote: One for EX and the others for UN. They ALL must
570 * freeze locally, and they ALL must queue freeze work. The freeze_work
571 * calls freeze_func, which tries to reacquire the freeze glock in SH,
572 * effectively waiting for the thaw on the node who holds it in EX.
573 * Once thawed, the work func acquires the freeze glock in
574 * SH and everybody goes back to thawed.
576 if (gl
->gl_state
== LM_ST_SHARED
&& !gfs2_withdrawn(sdp
) &&
577 !test_bit(SDF_NORECOVERY
, &sdp
->sd_flags
)) {
578 atomic_set(&sdp
->sd_freeze_state
, SFS_STARTING_FREEZE
);
579 error
= freeze_super(sdp
->sd_vfs
);
581 fs_info(sdp
, "GFS2: couldn't freeze filesystem: %d\n",
583 if (gfs2_withdrawn(sdp
)) {
584 atomic_set(&sdp
->sd_freeze_state
, SFS_UNFROZEN
);
587 gfs2_assert_withdraw(sdp
, 0);
589 queue_work(gfs2_freeze_wq
, &sdp
->sd_freeze_work
);
590 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
))
591 gfs2_log_flush(sdp
, NULL
, GFS2_LOG_HEAD_FLUSH_FREEZE
|
592 GFS2_LFC_FREEZE_GO_SYNC
);
593 else /* read-only mounts */
594 atomic_set(&sdp
->sd_freeze_state
, SFS_FROZEN
);
600 * freeze_go_xmote_bh - After promoting/demoting the freeze glock
603 static int freeze_go_xmote_bh(struct gfs2_glock
*gl
)
605 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
606 struct gfs2_inode
*ip
= GFS2_I(sdp
->sd_jdesc
->jd_inode
);
607 struct gfs2_glock
*j_gl
= ip
->i_gl
;
608 struct gfs2_log_header_host head
;
611 if (test_bit(SDF_JOURNAL_LIVE
, &sdp
->sd_flags
)) {
612 j_gl
->gl_ops
->go_inval(j_gl
, DIO_METADATA
);
614 error
= gfs2_find_jhead(sdp
->sd_jdesc
, &head
, false);
615 if (gfs2_assert_withdraw_delayed(sdp
, !error
))
617 if (gfs2_assert_withdraw_delayed(sdp
, head
.lh_flags
&
618 GFS2_LOG_HEAD_UNMOUNT
))
620 sdp
->sd_log_sequence
= head
.lh_sequence
+ 1;
621 gfs2_log_pointers_init(sdp
, head
.lh_blkno
);
627 * freeze_go_demote_ok
633 static int freeze_go_demote_ok(const struct gfs2_glock
*gl
)
639 * iopen_go_callback - schedule the dcache entry for the inode to be deleted
641 * @remote: true if this came from a different cluster node
643 * gl_lockref.lock lock is held while calling this
645 static void iopen_go_callback(struct gfs2_glock
*gl
, bool remote
)
647 struct gfs2_inode
*ip
= gl
->gl_object
;
648 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
650 if (!remote
|| sb_rdonly(sdp
->sd_vfs
))
653 if (gl
->gl_demote_state
== LM_ST_UNLOCKED
&&
654 gl
->gl_state
== LM_ST_SHARED
&& ip
) {
655 gl
->gl_lockref
.count
++;
656 if (!queue_delayed_work(gfs2_delete_workqueue
,
658 gl
->gl_lockref
.count
--;
662 static int iopen_go_demote_ok(const struct gfs2_glock
*gl
)
664 return !gfs2_delete_work_queued(gl
);
668 * inode_go_free - wake up anyone waiting for dlm's unlock ast to free it
669 * @gl: glock being freed
671 * For now, this is only used for the journal inode glock. In withdraw
672 * situations, we need to wait for the glock to be freed so that we know
673 * other nodes may proceed with recovery / journal replay.
675 static void inode_go_free(struct gfs2_glock
*gl
)
677 /* Note that we cannot reference gl_object because it's already set
678 * to NULL by this point in its lifecycle. */
679 if (!test_bit(GLF_FREEING
, &gl
->gl_flags
))
681 clear_bit_unlock(GLF_FREEING
, &gl
->gl_flags
);
682 wake_up_bit(&gl
->gl_flags
, GLF_FREEING
);
686 * nondisk_go_callback - used to signal when a node did a withdraw
687 * @gl: the nondisk glock
688 * @remote: true if this came from a different cluster node
691 static void nondisk_go_callback(struct gfs2_glock
*gl
, bool remote
)
693 struct gfs2_sbd
*sdp
= gl
->gl_name
.ln_sbd
;
695 /* Ignore the callback unless it's from another node, and it's the
697 if (!remote
|| gl
->gl_name
.ln_number
!= GFS2_LIVE_LOCK
)
700 /* First order of business is to cancel the demote request. We don't
701 * really want to demote a nondisk glock. At best it's just to inform
702 * us of another node's withdraw. We'll keep it in SH mode. */
703 clear_bit(GLF_DEMOTE
, &gl
->gl_flags
);
704 clear_bit(GLF_PENDING_DEMOTE
, &gl
->gl_flags
);
706 /* Ignore the unlock if we're withdrawn, unmounting, or in recovery. */
707 if (test_bit(SDF_NORECOVERY
, &sdp
->sd_flags
) ||
708 test_bit(SDF_WITHDRAWN
, &sdp
->sd_flags
) ||
709 test_bit(SDF_REMOTE_WITHDRAW
, &sdp
->sd_flags
))
712 /* We only care when a node wants us to unlock, because that means
713 * they want a journal recovered. */
714 if (gl
->gl_demote_state
!= LM_ST_UNLOCKED
)
717 if (sdp
->sd_args
.ar_spectator
) {
718 fs_warn(sdp
, "Spectator node cannot recover journals.\n");
722 fs_warn(sdp
, "Some node has withdrawn; checking for recovery.\n");
723 set_bit(SDF_REMOTE_WITHDRAW
, &sdp
->sd_flags
);
725 * We can't call remote_withdraw directly here or gfs2_recover_journal
726 * because this is called from the glock unlock function and the
727 * remote_withdraw needs to enqueue and dequeue the same "live" glock
728 * we were called from. So we queue it to the control work queue in
731 queue_delayed_work(gfs2_control_wq
, &sdp
->sd_control_work
, 0);
734 const struct gfs2_glock_operations gfs2_meta_glops
= {
735 .go_type
= LM_TYPE_META
,
736 .go_flags
= GLOF_NONDISK
,
739 const struct gfs2_glock_operations gfs2_inode_glops
= {
740 .go_sync
= inode_go_sync
,
741 .go_inval
= inode_go_inval
,
742 .go_demote_ok
= inode_go_demote_ok
,
743 .go_lock
= inode_go_lock
,
744 .go_dump
= inode_go_dump
,
745 .go_type
= LM_TYPE_INODE
,
746 .go_flags
= GLOF_ASPACE
| GLOF_LRU
| GLOF_LVB
,
747 .go_free
= inode_go_free
,
750 const struct gfs2_glock_operations gfs2_rgrp_glops
= {
751 .go_sync
= rgrp_go_sync
,
752 .go_inval
= rgrp_go_inval
,
753 .go_lock
= gfs2_rgrp_go_lock
,
754 .go_dump
= gfs2_rgrp_go_dump
,
755 .go_type
= LM_TYPE_RGRP
,
756 .go_flags
= GLOF_LVB
,
759 const struct gfs2_glock_operations gfs2_freeze_glops
= {
760 .go_sync
= freeze_go_sync
,
761 .go_xmote_bh
= freeze_go_xmote_bh
,
762 .go_demote_ok
= freeze_go_demote_ok
,
763 .go_type
= LM_TYPE_NONDISK
,
764 .go_flags
= GLOF_NONDISK
,
767 const struct gfs2_glock_operations gfs2_iopen_glops
= {
768 .go_type
= LM_TYPE_IOPEN
,
769 .go_callback
= iopen_go_callback
,
770 .go_demote_ok
= iopen_go_demote_ok
,
771 .go_flags
= GLOF_LRU
| GLOF_NONDISK
,
775 const struct gfs2_glock_operations gfs2_flock_glops
= {
776 .go_type
= LM_TYPE_FLOCK
,
777 .go_flags
= GLOF_LRU
| GLOF_NONDISK
,
780 const struct gfs2_glock_operations gfs2_nondisk_glops
= {
781 .go_type
= LM_TYPE_NONDISK
,
782 .go_flags
= GLOF_NONDISK
,
783 .go_callback
= nondisk_go_callback
,
786 const struct gfs2_glock_operations gfs2_quota_glops
= {
787 .go_type
= LM_TYPE_QUOTA
,
788 .go_flags
= GLOF_LVB
| GLOF_LRU
| GLOF_NONDISK
,
791 const struct gfs2_glock_operations gfs2_journal_glops
= {
792 .go_type
= LM_TYPE_JOURNAL
,
793 .go_flags
= GLOF_NONDISK
,
796 const struct gfs2_glock_operations
*gfs2_glops_list
[] = {
797 [LM_TYPE_META
] = &gfs2_meta_glops
,
798 [LM_TYPE_INODE
] = &gfs2_inode_glops
,
799 [LM_TYPE_RGRP
] = &gfs2_rgrp_glops
,
800 [LM_TYPE_IOPEN
] = &gfs2_iopen_glops
,
801 [LM_TYPE_FLOCK
] = &gfs2_flock_glops
,
802 [LM_TYPE_NONDISK
] = &gfs2_nondisk_glops
,
803 [LM_TYPE_QUOTA
] = &gfs2_quota_glops
,
804 [LM_TYPE_JOURNAL
] = &gfs2_journal_glops
,