1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 #include <linux/spinlock.h>
10 #include <linux/completion.h>
11 #include <linux/buffer_head.h>
12 #include <linux/crc32.h>
13 #include <linux/gfs2_ondisk.h>
14 #include <linux/delay.h>
15 #include <linux/uaccess.h>
28 struct kmem_cache *gfs2_glock_cachep __read_mostly;
29 struct kmem_cache *gfs2_glock_aspace_cachep __read_mostly;
30 struct kmem_cache *gfs2_inode_cachep __read_mostly;
31 struct kmem_cache *gfs2_bufdata_cachep __read_mostly;
32 struct kmem_cache *gfs2_rgrpd_cachep __read_mostly;
33 struct kmem_cache *gfs2_quotad_cachep __read_mostly;
34 struct kmem_cache *gfs2_qadata_cachep __read_mostly;
35 struct kmem_cache *gfs2_trans_cachep __read_mostly;
36 mempool_t *gfs2_page_pool __read_mostly;
38 void gfs2_assert_i(struct gfs2_sbd *sdp)
40 fs_emerg(sdp, "fatal assertion failed\n");
44 * check_journal_clean - Make sure a journal is clean for a spectator mount
45 * @sdp: The GFS2 superblock
46 * @jd: The journal descriptor
48 * Returns: 0 if the journal is clean or locked, else an error
50 int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
54 struct gfs2_holder j_gh;
55 struct gfs2_log_header_host head;
56 struct gfs2_inode *ip;
58 ip = GFS2_I(jd->jd_inode);
59 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_NOEXP |
60 GL_EXACT | GL_NOCACHE, &j_gh);
63 fs_err(sdp, "Error %d locking journal for spectator "
67 error = gfs2_jdesc_check(jd);
70 fs_err(sdp, "Error checking journal for spectator "
74 error = gfs2_find_jhead(jd, &head, false);
77 fs_err(sdp, "Error parsing journal for spectator "
81 if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
84 fs_err(sdp, "jid=%u: Journal is dirty, so the first "
85 "mounter must not be a spectator.\n",
90 gfs2_glock_dq_uninit(&j_gh);
95 * gfs2_freeze_lock - hold the freeze glock
96 * @sdp: the superblock
97 * @freeze_gh: pointer to the requested holder
98 * @caller_flags: any additional flags needed by the caller
100 int gfs2_freeze_lock(struct gfs2_sbd *sdp, struct gfs2_holder *freeze_gh,
103 int flags = LM_FLAG_NOEXP | GL_EXACT | caller_flags;
106 error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, flags,
108 if (error && error != GLR_TRYFAILED)
109 fs_err(sdp, "can't lock the freeze lock: %d\n", error);
113 void gfs2_freeze_unlock(struct gfs2_holder *freeze_gh)
115 if (gfs2_holder_initialized(freeze_gh))
116 gfs2_glock_dq_uninit(freeze_gh);
119 static void signal_our_withdraw(struct gfs2_sbd *sdp)
121 struct gfs2_glock *live_gl = sdp->sd_live_gh.gh_gl;
123 struct gfs2_inode *ip;
124 struct gfs2_glock *i_gl;
126 int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
130 if (test_bit(SDF_NORECOVERY, &sdp->sd_flags) || !sdp->sd_jdesc)
133 inode = sdp->sd_jdesc->jd_inode;
136 no_formal_ino = ip->i_no_formal_ino;
138 /* Prevent any glock dq until withdraw recovery is complete */
139 set_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
141 * Don't tell dlm we're bailing until we have no more buffers in the
142 * wind. If journal had an IO error, the log code should just purge
143 * the outstanding buffers rather than submitting new IO. Making the
144 * file system read-only will flush the journal, etc.
146 * During a normal unmount, gfs2_make_fs_ro calls gfs2_log_shutdown
147 * which clears SDF_JOURNAL_LIVE. In a withdraw, we must not write
148 * any UNMOUNT log header, so we can't call gfs2_log_shutdown, and
149 * therefore we need to clear SDF_JOURNAL_LIVE manually.
151 clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
152 if (!sb_rdonly(sdp->sd_vfs)) {
153 struct gfs2_holder freeze_gh;
155 gfs2_holder_mark_uninitialized(&freeze_gh);
156 if (sdp->sd_freeze_gl &&
157 !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) {
158 ret = gfs2_freeze_lock(sdp, &freeze_gh,
159 log_write_allowed ? 0 : LM_FLAG_TRY);
160 if (ret == GLR_TRYFAILED)
164 ret = gfs2_make_fs_ro(sdp);
165 gfs2_freeze_unlock(&freeze_gh);
168 if (sdp->sd_lockstruct.ls_ops->lm_lock == NULL) { /* lock_nolock */
171 clear_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
175 * Drop the glock for our journal so another node can recover it.
177 if (gfs2_holder_initialized(&sdp->sd_journal_gh)) {
178 gfs2_glock_dq_wait(&sdp->sd_journal_gh);
179 gfs2_holder_uninit(&sdp->sd_journal_gh);
181 sdp->sd_jinode_gh.gh_flags |= GL_NOCACHE;
182 gfs2_glock_dq(&sdp->sd_jinode_gh);
183 if (test_bit(SDF_FS_FROZEN, &sdp->sd_flags)) {
184 /* Make sure gfs2_unfreeze works if partially-frozen */
185 flush_workqueue(gfs2_freeze_wq);
186 atomic_set(&sdp->sd_freeze_state, SFS_FROZEN);
187 thaw_super(sdp->sd_vfs);
189 wait_on_bit(&i_gl->gl_flags, GLF_DEMOTE,
190 TASK_UNINTERRUPTIBLE);
194 * holder_uninit to force glock_put, to force dlm to let go
196 gfs2_holder_uninit(&sdp->sd_jinode_gh);
199 * Note: We need to be careful here:
200 * Our iput of jd_inode will evict it. The evict will dequeue its
201 * glock, but the glock dq will wait for the withdraw unless we have
202 * exception code in glock_dq.
206 * Wait until the journal inode's glock is freed. This allows try locks
207 * on other nodes to be successful, otherwise we remain the owner of
208 * the glock as far as dlm is concerned.
210 if (i_gl->gl_ops->go_free) {
211 set_bit(GLF_FREEING, &i_gl->gl_flags);
212 wait_on_bit(&i_gl->gl_flags, GLF_FREEING, TASK_UNINTERRUPTIBLE);
216 * Dequeue the "live" glock, but keep a reference so it's never freed.
218 gfs2_glock_hold(live_gl);
219 gfs2_glock_dq_wait(&sdp->sd_live_gh);
221 * We enqueue the "live" glock in EX so that all other nodes
222 * get a demote request and act on it. We don't really want the
223 * lock in EX, so we send a "try" lock with 1CB to produce a callback.
225 fs_warn(sdp, "Requesting recovery of jid %d.\n",
226 sdp->sd_lockstruct.ls_jid);
227 gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | LM_FLAG_NOEXP,
229 msleep(GL_GLOCK_MAX_HOLD);
231 * This will likely fail in a cluster, but succeed standalone:
233 ret = gfs2_glock_nq(&sdp->sd_live_gh);
236 * If we actually got the "live" lock in EX mode, there are no other
237 * nodes available to replay our journal. So we try to replay it
238 * ourselves. We hold the "live" glock to prevent other mounters
239 * during recovery, then just dequeue it and reacquire it in our
240 * normal SH mode. Just in case the problem that caused us to
241 * withdraw prevents us from recovering our journal (e.g. io errors
242 * and such) we still check if the journal is clean before proceeding
243 * but we may wait forever until another mounter does the recovery.
246 fs_warn(sdp, "No other mounters found. Trying to recover our "
247 "own journal jid %d.\n", sdp->sd_lockstruct.ls_jid);
248 if (gfs2_recover_journal(sdp->sd_jdesc, 1))
249 fs_warn(sdp, "Unable to recover our journal jid %d.\n",
250 sdp->sd_lockstruct.ls_jid);
251 gfs2_glock_dq_wait(&sdp->sd_live_gh);
252 gfs2_holder_reinit(LM_ST_SHARED, LM_FLAG_NOEXP | GL_EXACT,
254 gfs2_glock_nq(&sdp->sd_live_gh);
257 gfs2_glock_queue_put(live_gl); /* drop extra reference we acquired */
258 clear_bit(SDF_WITHDRAW_RECOVERY, &sdp->sd_flags);
261 * At this point our journal is evicted, so we need to get a new inode
262 * for it. Once done, we need to call gfs2_find_jhead which
263 * calls gfs2_map_journal_extents to map it for us again.
265 * Note that we don't really want it to look up a FREE block. The
266 * GFS2_BLKST_FREE simply overrides a block check in gfs2_inode_lookup
267 * which would otherwise fail because it requires grabbing an rgrp
268 * glock, which would fail with -EIO because we're withdrawing.
270 inode = gfs2_inode_lookup(sdp->sd_vfs, DT_UNKNOWN,
271 sdp->sd_jdesc->jd_no_addr, no_formal_ino,
274 fs_warn(sdp, "Reprocessing of jid %d failed with %ld.\n",
275 sdp->sd_lockstruct.ls_jid, PTR_ERR(inode));
278 sdp->sd_jdesc->jd_inode = inode;
281 * Now wait until recovery is complete.
283 for (tries = 0; tries < 10; tries++) {
284 ret = check_journal_clean(sdp, sdp->sd_jdesc, false);
288 fs_warn(sdp, "Waiting for journal recovery jid %d.\n",
289 sdp->sd_lockstruct.ls_jid);
293 fs_warn(sdp, "Journal recovery complete for jid %d.\n",
294 sdp->sd_lockstruct.ls_jid);
296 fs_warn(sdp, "Journal recovery skipped for %d until next "
297 "mount.\n", sdp->sd_lockstruct.ls_jid);
298 fs_warn(sdp, "Glock dequeues delayed: %lu\n", sdp->sd_glock_dqs_held);
299 sdp->sd_glock_dqs_held = 0;
300 wake_up_bit(&sdp->sd_flags, SDF_WITHDRAW_RECOVERY);
303 void gfs2_lm(struct gfs2_sbd *sdp, const char *fmt, ...)
305 struct va_format vaf;
308 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW &&
309 test_bit(SDF_WITHDRAWN, &sdp->sd_flags))
315 fs_err(sdp, "%pV", &vaf);
319 int gfs2_withdraw(struct gfs2_sbd *sdp)
321 struct lm_lockstruct *ls = &sdp->sd_lockstruct;
322 const struct lm_lockops *lm = ls->ls_ops;
324 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW &&
325 test_and_set_bit(SDF_WITHDRAWN, &sdp->sd_flags)) {
326 if (!test_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags))
329 wait_on_bit(&sdp->sd_flags, SDF_WITHDRAW_IN_PROG,
330 TASK_UNINTERRUPTIBLE);
334 set_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags);
336 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW) {
337 fs_err(sdp, "about to withdraw this file system\n");
338 BUG_ON(sdp->sd_args.ar_debug);
340 signal_our_withdraw(sdp);
342 kobject_uevent(&sdp->sd_kobj, KOBJ_OFFLINE);
344 if (!strcmp(sdp->sd_lockstruct.ls_ops->lm_proto_name, "lock_dlm"))
345 wait_for_completion(&sdp->sd_wdack);
347 if (lm->lm_unmount) {
348 fs_err(sdp, "telling LM to unmount\n");
351 set_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags);
352 fs_err(sdp, "File system withdrawn\n");
354 clear_bit(SDF_WITHDRAW_IN_PROG, &sdp->sd_flags);
355 smp_mb__after_atomic();
356 wake_up_bit(&sdp->sd_flags, SDF_WITHDRAW_IN_PROG);
359 if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
360 panic("GFS2: fsid=%s: panic requested\n", sdp->sd_fsname);
366 * gfs2_assert_withdraw_i - Cause the machine to withdraw if @assertion is false
369 void gfs2_assert_withdraw_i(struct gfs2_sbd *sdp, char *assertion,
370 const char *function, char *file, unsigned int line,
373 if (gfs2_withdrawn(sdp))
377 "fatal: assertion \"%s\" failed\n"
378 " function = %s, file = %s, line = %u\n",
379 assertion, function, file, line);
382 * If errors=panic was specified on mount, it won't help to delay the
385 if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
389 gfs2_withdraw_delayed(sdp);
396 * gfs2_assert_warn_i - Print a message to the console if @assertion is false
399 void gfs2_assert_warn_i(struct gfs2_sbd *sdp, char *assertion,
400 const char *function, char *file, unsigned int line)
402 if (time_before(jiffies,
403 sdp->sd_last_warning +
404 gfs2_tune_get(sdp, gt_complain_secs) * HZ))
407 if (sdp->sd_args.ar_errors == GFS2_ERRORS_WITHDRAW)
408 fs_warn(sdp, "warning: assertion \"%s\" failed at function = %s, file = %s, line = %u\n",
409 assertion, function, file, line);
411 if (sdp->sd_args.ar_debug)
416 if (sdp->sd_args.ar_errors == GFS2_ERRORS_PANIC)
417 panic("GFS2: fsid=%s: warning: assertion \"%s\" failed\n"
418 "GFS2: fsid=%s: function = %s, file = %s, line = %u\n",
419 sdp->sd_fsname, assertion,
420 sdp->sd_fsname, function, file, line);
422 sdp->sd_last_warning = jiffies;
426 * gfs2_consist_i - Flag a filesystem consistency error and withdraw
429 void gfs2_consist_i(struct gfs2_sbd *sdp, const char *function,
430 char *file, unsigned int line)
433 "fatal: filesystem consistency error - function = %s, file = %s, line = %u\n",
434 function, file, line);
439 * gfs2_consist_inode_i - Flag an inode consistency error and withdraw
442 void gfs2_consist_inode_i(struct gfs2_inode *ip,
443 const char *function, char *file, unsigned int line)
445 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
448 "fatal: filesystem consistency error\n"
449 " inode = %llu %llu\n"
450 " function = %s, file = %s, line = %u\n",
451 (unsigned long long)ip->i_no_formal_ino,
452 (unsigned long long)ip->i_no_addr,
453 function, file, line);
458 * gfs2_consist_rgrpd_i - Flag a RG consistency error and withdraw
461 void gfs2_consist_rgrpd_i(struct gfs2_rgrpd *rgd,
462 const char *function, char *file, unsigned int line)
464 struct gfs2_sbd *sdp = rgd->rd_sbd;
465 char fs_id_buf[sizeof(sdp->sd_fsname) + 7];
467 sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname);
468 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
470 "fatal: filesystem consistency error\n"
472 " function = %s, file = %s, line = %u\n",
473 (unsigned long long)rgd->rd_addr,
474 function, file, line);
479 * gfs2_meta_check_ii - Flag a magic number consistency error and withdraw
480 * Returns: -1 if this call withdrew the machine,
481 * -2 if it was already withdrawn
484 int gfs2_meta_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
485 const char *type, const char *function, char *file,
491 "fatal: invalid metadata block\n"
493 " function = %s, file = %s, line = %u\n",
494 (unsigned long long)bh->b_blocknr, type,
495 function, file, line);
496 me = gfs2_withdraw(sdp);
497 return (me) ? -1 : -2;
501 * gfs2_metatype_check_ii - Flag a metadata type consistency error and withdraw
502 * Returns: -1 if this call withdrew the machine,
503 * -2 if it was already withdrawn
506 int gfs2_metatype_check_ii(struct gfs2_sbd *sdp, struct buffer_head *bh,
507 u16 type, u16 t, const char *function,
508 char *file, unsigned int line)
513 "fatal: invalid metadata block\n"
514 " bh = %llu (type: exp=%u, found=%u)\n"
515 " function = %s, file = %s, line = %u\n",
516 (unsigned long long)bh->b_blocknr, type, t,
517 function, file, line);
518 me = gfs2_withdraw(sdp);
519 return (me) ? -1 : -2;
523 * gfs2_io_error_i - Flag an I/O error and withdraw
524 * Returns: -1 if this call withdrew the machine,
525 * 0 if it was already withdrawn
528 int gfs2_io_error_i(struct gfs2_sbd *sdp, const char *function, char *file,
533 " function = %s, file = %s, line = %u\n",
534 function, file, line);
535 return gfs2_withdraw(sdp);
539 * gfs2_io_error_bh_i - Flag a buffer I/O error
540 * @withdraw: withdraw the filesystem
543 void gfs2_io_error_bh_i(struct gfs2_sbd *sdp, struct buffer_head *bh,
544 const char *function, char *file, unsigned int line,
547 if (gfs2_withdrawn(sdp))
550 fs_err(sdp, "fatal: I/O error\n"
552 " function = %s, file = %s, line = %u\n",
553 (unsigned long long)bh->b_blocknr, function, file, line);