^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1) // SPDX-License-Identifier: GPL-2.0-only
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3) * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4) * Copyright 2004-2011 Red Hat, Inc.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7) #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9) #include <linux/fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 10) #include <linux/dlm.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 11) #include <linux/slab.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 12) #include <linux/types.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 13) #include <linux/delay.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 14) #include <linux/gfs2_ondisk.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 15) #include <linux/sched/signal.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 16)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 17) #include "incore.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 18) #include "glock.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 19) #include "glops.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 20) #include "recovery.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 21) #include "util.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 22) #include "sys.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 23) #include "trace_gfs2.h"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 24)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 25) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 26) * gfs2_update_stats - Update time based stats
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 27) * @mv: Pointer to mean/variance structure to update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 28) * @sample: New data to include
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 29) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 30) * @delta is the difference between the current rtt sample and the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 31) * running average srtt. We add 1/8 of that to the srtt in order to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 32) * update the current srtt estimate. The variance estimate is a bit
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 33) * more complicated. We subtract the current variance estimate from
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 34) * the abs value of the @delta and add 1/4 of that to the running
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 35) * total. That's equivalent to 3/4 of the current variance
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 36) * estimate plus 1/4 of the abs of @delta.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 37) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 38) * Note that the index points at the array entry containing the smoothed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 39) * mean value, and the variance is always in the following entry
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 40) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 41) * Reference: TCP/IP Illustrated, vol 2, p. 831,832
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 42) * All times are in units of integer nanoseconds. Unlike the TCP/IP case,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 43) * they are not scaled fixed point.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 44) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 45)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 46) static inline void gfs2_update_stats(struct gfs2_lkstats *s, unsigned index,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 47) s64 sample)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 48) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 49) s64 delta = sample - s->stats[index];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 50) s->stats[index] += (delta >> 3);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 51) index++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 52) s->stats[index] += (s64)(abs(delta) - s->stats[index]) >> 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 53) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 54)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 55) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 56) * gfs2_update_reply_times - Update locking statistics
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 57) * @gl: The glock to update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 58) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 59) * This assumes that gl->gl_dstamp has been set earlier.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 60) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 61) * The rtt (lock round trip time) is an estimate of the time
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 62) * taken to perform a dlm lock request. We update it on each
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 63) * reply from the dlm.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 64) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 65) * The blocking flag is set on the glock for all dlm requests
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 66) * which may potentially block due to lock requests from other nodes.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 67) * DLM requests where the current lock state is exclusive, the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 68) * requested state is null (or unlocked) or where the TRY or
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 69) * TRY_1CB flags are set are classified as non-blocking. All
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 70) * other DLM requests are counted as (potentially) blocking.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 71) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 72) static inline void gfs2_update_reply_times(struct gfs2_glock *gl)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 73) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 74) struct gfs2_pcpu_lkstats *lks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 75) const unsigned gltype = gl->gl_name.ln_type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 76) unsigned index = test_bit(GLF_BLOCKING, &gl->gl_flags) ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 77) GFS2_LKS_SRTTB : GFS2_LKS_SRTT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 78) s64 rtt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 79)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 80) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 81) rtt = ktime_to_ns(ktime_sub(ktime_get_real(), gl->gl_dstamp));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 82) lks = this_cpu_ptr(gl->gl_name.ln_sbd->sd_lkstats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 83) gfs2_update_stats(&gl->gl_stats, index, rtt); /* Local */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 84) gfs2_update_stats(&lks->lkstats[gltype], index, rtt); /* Global */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 85) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 86)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 87) trace_gfs2_glock_lock_time(gl, rtt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 88) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 89)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 90) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 91) * gfs2_update_request_times - Update locking statistics
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 92) * @gl: The glock to update
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 93) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 94) * The irt (lock inter-request times) measures the average time
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 95) * between requests to the dlm. It is updated immediately before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 96) * each dlm call.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 97) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 98)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 99) static inline void gfs2_update_request_times(struct gfs2_glock *gl)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 100) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 101) struct gfs2_pcpu_lkstats *lks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 102) const unsigned gltype = gl->gl_name.ln_type;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 103) ktime_t dstamp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 104) s64 irt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 105)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 106) preempt_disable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 107) dstamp = gl->gl_dstamp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 108) gl->gl_dstamp = ktime_get_real();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 109) irt = ktime_to_ns(ktime_sub(gl->gl_dstamp, dstamp));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 110) lks = this_cpu_ptr(gl->gl_name.ln_sbd->sd_lkstats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 111) gfs2_update_stats(&gl->gl_stats, GFS2_LKS_SIRT, irt); /* Local */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 112) gfs2_update_stats(&lks->lkstats[gltype], GFS2_LKS_SIRT, irt); /* Global */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 113) preempt_enable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 114) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 115)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 116) static void gdlm_ast(void *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 117) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 118) struct gfs2_glock *gl = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 119) unsigned ret = gl->gl_state;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 120)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 121) gfs2_update_reply_times(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 122) BUG_ON(gl->gl_lksb.sb_flags & DLM_SBF_DEMOTED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 123)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 124) if ((gl->gl_lksb.sb_flags & DLM_SBF_VALNOTVALID) && gl->gl_lksb.sb_lvbptr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 125) memset(gl->gl_lksb.sb_lvbptr, 0, GDLM_LVB_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 127) switch (gl->gl_lksb.sb_status) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 128) case -DLM_EUNLOCK: /* Unlocked, so glock can be freed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 129) if (gl->gl_ops->go_free)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 130) gl->gl_ops->go_free(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 131) gfs2_glock_free(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 132) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 133) case -DLM_ECANCEL: /* Cancel while getting lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 134) ret |= LM_OUT_CANCELED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 135) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 136) case -EAGAIN: /* Try lock fails */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 137) case -EDEADLK: /* Deadlock detected */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 138) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 139) case -ETIMEDOUT: /* Canceled due to timeout */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 140) ret |= LM_OUT_ERROR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 141) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 142) case 0: /* Success */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 143) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 144) default: /* Something unexpected */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 145) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 146) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 147)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 148) ret = gl->gl_req;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 149) if (gl->gl_lksb.sb_flags & DLM_SBF_ALTMODE) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 150) if (gl->gl_req == LM_ST_SHARED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 151) ret = LM_ST_DEFERRED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 152) else if (gl->gl_req == LM_ST_DEFERRED)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 153) ret = LM_ST_SHARED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 154) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 155) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 156) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 157)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 158) set_bit(GLF_INITIAL, &gl->gl_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 159) gfs2_glock_complete(gl, ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 160) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 161) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 162) if (!test_bit(GLF_INITIAL, &gl->gl_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 163) gl->gl_lksb.sb_lkid = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 164) gfs2_glock_complete(gl, ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 165) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 166)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 167) static void gdlm_bast(void *arg, int mode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 168) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 169) struct gfs2_glock *gl = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 171) switch (mode) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 172) case DLM_LOCK_EX:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 173) gfs2_glock_cb(gl, LM_ST_UNLOCKED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 174) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 175) case DLM_LOCK_CW:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 176) gfs2_glock_cb(gl, LM_ST_DEFERRED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 177) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 178) case DLM_LOCK_PR:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 179) gfs2_glock_cb(gl, LM_ST_SHARED);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 180) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 181) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 182) fs_err(gl->gl_name.ln_sbd, "unknown bast mode %d\n", mode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 183) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 184) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 185) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 186)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 187) /* convert gfs lock-state to dlm lock-mode */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 188)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 189) static int make_mode(struct gfs2_sbd *sdp, const unsigned int lmstate)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 190) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 191) switch (lmstate) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 192) case LM_ST_UNLOCKED:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 193) return DLM_LOCK_NL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 194) case LM_ST_EXCLUSIVE:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 195) return DLM_LOCK_EX;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 196) case LM_ST_DEFERRED:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 197) return DLM_LOCK_CW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 198) case LM_ST_SHARED:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 199) return DLM_LOCK_PR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 200) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 201) fs_err(sdp, "unknown LM state %d\n", lmstate);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 202) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 203) return -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 204) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 205)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 206) static u32 make_flags(struct gfs2_glock *gl, const unsigned int gfs_flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 207) const int req)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 208) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 209) u32 lkf = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 210)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 211) if (gl->gl_lksb.sb_lvbptr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 212) lkf |= DLM_LKF_VALBLK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 213)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 214) if (gfs_flags & LM_FLAG_TRY)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 215) lkf |= DLM_LKF_NOQUEUE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 216)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 217) if (gfs_flags & LM_FLAG_TRY_1CB) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 218) lkf |= DLM_LKF_NOQUEUE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 219) lkf |= DLM_LKF_NOQUEUEBAST;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 220) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 221)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 222) if (gfs_flags & LM_FLAG_PRIORITY) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 223) lkf |= DLM_LKF_NOORDER;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 224) lkf |= DLM_LKF_HEADQUE;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 225) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 226)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 227) if (gfs_flags & LM_FLAG_ANY) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 228) if (req == DLM_LOCK_PR)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 229) lkf |= DLM_LKF_ALTCW;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 230) else if (req == DLM_LOCK_CW)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 231) lkf |= DLM_LKF_ALTPR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 232) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 233) BUG();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 234) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 235)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 236) if (gl->gl_lksb.sb_lkid != 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 237) lkf |= DLM_LKF_CONVERT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 238) if (test_bit(GLF_BLOCKING, &gl->gl_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 239) lkf |= DLM_LKF_QUECVT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 242) return lkf;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 243) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 244)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 245) static void gfs2_reverse_hex(char *c, u64 value)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 246) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 247) *c = '0';
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 248) while (value) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 249) *c-- = hex_asc[value & 0x0f];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 250) value >>= 4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 251) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 252) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 253)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 254) static int gdlm_lock(struct gfs2_glock *gl, unsigned int req_state,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 255) unsigned int flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 256) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 257) struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 258) int req;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 259) u32 lkf;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 260) char strname[GDLM_STRNAME_BYTES] = "";
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 261)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 262) req = make_mode(gl->gl_name.ln_sbd, req_state);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 263) lkf = make_flags(gl, flags, req);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 264) gfs2_glstats_inc(gl, GFS2_LKS_DCOUNT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 265) gfs2_sbstats_inc(gl, GFS2_LKS_DCOUNT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 266) if (gl->gl_lksb.sb_lkid) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 267) gfs2_update_request_times(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 268) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 269) memset(strname, ' ', GDLM_STRNAME_BYTES - 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 270) strname[GDLM_STRNAME_BYTES - 1] = '\0';
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 271) gfs2_reverse_hex(strname + 7, gl->gl_name.ln_type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 272) gfs2_reverse_hex(strname + 23, gl->gl_name.ln_number);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 273) gl->gl_dstamp = ktime_get_real();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 274) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 275) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 276) * Submit the actual lock request.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 277) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 278)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 279) return dlm_lock(ls->ls_dlm, req, &gl->gl_lksb, lkf, strname,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 280) GDLM_STRNAME_BYTES - 1, 0, gdlm_ast, gl, gdlm_bast);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 281) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 282)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 283) static void gdlm_put_lock(struct gfs2_glock *gl)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 284) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 285) struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 286) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 287) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 288)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 289) if (gl->gl_lksb.sb_lkid == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 290) gfs2_glock_free(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 291) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 292) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 294) clear_bit(GLF_BLOCKING, &gl->gl_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 295) gfs2_glstats_inc(gl, GFS2_LKS_DCOUNT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 296) gfs2_sbstats_inc(gl, GFS2_LKS_DCOUNT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 297) gfs2_update_request_times(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 298)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 299) /* don't want to call dlm if we've unmounted the lock protocol */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 300) if (test_bit(DFL_UNMOUNT, &ls->ls_recover_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 301) gfs2_glock_free(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 302) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 303) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 304) /* don't want to skip dlm_unlock writing the lvb when lock has one */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 305)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 306) if (test_bit(SDF_SKIP_DLM_UNLOCK, &sdp->sd_flags) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 307) !gl->gl_lksb.sb_lvbptr) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 308) gfs2_glock_free(gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 309) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 310) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 311)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 312) error = dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_VALBLK,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 313) NULL, gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 314) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 315) fs_err(sdp, "gdlm_unlock %x,%llx err=%d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 316) gl->gl_name.ln_type,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 317) (unsigned long long)gl->gl_name.ln_number, error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 318) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 319) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 320) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 321)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 322) static void gdlm_cancel(struct gfs2_glock *gl)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 323) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 324) struct lm_lockstruct *ls = &gl->gl_name.ln_sbd->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 325) dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_CANCEL, NULL, gl);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 326) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 327)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 328) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 329) * dlm/gfs2 recovery coordination using dlm_recover callbacks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 330) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 331) * 0. gfs2 checks for another cluster node withdraw, needing journal replay
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 332) * 1. dlm_controld sees lockspace members change
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 333) * 2. dlm_controld blocks dlm-kernel locking activity
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 334) * 3. dlm_controld within dlm-kernel notifies gfs2 (recover_prep)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 335) * 4. dlm_controld starts and finishes its own user level recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 336) * 5. dlm_controld starts dlm-kernel dlm_recoverd to do kernel recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 337) * 6. dlm_recoverd notifies gfs2 of failed nodes (recover_slot)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 338) * 7. dlm_recoverd does its own lock recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 339) * 8. dlm_recoverd unblocks dlm-kernel locking activity
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 340) * 9. dlm_recoverd notifies gfs2 when done (recover_done with new generation)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 341) * 10. gfs2_control updates control_lock lvb with new generation and jid bits
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 342) * 11. gfs2_control enqueues journals for gfs2_recover to recover (maybe none)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 343) * 12. gfs2_recover dequeues and recovers journals of failed nodes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 344) * 13. gfs2_recover provides recovery results to gfs2_control (recovery_result)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 345) * 14. gfs2_control updates control_lock lvb jid bits for recovered journals
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 346) * 15. gfs2_control unblocks normal locking when all journals are recovered
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 347) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 348) * - failures during recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 349) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 350) * recover_prep() may set BLOCK_LOCKS (step 3) again before gfs2_control
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 351) * clears BLOCK_LOCKS (step 15), e.g. another node fails while still
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 352) * recovering for a prior failure. gfs2_control needs a way to detect
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 353) * this so it can leave BLOCK_LOCKS set in step 15. This is managed using
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 354) * the recover_block and recover_start values.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 355) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 356) * recover_done() provides a new lockspace generation number each time it
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 357) * is called (step 9). This generation number is saved as recover_start.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 358) * When recover_prep() is called, it sets BLOCK_LOCKS and sets
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 359) * recover_block = recover_start. So, while recover_block is equal to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 360) * recover_start, BLOCK_LOCKS should remain set. (recover_spin must
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 361) * be held around the BLOCK_LOCKS/recover_block/recover_start logic.)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 362) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 363) * - more specific gfs2 steps in sequence above
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 364) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 365) * 3. recover_prep sets BLOCK_LOCKS and sets recover_block = recover_start
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 366) * 6. recover_slot records any failed jids (maybe none)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 367) * 9. recover_done sets recover_start = new generation number
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 368) * 10. gfs2_control sets control_lock lvb = new gen + bits for failed jids
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 369) * 12. gfs2_recover does journal recoveries for failed jids identified above
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 370) * 14. gfs2_control clears control_lock lvb bits for recovered jids
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 371) * 15. gfs2_control checks if recover_block == recover_start (step 3 occured
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 372) * again) then do nothing, otherwise if recover_start > recover_block
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 373) * then clear BLOCK_LOCKS.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 374) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 375) * - parallel recovery steps across all nodes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 376) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 377) * All nodes attempt to update the control_lock lvb with the new generation
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 378) * number and jid bits, but only the first to get the control_lock EX will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 379) * do so; others will see that it's already done (lvb already contains new
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 380) * generation number.)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 381) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 382) * . All nodes get the same recover_prep/recover_slot/recover_done callbacks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 383) * . All nodes attempt to set control_lock lvb gen + bits for the new gen
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 384) * . One node gets control_lock first and writes the lvb, others see it's done
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 385) * . All nodes attempt to recover jids for which they see control_lock bits set
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 386) * . One node succeeds for a jid, and that one clears the jid bit in the lvb
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 387) * . All nodes will eventually see all lvb bits clear and unblock locks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 388) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 389) * - is there a problem with clearing an lvb bit that should be set
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 390) * and missing a journal recovery?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 391) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 392) * 1. jid fails
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 393) * 2. lvb bit set for step 1
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 394) * 3. jid recovered for step 1
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 395) * 4. jid taken again (new mount)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 396) * 5. jid fails (for step 4)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 397) * 6. lvb bit set for step 5 (will already be set)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 398) * 7. lvb bit cleared for step 3
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 399) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 400) * This is not a problem because the failure in step 5 does not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 401) * require recovery, because the mount in step 4 could not have
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 402) * progressed far enough to unblock locks and access the fs. The
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 403) * control_mount() function waits for all recoveries to be complete
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 404) * for the latest lockspace generation before ever unblocking locks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 405) * and returning. The mount in step 4 waits until the recovery in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 406) * step 1 is done.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 407) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 408) * - special case of first mounter: first node to mount the fs
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 409) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 410) * The first node to mount a gfs2 fs needs to check all the journals
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 411) * and recover any that need recovery before other nodes are allowed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 412) * to mount the fs. (Others may begin mounting, but they must wait
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 413) * for the first mounter to be done before taking locks on the fs
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 414) * or accessing the fs.) This has two parts:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 415) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 416) * 1. The mounted_lock tells a node it's the first to mount the fs.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 417) * Each node holds the mounted_lock in PR while it's mounted.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 418) * Each node tries to acquire the mounted_lock in EX when it mounts.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 419) * If a node is granted the mounted_lock EX it means there are no
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 420) * other mounted nodes (no PR locks exist), and it is the first mounter.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 421) * The mounted_lock is demoted to PR when first recovery is done, so
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 422) * others will fail to get an EX lock, but will get a PR lock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 423) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 424) * 2. The control_lock blocks others in control_mount() while the first
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 425) * mounter is doing first mount recovery of all journals.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 426) * A mounting node needs to acquire control_lock in EX mode before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 427) * it can proceed. The first mounter holds control_lock in EX while doing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 428) * the first mount recovery, blocking mounts from other nodes, then demotes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 429) * control_lock to NL when it's done (others_may_mount/first_done),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 430) * allowing other nodes to continue mounting.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 431) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 432) * first mounter:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 433) * control_lock EX/NOQUEUE success
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 434) * mounted_lock EX/NOQUEUE success (no other PR, so no other mounters)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 435) * set first=1
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 436) * do first mounter recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 437) * mounted_lock EX->PR
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 438) * control_lock EX->NL, write lvb generation
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 439) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 440) * other mounter:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 441) * control_lock EX/NOQUEUE success (if fail -EAGAIN, retry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 442) * mounted_lock EX/NOQUEUE fail -EAGAIN (expected due to other mounters PR)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 443) * mounted_lock PR/NOQUEUE success
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 444) * read lvb generation
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 445) * control_lock EX->NL
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 446) * set first=0
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 447) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 448) * - mount during recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 449) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 450) * If a node mounts while others are doing recovery (not first mounter),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 451) * the mounting node will get its initial recover_done() callback without
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 452) * having seen any previous failures/callbacks.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 453) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 454) * It must wait for all recoveries preceding its mount to be finished
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 455) * before it unblocks locks. It does this by repeating the "other mounter"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 456) * steps above until the lvb generation number is >= its mount generation
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 457) * number (from initial recover_done) and all lvb bits are clear.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 458) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 459) * - control_lock lvb format
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 460) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 461) * 4 bytes generation number: the latest dlm lockspace generation number
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 462) * from recover_done callback. Indicates the jid bitmap has been updated
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 463) * to reflect all slot failures through that generation.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 464) * 4 bytes unused.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 465) * GDLM_LVB_SIZE-8 bytes of jid bit map. If bit N is set, it indicates
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 466) * that jid N needs recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 467) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 468)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 469) #define JID_BITMAP_OFFSET 8 /* 4 byte generation number + 4 byte unused */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 470)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 471) static void control_lvb_read(struct lm_lockstruct *ls, uint32_t *lvb_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 472) char *lvb_bits)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 473) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 474) __le32 gen;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 475) memcpy(lvb_bits, ls->ls_control_lvb, GDLM_LVB_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 476) memcpy(&gen, lvb_bits, sizeof(__le32));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 477) *lvb_gen = le32_to_cpu(gen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 478) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 479)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 480) static void control_lvb_write(struct lm_lockstruct *ls, uint32_t lvb_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 481) char *lvb_bits)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 482) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 483) __le32 gen;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 484) memcpy(ls->ls_control_lvb, lvb_bits, GDLM_LVB_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 485) gen = cpu_to_le32(lvb_gen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 486) memcpy(ls->ls_control_lvb, &gen, sizeof(__le32));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 487) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 488)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 489) static int all_jid_bits_clear(char *lvb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 490) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 491) return !memchr_inv(lvb + JID_BITMAP_OFFSET, 0,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 492) GDLM_LVB_SIZE - JID_BITMAP_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 493) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 494)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 495) static void sync_wait_cb(void *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 496) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 497) struct lm_lockstruct *ls = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 498) complete(&ls->ls_sync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 499) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 500)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 501) static int sync_unlock(struct gfs2_sbd *sdp, struct dlm_lksb *lksb, char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 502) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 503) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 504) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 505)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 506) error = dlm_unlock(ls->ls_dlm, lksb->sb_lkid, 0, lksb, ls);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 507) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 508) fs_err(sdp, "%s lkid %x error %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 509) name, lksb->sb_lkid, error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 510) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 511) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 512)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 513) wait_for_completion(&ls->ls_sync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 514)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 515) if (lksb->sb_status != -DLM_EUNLOCK) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 516) fs_err(sdp, "%s lkid %x status %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 517) name, lksb->sb_lkid, lksb->sb_status);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 518) return -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 519) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 520) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 521) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 522)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 523) static int sync_lock(struct gfs2_sbd *sdp, int mode, uint32_t flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 524) unsigned int num, struct dlm_lksb *lksb, char *name)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 525) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 526) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 527) char strname[GDLM_STRNAME_BYTES];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 528) int error, status;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 529)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 530) memset(strname, 0, GDLM_STRNAME_BYTES);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 531) snprintf(strname, GDLM_STRNAME_BYTES, "%8x%16x", LM_TYPE_NONDISK, num);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 532)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 533) error = dlm_lock(ls->ls_dlm, mode, lksb, flags,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 534) strname, GDLM_STRNAME_BYTES - 1,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 535) 0, sync_wait_cb, ls, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 536) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 537) fs_err(sdp, "%s lkid %x flags %x mode %d error %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 538) name, lksb->sb_lkid, flags, mode, error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 539) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 540) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 541)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 542) wait_for_completion(&ls->ls_sync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 543)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 544) status = lksb->sb_status;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 545)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 546) if (status && status != -EAGAIN) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 547) fs_err(sdp, "%s lkid %x flags %x mode %d status %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 548) name, lksb->sb_lkid, flags, mode, status);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 549) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 550)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 551) return status;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 552) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 553)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 554) static int mounted_unlock(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 555) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 556) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 557) return sync_unlock(sdp, &ls->ls_mounted_lksb, "mounted_lock");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 558) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 559)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 560) static int mounted_lock(struct gfs2_sbd *sdp, int mode, uint32_t flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 561) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 562) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 563) return sync_lock(sdp, mode, flags, GFS2_MOUNTED_LOCK,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 564) &ls->ls_mounted_lksb, "mounted_lock");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 565) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 566)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 567) static int control_unlock(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 568) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 569) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 570) return sync_unlock(sdp, &ls->ls_control_lksb, "control_lock");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 571) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 572)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 573) static int control_lock(struct gfs2_sbd *sdp, int mode, uint32_t flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 574) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 575) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 576) return sync_lock(sdp, mode, flags, GFS2_CONTROL_LOCK,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 577) &ls->ls_control_lksb, "control_lock");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 578) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 579)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 580) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 581) * remote_withdraw - react to a node withdrawing from the file system
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 582) * @sdp: The superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 583) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 584) static void remote_withdraw(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 585) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 586) struct gfs2_jdesc *jd;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 587) int ret = 0, count = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 588)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 589) list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 590) if (jd->jd_jid == sdp->sd_lockstruct.ls_jid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 591) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 592) ret = gfs2_recover_journal(jd, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 593) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 594) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 595) count++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 596) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 597)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 598) /* Now drop the additional reference we acquired */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 599) fs_err(sdp, "Journals checked: %d, ret = %d.\n", count, ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 600) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 601)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 602) static void gfs2_control_func(struct work_struct *work)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 603) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 604) struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_control_work.work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 605) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 606) uint32_t block_gen, start_gen, lvb_gen, flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 607) int recover_set = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 608) int write_lvb = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 609) int recover_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 610) int i, error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 611)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 612) /* First check for other nodes that may have done a withdraw. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 613) if (test_bit(SDF_REMOTE_WITHDRAW, &sdp->sd_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 614) remote_withdraw(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 615) clear_bit(SDF_REMOTE_WITHDRAW, &sdp->sd_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 616) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 617) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 618)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 619) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 620) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 621) * No MOUNT_DONE means we're still mounting; control_mount()
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 622) * will set this flag, after which this thread will take over
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 623) * all further clearing of BLOCK_LOCKS.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 624) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 625) * FIRST_MOUNT means this node is doing first mounter recovery,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 626) * for which recovery control is handled by
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 627) * control_mount()/control_first_done(), not this thread.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 628) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 629) if (!test_bit(DFL_MOUNT_DONE, &ls->ls_recover_flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 630) test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 631) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 632) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 633) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 634) block_gen = ls->ls_recover_block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 635) start_gen = ls->ls_recover_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 636) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 637)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 638) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 639) * Equal block_gen and start_gen implies we are between
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 640) * recover_prep and recover_done callbacks, which means
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 641) * dlm recovery is in progress and dlm locking is blocked.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 642) * There's no point trying to do any work until recover_done.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 643) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 644)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 645) if (block_gen == start_gen)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 646) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 647)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 648) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 649) * Propagate recover_submit[] and recover_result[] to lvb:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 650) * dlm_recoverd adds to recover_submit[] jids needing recovery
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 651) * gfs2_recover adds to recover_result[] journal recovery results
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 652) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 653) * set lvb bit for jids in recover_submit[] if the lvb has not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 654) * yet been updated for the generation of the failure
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 655) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 656) * clear lvb bit for jids in recover_result[] if the result of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 657) * the journal recovery is SUCCESS
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 658) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 659)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 660) error = control_lock(sdp, DLM_LOCK_EX, DLM_LKF_CONVERT|DLM_LKF_VALBLK);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 661) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 662) fs_err(sdp, "control lock EX error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 663) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 664) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 665)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 666) control_lvb_read(ls, &lvb_gen, ls->ls_lvb_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 667)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 668) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 669) if (block_gen != ls->ls_recover_block ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 670) start_gen != ls->ls_recover_start) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 671) fs_info(sdp, "recover generation %u block1 %u %u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 672) start_gen, block_gen, ls->ls_recover_block);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 673) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 674) control_lock(sdp, DLM_LOCK_NL, DLM_LKF_CONVERT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 675) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 676) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 677)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 678) recover_size = ls->ls_recover_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 679)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 680) if (lvb_gen <= start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 681) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 682) * Clear lvb bits for jids we've successfully recovered.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 683) * Because all nodes attempt to recover failed journals,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 684) * a journal can be recovered multiple times successfully
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 685) * in succession. Only the first will really do recovery,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 686) * the others find it clean, but still report a successful
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 687) * recovery. So, another node may have already recovered
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 688) * the jid and cleared the lvb bit for it.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 689) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 690) for (i = 0; i < recover_size; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 691) if (ls->ls_recover_result[i] != LM_RD_SUCCESS)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 692) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 693)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 694) ls->ls_recover_result[i] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 695)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 696) if (!test_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 697) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 698)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 699) __clear_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 700) write_lvb = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 701) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 702) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 703)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 704) if (lvb_gen == start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 705) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 706) * Failed slots before start_gen are already set in lvb.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 707) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 708) for (i = 0; i < recover_size; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 709) if (!ls->ls_recover_submit[i])
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 710) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 711) if (ls->ls_recover_submit[i] < lvb_gen)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 712) ls->ls_recover_submit[i] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 713) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 714) } else if (lvb_gen < start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 715) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 716) * Failed slots before start_gen are not yet set in lvb.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 717) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 718) for (i = 0; i < recover_size; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 719) if (!ls->ls_recover_submit[i])
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 720) continue;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 721) if (ls->ls_recover_submit[i] < start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 722) ls->ls_recover_submit[i] = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 723) __set_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 724) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 725) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 726) /* even if there are no bits to set, we need to write the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 727) latest generation to the lvb */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 728) write_lvb = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 729) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 730) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 731) * we should be getting a recover_done() for lvb_gen soon
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 732) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 733) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 734) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 735)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 736) if (write_lvb) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 737) control_lvb_write(ls, start_gen, ls->ls_lvb_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 738) flags = DLM_LKF_CONVERT | DLM_LKF_VALBLK;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 739) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 740) flags = DLM_LKF_CONVERT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 741) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 742)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 743) error = control_lock(sdp, DLM_LOCK_NL, flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 744) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 745) fs_err(sdp, "control lock NL error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 746) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 747) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 748)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 749) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 750) * Everyone will see jid bits set in the lvb, run gfs2_recover_set(),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 751) * and clear a jid bit in the lvb if the recovery is a success.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 752) * Eventually all journals will be recovered, all jid bits will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 753) * be cleared in the lvb, and everyone will clear BLOCK_LOCKS.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 754) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 755)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 756) for (i = 0; i < recover_size; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 757) if (test_bit_le(i, ls->ls_lvb_bits + JID_BITMAP_OFFSET)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 758) fs_info(sdp, "recover generation %u jid %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 759) start_gen, i);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 760) gfs2_recover_set(sdp, i);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 761) recover_set++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 762) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 763) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 764) if (recover_set)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 765) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 766)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 767) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 768) * No more jid bits set in lvb, all recovery is done, unblock locks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 769) * (unless a new recover_prep callback has occured blocking locks
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 770) * again while working above)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 771) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 772)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 773) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 774) if (ls->ls_recover_block == block_gen &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 775) ls->ls_recover_start == start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 776) clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 777) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 778) fs_info(sdp, "recover generation %u done\n", start_gen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 779) gfs2_glock_thaw(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 780) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 781) fs_info(sdp, "recover generation %u block2 %u %u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 782) start_gen, block_gen, ls->ls_recover_block);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 783) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 784) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 785) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 786)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 787) static int control_mount(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 788) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 789) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 790) uint32_t start_gen, block_gen, mount_gen, lvb_gen;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 791) int mounted_mode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 792) int retries = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 793) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 794)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 795) memset(&ls->ls_mounted_lksb, 0, sizeof(struct dlm_lksb));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 796) memset(&ls->ls_control_lksb, 0, sizeof(struct dlm_lksb));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 797) memset(&ls->ls_control_lvb, 0, GDLM_LVB_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 798) ls->ls_control_lksb.sb_lvbptr = ls->ls_control_lvb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 799) init_completion(&ls->ls_sync_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 800)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 801) set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 802)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 803) error = control_lock(sdp, DLM_LOCK_NL, DLM_LKF_VALBLK);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 804) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 805) fs_err(sdp, "control_mount control_lock NL error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 806) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 807) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 808)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 809) error = mounted_lock(sdp, DLM_LOCK_NL, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 810) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 811) fs_err(sdp, "control_mount mounted_lock NL error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 812) control_unlock(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 813) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 814) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 815) mounted_mode = DLM_LOCK_NL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 816)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 817) restart:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 818) if (retries++ && signal_pending(current)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 819) error = -EINTR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 820) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 821) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 822)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 823) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 824) * We always start with both locks in NL. control_lock is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 825) * demoted to NL below so we don't need to do it here.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 826) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 827)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 828) if (mounted_mode != DLM_LOCK_NL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 829) error = mounted_lock(sdp, DLM_LOCK_NL, DLM_LKF_CONVERT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 830) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 831) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 832) mounted_mode = DLM_LOCK_NL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 833) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 834)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 835) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 836) * Other nodes need to do some work in dlm recovery and gfs2_control
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 837) * before the recover_done and control_lock will be ready for us below.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 838) * A delay here is not required but often avoids having to retry.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 839) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 840)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 841) msleep_interruptible(500);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 842)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 843) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 844) * Acquire control_lock in EX and mounted_lock in either EX or PR.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 845) * control_lock lvb keeps track of any pending journal recoveries.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 846) * mounted_lock indicates if any other nodes have the fs mounted.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 847) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 848)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 849) error = control_lock(sdp, DLM_LOCK_EX, DLM_LKF_CONVERT|DLM_LKF_NOQUEUE|DLM_LKF_VALBLK);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 850) if (error == -EAGAIN) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 851) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 852) } else if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 853) fs_err(sdp, "control_mount control_lock EX error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 854) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 855) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 856)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 857) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 858) * If we're a spectator, we don't want to take the lock in EX because
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 859) * we cannot do the first-mount responsibility it implies: recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 860) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 861) if (sdp->sd_args.ar_spectator)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 862) goto locks_done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 863)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 864) error = mounted_lock(sdp, DLM_LOCK_EX, DLM_LKF_CONVERT|DLM_LKF_NOQUEUE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 865) if (!error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 866) mounted_mode = DLM_LOCK_EX;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 867) goto locks_done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 868) } else if (error != -EAGAIN) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 869) fs_err(sdp, "control_mount mounted_lock EX error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 870) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 871) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 872)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 873) error = mounted_lock(sdp, DLM_LOCK_PR, DLM_LKF_CONVERT|DLM_LKF_NOQUEUE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 874) if (!error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 875) mounted_mode = DLM_LOCK_PR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 876) goto locks_done;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 877) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 878) /* not even -EAGAIN should happen here */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 879) fs_err(sdp, "control_mount mounted_lock PR error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 880) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 881) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 882)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 883) locks_done:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 884) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 885) * If we got both locks above in EX, then we're the first mounter.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 886) * If not, then we need to wait for the control_lock lvb to be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 887) * updated by other mounted nodes to reflect our mount generation.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 888) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 889) * In simple first mounter cases, first mounter will see zero lvb_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 890) * but in cases where all existing nodes leave/fail before mounting
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 891) * nodes finish control_mount, then all nodes will be mounting and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 892) * lvb_gen will be non-zero.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 893) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 894)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 895) control_lvb_read(ls, &lvb_gen, ls->ls_lvb_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 896)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 897) if (lvb_gen == 0xFFFFFFFF) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 898) /* special value to force mount attempts to fail */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 899) fs_err(sdp, "control_mount control_lock disabled\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 900) error = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 901) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 902) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 903)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 904) if (mounted_mode == DLM_LOCK_EX) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 905) /* first mounter, keep both EX while doing first recovery */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 906) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 907) clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 908) set_bit(DFL_MOUNT_DONE, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 909) set_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 910) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 911) fs_info(sdp, "first mounter control generation %u\n", lvb_gen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 912) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 913) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 914)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 915) error = control_lock(sdp, DLM_LOCK_NL, DLM_LKF_CONVERT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 916) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 917) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 918)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 919) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 920) * We are not first mounter, now we need to wait for the control_lock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 921) * lvb generation to be >= the generation from our first recover_done
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 922) * and all lvb bits to be clear (no pending journal recoveries.)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 923) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 924)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 925) if (!all_jid_bits_clear(ls->ls_lvb_bits)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 926) /* journals need recovery, wait until all are clear */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 927) fs_info(sdp, "control_mount wait for journal recovery\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 928) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 929) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 930)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 931) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 932) block_gen = ls->ls_recover_block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 933) start_gen = ls->ls_recover_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 934) mount_gen = ls->ls_recover_mount;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 935)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 936) if (lvb_gen < mount_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 937) /* wait for mounted nodes to update control_lock lvb to our
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 938) generation, which might include new recovery bits set */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 939) if (sdp->sd_args.ar_spectator) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 940) fs_info(sdp, "Recovery is required. Waiting for a "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 941) "non-spectator to mount.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 942) msleep_interruptible(1000);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 943) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 944) fs_info(sdp, "control_mount wait1 block %u start %u "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 945) "mount %u lvb %u flags %lx\n", block_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 946) start_gen, mount_gen, lvb_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 947) ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 948) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 949) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 950) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 951) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 952)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 953) if (lvb_gen != start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 954) /* wait for mounted nodes to update control_lock lvb to the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 955) latest recovery generation */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 956) fs_info(sdp, "control_mount wait2 block %u start %u mount %u "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 957) "lvb %u flags %lx\n", block_gen, start_gen, mount_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 958) lvb_gen, ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 959) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 960) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 961) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 962)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 963) if (block_gen == start_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 964) /* dlm recovery in progress, wait for it to finish */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 965) fs_info(sdp, "control_mount wait3 block %u start %u mount %u "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 966) "lvb %u flags %lx\n", block_gen, start_gen, mount_gen,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 967) lvb_gen, ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 968) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 969) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 970) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 971)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 972) clear_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 973) set_bit(DFL_MOUNT_DONE, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 974) memset(ls->ls_recover_submit, 0, ls->ls_recover_size*sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 975) memset(ls->ls_recover_result, 0, ls->ls_recover_size*sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 976) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 977) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 978)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 979) fail:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 980) mounted_unlock(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 981) control_unlock(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 982) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 983) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 984)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 985) static int control_first_done(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 986) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 987) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 988) uint32_t start_gen, block_gen;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 989) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 990)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 991) restart:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 992) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 993) start_gen = ls->ls_recover_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 994) block_gen = ls->ls_recover_block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 995)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 996) if (test_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 997) !test_bit(DFL_MOUNT_DONE, &ls->ls_recover_flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 998) !test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 999) /* sanity check, should not happen */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1000) fs_err(sdp, "control_first_done start %u block %u flags %lx\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1001) start_gen, block_gen, ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1002) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1003) control_unlock(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1004) return -1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1005) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1006)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1007) if (start_gen == block_gen) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1008) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1009) * Wait for the end of a dlm recovery cycle to switch from
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1010) * first mounter recovery. We can ignore any recover_slot
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1011) * callbacks between the recover_prep and next recover_done
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1012) * because we are still the first mounter and any failed nodes
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1013) * have not fully mounted, so they don't need recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1014) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1015) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1016) fs_info(sdp, "control_first_done wait gen %u\n", start_gen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1017)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1018) wait_on_bit(&ls->ls_recover_flags, DFL_DLM_RECOVERY,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1019) TASK_UNINTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1020) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1021) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1022)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1023) clear_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1024) set_bit(DFL_FIRST_MOUNT_DONE, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1025) memset(ls->ls_recover_submit, 0, ls->ls_recover_size*sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1026) memset(ls->ls_recover_result, 0, ls->ls_recover_size*sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1027) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1028)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1029) memset(ls->ls_lvb_bits, 0, GDLM_LVB_SIZE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1030) control_lvb_write(ls, start_gen, ls->ls_lvb_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1031)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1032) error = mounted_lock(sdp, DLM_LOCK_PR, DLM_LKF_CONVERT);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1033) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1034) fs_err(sdp, "control_first_done mounted PR error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1035)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1036) error = control_lock(sdp, DLM_LOCK_NL, DLM_LKF_CONVERT|DLM_LKF_VALBLK);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1037) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1038) fs_err(sdp, "control_first_done control NL error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1039)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1040) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1041) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1043) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1044) * Expand static jid arrays if necessary (by increments of RECOVER_SIZE_INC)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1045) * to accomodate the largest slot number. (NB dlm slot numbers start at 1,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1046) * gfs2 jids start at 0, so jid = slot - 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1047) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1048)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1049) #define RECOVER_SIZE_INC 16
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1050)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1051) static int set_recover_size(struct gfs2_sbd *sdp, struct dlm_slot *slots,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1052) int num_slots)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1053) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1054) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1055) uint32_t *submit = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1056) uint32_t *result = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1057) uint32_t old_size, new_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1058) int i, max_jid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1059)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1060) if (!ls->ls_lvb_bits) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1061) ls->ls_lvb_bits = kzalloc(GDLM_LVB_SIZE, GFP_NOFS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1062) if (!ls->ls_lvb_bits)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1063) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1064) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1065)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1066) max_jid = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1067) for (i = 0; i < num_slots; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1068) if (max_jid < slots[i].slot - 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1069) max_jid = slots[i].slot - 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1070) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1071)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1072) old_size = ls->ls_recover_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1073) new_size = old_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1074) while (new_size < max_jid + 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1075) new_size += RECOVER_SIZE_INC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1076) if (new_size == old_size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1077) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1078)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1079) submit = kcalloc(new_size, sizeof(uint32_t), GFP_NOFS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1080) result = kcalloc(new_size, sizeof(uint32_t), GFP_NOFS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1081) if (!submit || !result) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1082) kfree(submit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1083) kfree(result);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1084) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1085) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1086)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1087) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1088) memcpy(submit, ls->ls_recover_submit, old_size * sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1089) memcpy(result, ls->ls_recover_result, old_size * sizeof(uint32_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1090) kfree(ls->ls_recover_submit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1091) kfree(ls->ls_recover_result);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1092) ls->ls_recover_submit = submit;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1093) ls->ls_recover_result = result;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1094) ls->ls_recover_size = new_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1095) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1096) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1097) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1099) static void free_recover_size(struct lm_lockstruct *ls)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1100) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1101) kfree(ls->ls_lvb_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1102) kfree(ls->ls_recover_submit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1103) kfree(ls->ls_recover_result);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1104) ls->ls_recover_submit = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1105) ls->ls_recover_result = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1106) ls->ls_recover_size = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1107) ls->ls_lvb_bits = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1108) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1109)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1110) /* dlm calls before it does lock recovery */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1111)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1112) static void gdlm_recover_prep(void *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1113) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1114) struct gfs2_sbd *sdp = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1115) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1116)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1117) if (gfs2_withdrawn(sdp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1118) fs_err(sdp, "recover_prep ignored due to withdraw.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1119) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1120) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1121) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1122) ls->ls_recover_block = ls->ls_recover_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1123) set_bit(DFL_DLM_RECOVERY, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1124)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1125) if (!test_bit(DFL_MOUNT_DONE, &ls->ls_recover_flags) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1126) test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1127) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1128) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1129) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1130) set_bit(DFL_BLOCK_LOCKS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1131) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1132) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1133)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1134) /* dlm calls after recover_prep has been completed on all lockspace members;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1135) identifies slot/jid of failed member */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1136)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1137) static void gdlm_recover_slot(void *arg, struct dlm_slot *slot)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1138) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1139) struct gfs2_sbd *sdp = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1140) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1141) int jid = slot->slot - 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1142)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1143) if (gfs2_withdrawn(sdp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1144) fs_err(sdp, "recover_slot jid %d ignored due to withdraw.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1145) jid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1146) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1147) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1148) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1149) if (ls->ls_recover_size < jid + 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1150) fs_err(sdp, "recover_slot jid %d gen %u short size %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1151) jid, ls->ls_recover_block, ls->ls_recover_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1152) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1153) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1154) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1155)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1156) if (ls->ls_recover_submit[jid]) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1157) fs_info(sdp, "recover_slot jid %d gen %u prev %u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1158) jid, ls->ls_recover_block, ls->ls_recover_submit[jid]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1159) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1160) ls->ls_recover_submit[jid] = ls->ls_recover_block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1161) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1162) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1163)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1164) /* dlm calls after recover_slot and after it completes lock recovery */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1165)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1166) static void gdlm_recover_done(void *arg, struct dlm_slot *slots, int num_slots,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1167) int our_slot, uint32_t generation)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1168) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1169) struct gfs2_sbd *sdp = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1170) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1171)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1172) if (gfs2_withdrawn(sdp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1173) fs_err(sdp, "recover_done ignored due to withdraw.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1174) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1175) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1176) /* ensure the ls jid arrays are large enough */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1177) set_recover_size(sdp, slots, num_slots);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1178)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1179) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1180) ls->ls_recover_start = generation;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1181)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1182) if (!ls->ls_recover_mount) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1183) ls->ls_recover_mount = generation;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1184) ls->ls_jid = our_slot - 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1185) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1186)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1187) if (!test_bit(DFL_UNMOUNT, &ls->ls_recover_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1188) queue_delayed_work(gfs2_control_wq, &sdp->sd_control_work, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1189)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1190) clear_bit(DFL_DLM_RECOVERY, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1191) smp_mb__after_atomic();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1192) wake_up_bit(&ls->ls_recover_flags, DFL_DLM_RECOVERY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1193) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1194) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1195)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1196) /* gfs2_recover thread has a journal recovery result */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1197)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1198) static void gdlm_recovery_result(struct gfs2_sbd *sdp, unsigned int jid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1199) unsigned int result)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1200) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1201) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1202)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1203) if (gfs2_withdrawn(sdp)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1204) fs_err(sdp, "recovery_result jid %d ignored due to withdraw.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1205) jid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1206) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1207) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1208) if (test_bit(DFL_NO_DLM_OPS, &ls->ls_recover_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1209) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1210)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1211) /* don't care about the recovery of own journal during mount */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1212) if (jid == ls->ls_jid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1213) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1214)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1215) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1216) if (test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1217) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1218) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1219) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1220) if (ls->ls_recover_size < jid + 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1221) fs_err(sdp, "recovery_result jid %d short size %d\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1222) jid, ls->ls_recover_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1223) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1224) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1225) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1226)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1227) fs_info(sdp, "recover jid %d result %s\n", jid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1228) result == LM_RD_GAVEUP ? "busy" : "success");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1229)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1230) ls->ls_recover_result[jid] = result;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1231)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1232) /* GAVEUP means another node is recovering the journal; delay our
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1233) next attempt to recover it, to give the other node a chance to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1234) finish before trying again */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1235)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1236) if (!test_bit(DFL_UNMOUNT, &ls->ls_recover_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1237) queue_delayed_work(gfs2_control_wq, &sdp->sd_control_work,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1238) result == LM_RD_GAVEUP ? HZ : 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1239) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1240) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1242) static const struct dlm_lockspace_ops gdlm_lockspace_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1243) .recover_prep = gdlm_recover_prep,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1244) .recover_slot = gdlm_recover_slot,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1245) .recover_done = gdlm_recover_done,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1246) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1247)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1248) static int gdlm_mount(struct gfs2_sbd *sdp, const char *table)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1249) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1250) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1251) char cluster[GFS2_LOCKNAME_LEN];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1252) const char *fsname;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1253) uint32_t flags;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1254) int error, ops_result;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1255)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1256) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1257) * initialize everything
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1258) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1259)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1260) INIT_DELAYED_WORK(&sdp->sd_control_work, gfs2_control_func);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1261) spin_lock_init(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1262) ls->ls_recover_flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1263) ls->ls_recover_mount = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1264) ls->ls_recover_start = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1265) ls->ls_recover_block = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1266) ls->ls_recover_size = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1267) ls->ls_recover_submit = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1268) ls->ls_recover_result = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1269) ls->ls_lvb_bits = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1270)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1271) error = set_recover_size(sdp, NULL, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1272) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1273) goto fail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1274)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1275) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1276) * prepare dlm_new_lockspace args
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1277) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1278)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1279) fsname = strchr(table, ':');
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1280) if (!fsname) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1281) fs_info(sdp, "no fsname found\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1282) error = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1283) goto fail_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1284) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1285) memset(cluster, 0, sizeof(cluster));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1286) memcpy(cluster, table, strlen(table) - strlen(fsname));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1287) fsname++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1288)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1289) flags = DLM_LSFL_FS | DLM_LSFL_NEWEXCL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1290)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1291) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1292) * create/join lockspace
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1293) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1294)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1295) error = dlm_new_lockspace(fsname, cluster, flags, GDLM_LVB_SIZE,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1296) &gdlm_lockspace_ops, sdp, &ops_result,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1297) &ls->ls_dlm);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1298) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1299) fs_err(sdp, "dlm_new_lockspace error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1300) goto fail_free;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1301) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1302)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1303) if (ops_result < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1304) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1305) * dlm does not support ops callbacks,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1306) * old dlm_controld/gfs_controld are used, try without ops.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1307) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1308) fs_info(sdp, "dlm lockspace ops not used\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1309) free_recover_size(ls);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1310) set_bit(DFL_NO_DLM_OPS, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1311) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1312) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1313)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1314) if (!test_bit(SDF_NOJOURNALID, &sdp->sd_flags)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1315) fs_err(sdp, "dlm lockspace ops disallow jid preset\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1316) error = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1317) goto fail_release;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1318) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1319)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1320) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1321) * control_mount() uses control_lock to determine first mounter,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1322) * and for later mounts, waits for any recoveries to be cleared.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1323) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1324)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1325) error = control_mount(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1326) if (error) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1327) fs_err(sdp, "mount control error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1328) goto fail_release;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1329) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1330)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1331) ls->ls_first = !!test_bit(DFL_FIRST_MOUNT, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1332) clear_bit(SDF_NOJOURNALID, &sdp->sd_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1333) smp_mb__after_atomic();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1334) wake_up_bit(&sdp->sd_flags, SDF_NOJOURNALID);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1335) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1336)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1337) fail_release:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1338) dlm_release_lockspace(ls->ls_dlm, 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1339) fail_free:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1340) free_recover_size(ls);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1341) fail:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1342) return error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1343) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1344)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1345) static void gdlm_first_done(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1346) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1347) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1348) int error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1349)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1350) if (test_bit(DFL_NO_DLM_OPS, &ls->ls_recover_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1351) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1353) error = control_first_done(sdp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1354) if (error)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1355) fs_err(sdp, "mount first_done error %d\n", error);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1356) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1357)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1358) static void gdlm_unmount(struct gfs2_sbd *sdp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1359) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1360) struct lm_lockstruct *ls = &sdp->sd_lockstruct;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1361)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1362) if (test_bit(DFL_NO_DLM_OPS, &ls->ls_recover_flags))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1363) goto release;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1364)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1365) /* wait for gfs2_control_wq to be done with this mount */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1366)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1367) spin_lock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1368) set_bit(DFL_UNMOUNT, &ls->ls_recover_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1369) spin_unlock(&ls->ls_recover_spin);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1370) flush_delayed_work(&sdp->sd_control_work);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1371)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1372) /* mounted_lock and control_lock will be purged in dlm recovery */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1373) release:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1374) if (ls->ls_dlm) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1375) dlm_release_lockspace(ls->ls_dlm, 2);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1376) ls->ls_dlm = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1377) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1378)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1379) free_recover_size(ls);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1380) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1381)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1382) static const match_table_t dlm_tokens = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1383) { Opt_jid, "jid=%d"},
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1384) { Opt_id, "id=%d"},
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1385) { Opt_first, "first=%d"},
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1386) { Opt_nodir, "nodir=%d"},
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1387) { Opt_err, NULL },
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1388) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1389)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1390) const struct lm_lockops gfs2_dlm_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1391) .lm_proto_name = "lock_dlm",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1392) .lm_mount = gdlm_mount,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1393) .lm_first_done = gdlm_first_done,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1394) .lm_recovery_result = gdlm_recovery_result,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1395) .lm_unmount = gdlm_unmount,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1396) .lm_put_lock = gdlm_put_lock,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1397) .lm_lock = gdlm_lock,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1398) .lm_cancel = gdlm_cancel,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1399) .lm_tokens = &dlm_tokens,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1400) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1401)
Orange Pi5 kernel
Deprecated Linux kernel 5.10.110 for OrangePi 5/5B/5+ boards
3 Commits
0 Branches
0 Tags