* [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages
@ 2025-08-29 11:07 Alessio Attilio
2025-08-29 13:53 ` Alexander Aring
2025-08-29 18:05 ` David Teigland
0 siblings, 2 replies; 4+ messages in thread
From: Alessio Attilio @ 2025-08-29 11:07 UTC (permalink / raw)
To: Alexander Aring, David Teigland; +Cc: gfs2, linux-kernel, Alessio Attilio
---
fs/dlm/lock.c | 8067 ++++++++++++++++++++++++-------------------------
1 file changed, 3944 insertions(+), 4123 deletions(-)
diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
index 6dd3a524cd35..4dfde93f4056 100644
--- a/fs/dlm/lock.c
+++ b/fs/dlm/lock.c
@@ -977,7 +977,6 @@ static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
request; this should never happen */
log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
from_nodeid, r->res_master_nodeid, dir_nodeid);
- dlm_print_rsb(r);
write_unlock_bh(&ls->ls_rsbtbl_lock);
error = -ENOTBLK;
goto out;
@@ -1008,16 +1007,54 @@ static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
* rsb not found
*/
+ if (error == -EBADR && !create)
+ goto out;
+
error = get_rsb_struct(ls, name, len, &r);
if (WARN_ON_ONCE(error))
goto out;
r->res_hash = hash;
r->res_dir_nodeid = dir_nodeid;
- r->res_master_nodeid = dir_nodeid;
- r->res_nodeid = (dir_nodeid == our_nodeid) ? 0 : dir_nodeid;
kref_init(&r->res_ref);
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
+ }
+
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
+ }
+
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
+
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
+
+ out_add:
+
write_lock_bh(&ls->ls_rsbtbl_lock);
error = rsb_insert(r, &ls->ls_rsbtbl);
if (error == -EEXIST) {
@@ -1031,269 +1068,196 @@ static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
list_add(&r->res_slow_list, &ls->ls_slow_active);
}
write_unlock_bh(&ls->ls_rsbtbl_lock);
-
out:
*r_ret = r;
return error;
}
-/*
- * rsb rcu usage
- *
- * While rcu read lock is held, the rsb cannot be freed,
- * which allows a lookup optimization.
- *
- * Two threads are accessing the same rsb concurrently,
- * the first (A) is trying to use the rsb, the second (B)
- * is trying to free the rsb.
- *
- * thread A thread B
- * (trying to use rsb) (trying to free rsb)
- *
- * A1. rcu read lock
- * A2. rsbtbl read lock
- * A3. look up rsb in rsbtbl
- * A4. rsbtbl read unlock
- * B1. rsbtbl write lock
- * B2. look up rsb in rsbtbl
- * B3. remove rsb from rsbtbl
- * B4. clear rsb HASHED flag
- * B5. rsbtbl write unlock
- * B6. begin freeing rsb using rcu...
- *
- * (rsb is inactive, so try to make it active again)
- * A5. read rsb HASHED flag (safe because rsb is not freed yet)
- * A6. the rsb HASHED flag is not set, which it means the rsb
- * is being removed from rsbtbl and freed, so don't use it.
- * A7. rcu read unlock
- *
- * B7. ...finish freeing rsb using rcu
- * A8. create a new rsb
- *
- * Without the rcu optimization, steps A5-8 would need to do
- * an extra rsbtbl lookup:
- * A5. rsbtbl write lock
- * A6. look up rsb in rsbtbl, not found
- * A7. rsbtbl write unlock
- * A8. create a new rsb
- */
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-static int find_rsb(struct dlm_ls *ls, const void *name, int len,
- int from_nodeid, unsigned int flags,
- struct dlm_rsb **r_ret)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
- int dir_nodeid;
- uint32_t hash;
- int rv;
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int recover = (flags & R_RECEIVE_RECOVER);
+ int error;
- if (len > DLM_RESNAME_MAXLEN)
- return -EINVAL;
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
+ if (error)
+ goto do_new;
- hash = jhash(name, len, 0);
- dir_nodeid = dlm_hash2nodeid(ls, hash);
+ /* check if the rsb is in active state under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
+ }
- rcu_read_lock();
- if (dlm_no_directory(ls))
- rv = find_rsb_nodir(ls, name, len, hash, dir_nodeid,
- from_nodeid, flags, r_ret);
- else
- rv = find_rsb_dir(ls, name, len, hash, dir_nodeid,
- from_nodeid, flags, r_ret);
- rcu_read_unlock();
- return rv;
-}
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
+ }
-/* we have received a request and found that res_master_nodeid != our_nodeid,
- so we need to return an error or make ourself the master */
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
-static int validate_master_nodeid(struct dlm_ls *ls, struct dlm_rsb *r,
- int from_nodeid)
-{
- if (dlm_no_directory(ls)) {
- log_error(ls, "find_rsb keep from_nodeid %d master %d dir %d",
- from_nodeid, r->res_master_nodeid,
- r->res_dir_nodeid);
- dlm_print_rsb(r);
- return -ENOTBLK;
- }
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+
+ goto out;
- if (from_nodeid != r->res_dir_nodeid) {
- /* our rsb is not master, and another node (not the dir node)
- has sent us a request. this is much more common when our
- master_nodeid is zero, so limit debug to non-zero. */
- if (r->res_master_nodeid) {
- log_debug(ls, "validate master from_other %d master %d "
- "dir %d first %x %s", from_nodeid,
- r->res_master_nodeid, r->res_dir_nodeid,
- r->res_first_lkid, r->res_name);
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+
+ /* See comment in find_rsb_dir. */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
}
- return -ENOTBLK;
} else {
- /* our rsb is not master, but the dir nodeid has sent us a
- request; this could happen with master 0 / res_nodeid -1 */
-
- if (r->res_master_nodeid) {
- log_error(ls, "validate master from_dir %d master %d "
- "first %x %s",
- from_nodeid, r->res_master_nodeid,
- r->res_first_lkid, r->res_name);
- }
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
+ }
+
+
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
+ */
+
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
+ }
- r->res_master_nodeid = dlm_our_nodeid();
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
r->res_nodeid = 0;
- return 0;
}
-}
-static void __dlm_master_lookup(struct dlm_ls *ls, struct dlm_rsb *r, int our_nodeid,
- int from_nodeid, bool is_inactive, unsigned int flags,
- int *r_nodeid, int *result)
-{
- int fix_master = (flags & DLM_LU_RECOVER_MASTER);
- int from_master = (flags & DLM_LU_RECOVER_DIR);
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- if (r->res_dir_nodeid != our_nodeid) {
- /* should not happen, but may as well fix it and carry on */
- log_error(ls, "%s res_dir %d our %d %s", __func__,
- r->res_dir_nodeid, our_nodeid, r->res_name);
- r->res_dir_nodeid = our_nodeid;
- }
+ goto out;
- if (fix_master && r->res_master_nodeid && dlm_is_removed(ls, r->res_master_nodeid)) {
- /* Recovery uses this function to set a new master when
- * the previous master failed. Setting NEW_MASTER will
- * force dlm_recover_masters to call recover_master on this
- * rsb even though the res_nodeid is no longer removed.
- */
- r->res_master_nodeid = from_nodeid;
- r->res_nodeid = from_nodeid;
- rsb_set_flag(r, RSB_NEW_MASTER);
+ do_new:
+ /*
+ * rsb not found
+ */
- if (is_inactive) {
- /* I don't think we should ever find it inactive. */
- log_error(ls, "%s fix_master inactive", __func__);
- dlm_dump_rsb(r);
- }
- }
+ if (error == -EBADR && !create)
+ goto out;
- if (from_master && (r->res_master_nodeid != from_nodeid)) {
- /* this will happen if from_nodeid became master during
- * a previous recovery cycle, and we aborted the previous
- * cycle before recovering this master value
- */
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
- log_limit(ls, "%s from_master %d master_nodeid %d res_nodeid %d first %x %s",
- __func__, from_nodeid, r->res_master_nodeid,
- r->res_nodeid, r->res_first_lkid, r->res_name);
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
- if (r->res_master_nodeid == our_nodeid) {
- log_error(ls, "from_master %d our_master", from_nodeid);
- dlm_dump_rsb(r);
- goto ret_assign;
- }
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
+ }
- r->res_master_nodeid = from_nodeid;
- r->res_nodeid = from_nodeid;
- rsb_set_flag(r, RSB_NEW_MASTER);
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
}
- if (!r->res_master_nodeid) {
- /* this will happen if recovery happens while we're looking
- * up the master for this rsb
- */
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
- log_debug(ls, "%s master 0 to %d first %x %s", __func__,
- from_nodeid, r->res_first_lkid, r->res_name);
- r->res_master_nodeid = from_nodeid;
- r->res_nodeid = from_nodeid;
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
}
- if (!from_master && !fix_master &&
- (r->res_master_nodeid == from_nodeid)) {
- /* this can happen when the master sends remove, the dir node
- * finds the rsb on the active list and ignores the remove,
- * and the former master sends a lookup
- */
+ out_add:
- log_limit(ls, "%s from master %d flags %x first %x %s",
- __func__, from_nodeid, flags, r->res_first_lkid,
- r->res_name);
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
}
-
- ret_assign:
- *r_nodeid = r->res_master_nodeid;
- if (result)
- *result = DLM_LU_MATCH;
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ out:
+ *r_ret = r;
+ return error;
}
-/*
- * We're the dir node for this res and another node wants to know the
- * master nodeid. During normal operation (non recovery) this is only
- * called from receive_lookup(); master lookups when the local node is
- * the dir node are done by find_rsb().
- *
- * normal operation, we are the dir node for a resource
- * . _request_lock
- * . set_master
- * . send_lookup
- * . receive_lookup
- * . dlm_master_lookup flags 0
- *
- * recover directory, we are rebuilding dir for all resources
- * . dlm_recover_directory
- * . dlm_rcom_names
- * remote node sends back the rsb names it is master of and we are dir of
- * . dlm_master_lookup RECOVER_DIR (fix_master 0, from_master 1)
- * we either create new rsb setting remote node as master, or find existing
- * rsb and set master to be the remote node.
- *
- * recover masters, we are finding the new master for resources
- * . dlm_recover_masters
- * . recover_master
- * . dlm_send_rcom_lookup
- * . receive_rcom_lookup
- * . dlm_master_lookup RECOVER_MASTER (fix_master 1, from_master 0)
- */
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-static int _dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, const char *name,
- int len, unsigned int flags, int *r_nodeid, int *result)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
struct dlm_rsb *r = NULL;
- uint32_t hash;
int our_nodeid = dlm_our_nodeid();
- int dir_nodeid, error;
-
- if (len > DLM_RESNAME_MAXLEN)
- return -EINVAL;
-
- if (from_nodeid == our_nodeid) {
- log_error(ls, "dlm_master_lookup from our_nodeid %d flags %x",
- our_nodeid, flags);
- return -EINVAL;
- }
-
- hash = jhash(name, len, 0);
- dir_nodeid = dlm_hash2nodeid(ls, hash);
- if (dir_nodeid != our_nodeid) {
- log_error(ls, "dlm_master_lookup from %d dir %d our %d h %x %d",
- from_nodeid, dir_nodeid, our_nodeid, hash,
- ls->ls_num_nodes);
- *r_nodeid = -1;
- return -EINVAL;
- }
+ int recover = (flags & R_RECEIVE_RECOVER);
+ int error;
retry:
error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
if (error)
- goto not_found;
+ goto do_new;
- /* check if the rsb is active under read lock - likely path */
+ /* check if the rsb is in active state under read lock - likely path */
read_lock_bh(&ls->ls_rsbtbl_lock);
if (!rsb_flag(r, RSB_HASHED)) {
read_unlock_bh(&ls->ls_rsbtbl_lock);
- goto not_found;
+ goto do_new;
}
if (rsb_flag(r, RSB_INACTIVE)) {
@@ -1301,69 +1265,119 @@ static int _dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, const char *na
goto do_inactive;
}
- /* because the rsb is active, we need to lock_rsb before
- * checking/changing re_master_nodeid
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
*/
- hold_rsb(r);
+ kref_get(&r->res_ref);
read_unlock_bh(&ls->ls_rsbtbl_lock);
- lock_rsb(r);
-
- __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, false,
- flags, r_nodeid, result);
- /* the rsb was active */
- unlock_rsb(r);
- put_rsb(r);
+ goto out;
- return 0;
do_inactive:
- /* unlikely path - check if still part of ls_rsbtbl */
write_lock_bh(&ls->ls_rsbtbl_lock);
- /* see comment in find_rsb_dir */
+ /* See comment in find_rsb_dir. */
if (rsb_flag(r, RSB_HASHED)) {
if (!rsb_flag(r, RSB_INACTIVE)) {
write_unlock_bh(&ls->ls_rsbtbl_lock);
- /* something as changed, very unlikely but
- * try again
- */
goto retry;
}
} else {
write_unlock_bh(&ls->ls_rsbtbl_lock);
- goto not_found;
+ goto do_new;
}
- /* because the rsb is inactive, it's not refcounted and lock_rsb
- is not used, but is protected by the rsbtbl lock */
-
- __dlm_master_lookup(ls, r, our_nodeid, from_nodeid, true, flags,
- r_nodeid, result);
- /* A dir record rsb should never be on scan list.
- * Except when we are the dir and master node.
- * This function should only be called by the dir
- * node.
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
*/
- WARN_ON(!list_empty(&r->res_scan_list) &&
- r->res_master_nodeid != our_nodeid);
-
- write_unlock_bh(&ls->ls_rsbtbl_lock);
- return 0;
-
- not_found:
- error = get_rsb_struct(ls, name, len, &r);
- if (WARN_ON_ONCE(error))
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
+ }
+
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ }
+
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+
+ goto out;
+
+
+ do_new:
+ /*
+ * rsb not found
+ */
+
+ if (error == -EBADR && !create)
+ goto out;
+
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
goto out;
r->res_hash = hash;
- r->res_dir_nodeid = our_nodeid;
- r->res_master_nodeid = from_nodeid;
- r->res_nodeid = from_nodeid;
- rsb_set_flag(r, RSB_INACTIVE);
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
+
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
+ }
+
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
+ }
+
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
+
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
+
+ out_add:
write_lock_bh(&ls->ls_rsbtbl_lock);
error = rsb_insert(r, &ls->ls_rsbtbl);
@@ -1374,4831 +1388,4638 @@ static int _dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, const char *na
write_unlock_bh(&ls->ls_rsbtbl_lock);
dlm_free_rsb(r);
goto retry;
- } else if (error) {
- write_unlock_bh(&ls->ls_rsbtbl_lock);
- /* should never happen */
- dlm_free_rsb(r);
- goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
}
-
- list_add(&r->res_slow_list, &ls->ls_slow_inactive);
write_unlock_bh(&ls->ls_rsbtbl_lock);
-
- if (result)
- *result = DLM_LU_ADD;
- *r_nodeid = from_nodeid;
out:
+ *r_ret = r;
return error;
}
-int dlm_master_lookup(struct dlm_ls *ls, int from_nodeid, const char *name,
- int len, unsigned int flags, int *r_nodeid, int *result)
-{
- int rv;
- rcu_read_lock();
- rv = _dlm_master_lookup(ls, from_nodeid, name, len, flags, r_nodeid, result);
- rcu_read_unlock();
- return rv;
-}
-
-static void dlm_dump_rsb_hash(struct dlm_ls *ls, uint32_t hash)
-{
- struct dlm_rsb *r;
-
- read_lock_bh(&ls->ls_rsbtbl_lock);
- list_for_each_entry(r, &ls->ls_slow_active, res_slow_list) {
- if (r->res_hash == hash)
- dlm_dump_rsb(r);
- }
- read_unlock_bh(&ls->ls_rsbtbl_lock);
-}
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-void dlm_dump_rsb_name(struct dlm_ls *ls, const char *name, int len)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int recover = (flags & R_RECEIVE_RECOVER);
int error;
- rcu_read_lock();
+ retry:
error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
- if (!error)
- goto out;
-
- dlm_dump_rsb(r);
- out:
- rcu_read_unlock();
-}
+ if (error)
+ goto do_new;
-static void deactivate_rsb(struct kref *kref)
-{
- struct dlm_rsb *r = container_of(kref, struct dlm_rsb, res_ref);
- struct dlm_ls *ls = r->res_ls;
- int our_nodeid = dlm_our_nodeid();
+ /* check if the rsb is in active state under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
+ }
- DLM_ASSERT(list_empty(&r->res_root_list), dlm_print_rsb(r););
- rsb_set_flag(r, RSB_INACTIVE);
- list_move(&r->res_slow_list, &ls->ls_slow_inactive);
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
+ }
/*
- * When the rsb becomes unused, there are two possibilities:
- * 1. Leave the inactive rsb in place (don't remove it).
- * 2. Add it to the scan list to be removed.
- *
- * 1 is done when the rsb is acting as the dir record
- * for a remotely mastered rsb. The rsb must be left
- * in place as an inactive rsb to act as the dir record.
- *
- * 2 is done when a) the rsb is not the master and not the
- * dir record, b) when the rsb is both the master and the
- * dir record, c) when the rsb is master but not dir record.
- *
- * (If no directory is used, the rsb can always be removed.)
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
*/
- if (dlm_no_directory(ls) ||
- (r->res_master_nodeid == our_nodeid ||
- dlm_dir_nodeid(r) != our_nodeid))
- add_scan(ls, r);
-
- if (r->res_lvbptr) {
- dlm_free_lvb(r->res_lvbptr);
- r->res_lvbptr = NULL;
- }
-}
-
-void free_inactive_rsb(struct dlm_rsb *r)
-{
- WARN_ON_ONCE(!rsb_flag(r, RSB_INACTIVE));
- DLM_ASSERT(list_empty(&r->res_lookup), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_grantqueue), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_convertqueue), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_waitqueue), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_root_list), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_scan_list), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_recover_list), dlm_dump_rsb(r););
- DLM_ASSERT(list_empty(&r->res_masters_list), dlm_dump_rsb(r););
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
- dlm_free_rsb(r);
-}
+ goto out;
-/* Attaching/detaching lkb's from rsb's is for rsb reference counting.
- The rsb must exist as long as any lkb's for it do. */
-static void attach_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- hold_rsb(r);
- lkb->lkb_resource = r;
-}
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
-static void detach_lkb(struct dlm_lkb *lkb)
-{
- if (lkb->lkb_resource) {
- put_rsb(lkb->lkb_resource);
- lkb->lkb_resource = NULL;
+ /* See comment in find_rsb_dir. */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
+ }
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
}
-}
-
-static int _create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret,
- unsigned long start, unsigned long end)
-{
- struct xa_limit limit;
- struct dlm_lkb *lkb;
- int rv;
-
- limit.max = end;
- limit.min = start;
- lkb = dlm_allocate_lkb();
- if (!lkb)
- return -ENOMEM;
-
- lkb->lkb_last_bast_cb_mode = DLM_LOCK_IV;
- lkb->lkb_last_cast_cb_mode = DLM_LOCK_IV;
- lkb->lkb_last_cb_mode = DLM_LOCK_IV;
- lkb->lkb_nodeid = -1;
- lkb->lkb_grmode = DLM_LOCK_IV;
- kref_init(&lkb->lkb_ref);
- INIT_LIST_HEAD(&lkb->lkb_ownqueue);
- INIT_LIST_HEAD(&lkb->lkb_rsb_lookup);
- write_lock_bh(&ls->ls_lkbxa_lock);
- rv = xa_alloc(&ls->ls_lkbxa, &lkb->lkb_id, lkb, limit, GFP_ATOMIC);
- write_unlock_bh(&ls->ls_lkbxa_lock);
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
+ */
- if (rv < 0) {
- log_error(ls, "create_lkb xa error %d", rv);
- dlm_free_lkb(lkb);
- return rv;
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
}
- *lkb_ret = lkb;
- return 0;
-}
-
-static int create_lkb(struct dlm_ls *ls, struct dlm_lkb **lkb_ret)
-{
- return _create_lkb(ls, lkb_ret, 1, ULONG_MAX);
-}
-
-static int find_lkb(struct dlm_ls *ls, uint32_t lkid, struct dlm_lkb **lkb_ret)
-{
- struct dlm_lkb *lkb;
-
- rcu_read_lock();
- lkb = xa_load(&ls->ls_lkbxa, lkid);
- if (lkb) {
- /* check if lkb is still part of lkbxa under lkbxa_lock as
- * the lkb_ref is tight to the lkbxa data structure, see
- * __put_lkb().
- */
- read_lock_bh(&ls->ls_lkbxa_lock);
- if (kref_read(&lkb->lkb_ref))
- kref_get(&lkb->lkb_ref);
- else
- lkb = NULL;
- read_unlock_bh(&ls->ls_lkbxa_lock);
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
}
- rcu_read_unlock();
- *lkb_ret = lkb;
- return lkb ? 0 : -ENOENT;
-}
-
-static void kill_lkb(struct kref *kref)
-{
- struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- /* All work is done after the return from kref_put() so we
- can release the write_lock before the detach_lkb */
+ goto out;
- DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
-}
-/* __put_lkb() is used when an lkb may not have an rsb attached to
- it so we need to provide the lockspace explicitly */
+ do_new:
+ /*
+ * rsb not found
+ */
-static int __put_lkb(struct dlm_ls *ls, struct dlm_lkb *lkb)
-{
- uint32_t lkid = lkb->lkb_id;
- int rv;
+ if (error == -EBADR && !create)
+ goto out;
- rv = dlm_kref_put_write_lock_bh(&lkb->lkb_ref, kill_lkb,
- &ls->ls_lkbxa_lock);
- if (rv) {
- xa_erase(&ls->ls_lkbxa, lkid);
- write_unlock_bh(&ls->ls_lkbxa_lock);
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
- detach_lkb(lkb);
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
- /* for local/process lkbs, lvbptr points to caller's lksb */
- if (lkb->lkb_lvbptr && is_master_copy(lkb))
- dlm_free_lvb(lkb->lkb_lvbptr);
- dlm_free_lkb(lkb);
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
}
- return rv;
-}
-
-int dlm_put_lkb(struct dlm_lkb *lkb)
-{
- struct dlm_ls *ls;
-
- DLM_ASSERT(lkb->lkb_resource, dlm_print_lkb(lkb););
- DLM_ASSERT(lkb->lkb_resource->res_ls, dlm_print_lkb(lkb););
-
- ls = lkb->lkb_resource->res_ls;
- return __put_lkb(ls, lkb);
-}
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
+ }
-/* This is only called to add a reference when the code already holds
- a valid reference to the lkb, so there's no need for locking. */
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
-static inline void hold_lkb(struct dlm_lkb *lkb)
-{
- kref_get(&lkb->lkb_ref);
-}
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
-static void unhold_lkb_assert(struct kref *kref)
-{
- struct dlm_lkb *lkb = container_of(kref, struct dlm_lkb, lkb_ref);
+ out_add:
- DLM_ASSERT(false, dlm_print_lkb(lkb););
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
+ }
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ out:
+ *r_ret = r;
+ return error;
}
-/* This is called when we need to remove a reference and are certain
- it's not the last ref. e.g. del_lkb is always called between a
- find_lkb/put_lkb and is always the inverse of a previous add_lkb.
- put_lkb would work fine, but would involve unnecessary locking */
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-static inline void unhold_lkb(struct dlm_lkb *lkb)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
- kref_put(&lkb->lkb_ref, unhold_lkb_assert);
-}
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int recover = (flags & R_RECEIVE_RECOVER);
+ int error;
-static void lkb_add_ordered(struct list_head *new, struct list_head *head,
- int mode)
-{
- struct dlm_lkb *lkb = NULL, *iter;
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
+ if (error)
+ goto do_new;
- list_for_each_entry(iter, head, lkb_statequeue)
- if (iter->lkb_rqmode < mode) {
- lkb = iter;
- list_add_tail(new, &iter->lkb_statequeue);
- break;
- }
+ /* check if the rsb is in active state under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
+ }
- if (!lkb)
- list_add_tail(new, head);
-}
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
+ }
-/* add/remove lkb to rsb's grant/convert/wait queue */
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
-static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
-{
- kref_get(&lkb->lkb_ref);
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
- DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
+ goto out;
- lkb->lkb_timestamp = ktime_get();
- lkb->lkb_status = status;
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
- switch (status) {
- case DLM_LKSTS_WAITING:
- if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
- list_add(&lkb->lkb_statequeue, &r->res_waitqueue);
- else
- list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
- break;
- case DLM_LKSTS_GRANTED:
- /* convention says granted locks kept in order of grmode */
- lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
- lkb->lkb_grmode);
- break;
- case DLM_LKSTS_CONVERT:
- if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
- list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
- else
- list_add_tail(&lkb->lkb_statequeue,
- &r->res_convertqueue);
- break;
- default:
- DLM_ASSERT(0, dlm_print_lkb(lkb); printk("sts=%d\n", status););
+ /* See comment in find_rsb_dir. */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
+ }
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
}
-}
-static void del_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- lkb->lkb_status = 0;
- list_del(&lkb->lkb_statequeue);
- unhold_lkb(lkb);
-}
-static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts)
-{
- del_lkb(r, lkb);
- add_lkb(r, lkb, sts);
-}
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
+ */
-static int msg_reply_type(int mstype)
-{
- switch (mstype) {
- case DLM_MSG_REQUEST:
- return DLM_MSG_REQUEST_REPLY;
- case DLM_MSG_CONVERT:
- return DLM_MSG_CONVERT_REPLY;
- case DLM_MSG_UNLOCK:
- return DLM_MSG_UNLOCK_REPLY;
- case DLM_MSG_CANCEL:
- return DLM_MSG_CANCEL_REPLY;
- case DLM_MSG_LOOKUP:
- return DLM_MSG_LOOKUP_REPLY;
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
}
- return -1;
-}
-/* add/remove lkb from global waiters list of lkb's waiting for
- a reply from a remote node */
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ }
-static void add_to_waiters(struct dlm_lkb *lkb, int mstype, int to_nodeid)
-{
- struct dlm_ls *ls = lkb->lkb_resource->res_ls;
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- spin_lock_bh(&ls->ls_waiters_lock);
- if (lkb->lkb_wait_type || is_overlap_cancel(lkb)) {
- switch (mstype) {
- case DLM_MSG_UNLOCK:
- set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
- break;
- case DLM_MSG_CANCEL:
- set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
- break;
- default:
- /* should never happen as validate_lock_args() checks
- * on lkb_wait_type and validate_unlock_args() only
- * creates UNLOCK or CANCEL messages.
- */
- WARN_ON_ONCE(1);
- goto out;
- }
- lkb->lkb_wait_count++;
- hold_lkb(lkb);
+ goto out;
- log_debug(ls, "addwait %x cur %d overlap %d count %d f %x",
- lkb->lkb_id, lkb->lkb_wait_type, mstype,
- lkb->lkb_wait_count, dlm_iflags_val(lkb));
- goto out;
- }
- DLM_ASSERT(!lkb->lkb_wait_count,
- dlm_print_lkb(lkb);
- printk("wait_count %d\n", lkb->lkb_wait_count););
+ do_new:
+ /*
+ * rsb not found
+ */
- lkb->lkb_wait_count++;
- lkb->lkb_wait_type = mstype;
- lkb->lkb_wait_nodeid = to_nodeid; /* for debugging */
- hold_lkb(lkb);
- list_add(&lkb->lkb_wait_reply, &ls->ls_waiters);
- out:
- spin_unlock_bh(&ls->ls_waiters_lock);
-}
+ if (error == -EBADR && !create)
+ goto out;
-/* We clear the RESEND flag because we might be taking an lkb off the waiters
- list as part of process_requestqueue (e.g. a lookup that has an optimized
- request reply on the requestqueue) between dlm_recover_waiters_pre() which
- set RESEND and dlm_recover_waiters_post() */
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
-static int _remove_from_waiters(struct dlm_lkb *lkb, int mstype,
- const struct dlm_message *ms)
-{
- struct dlm_ls *ls = lkb->lkb_resource->res_ls;
- int overlap_done = 0;
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
- if (mstype == DLM_MSG_UNLOCK_REPLY &&
- test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags)) {
- log_debug(ls, "remwait %x unlock_reply overlap", lkb->lkb_id);
- overlap_done = 1;
- goto out_del;
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
}
- if (mstype == DLM_MSG_CANCEL_REPLY &&
- test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
- log_debug(ls, "remwait %x cancel_reply overlap", lkb->lkb_id);
- overlap_done = 1;
- goto out_del;
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
}
- /* Cancel state was preemptively cleared by a successful convert,
- see next comment, nothing to do. */
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
- if ((mstype == DLM_MSG_CANCEL_REPLY) &&
- (lkb->lkb_wait_type != DLM_MSG_CANCEL)) {
- log_debug(ls, "remwait %x cancel_reply wait_type %d",
- lkb->lkb_id, lkb->lkb_wait_type);
- return -1;
- }
-
- /* Remove for the convert reply, and premptively remove for the
- cancel reply. A convert has been granted while there's still
- an outstanding cancel on it (the cancel is moot and the result
- in the cancel reply should be 0). We preempt the cancel reply
- because the app gets the convert result and then can follow up
- with another op, like convert. This subsequent op would see the
- lingering state of the cancel and fail with -EBUSY. */
-
- if ((mstype == DLM_MSG_CONVERT_REPLY) &&
- (lkb->lkb_wait_type == DLM_MSG_CONVERT) && ms && !ms->m_result &&
- test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
- log_debug(ls, "remwait %x convert_reply zap overlap_cancel",
- lkb->lkb_id);
- lkb->lkb_wait_type = 0;
- lkb->lkb_wait_count--;
- unhold_lkb(lkb);
- goto out_del;
- }
-
- /* N.B. type of reply may not always correspond to type of original
- msg due to lookup->request optimization, verify others? */
-
- if (lkb->lkb_wait_type) {
- lkb->lkb_wait_type = 0;
- goto out_del;
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
}
- log_error(ls, "remwait error %x remote %d %x msg %d flags %x no wait",
- lkb->lkb_id, ms ? le32_to_cpu(ms->m_header.h_nodeid) : 0,
- lkb->lkb_remid, mstype, dlm_iflags_val(lkb));
- return -1;
-
- out_del:
- /* the force-unlock/cancel has completed and we haven't recvd a reply
- to the op that was in progress prior to the unlock/cancel; we
- give up on any reply to the earlier op. FIXME: not sure when/how
- this would happen */
+ out_add:
- if (overlap_done && lkb->lkb_wait_type) {
- log_error(ls, "remwait error %x reply %d wait_type %d overlap",
- lkb->lkb_id, mstype, lkb->lkb_wait_type);
- lkb->lkb_wait_count--;
- unhold_lkb(lkb);
- lkb->lkb_wait_type = 0;
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
}
-
- DLM_ASSERT(lkb->lkb_wait_count, dlm_print_lkb(lkb););
-
- clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
- lkb->lkb_wait_count--;
- if (!lkb->lkb_wait_count)
- list_del_init(&lkb->lkb_wait_reply);
- unhold_lkb(lkb);
- return 0;
-}
-
-static int remove_from_waiters(struct dlm_lkb *lkb, int mstype)
-{
- struct dlm_ls *ls = lkb->lkb_resource->res_ls;
- int error;
-
- spin_lock_bh(&ls->ls_waiters_lock);
- error = _remove_from_waiters(lkb, mstype, NULL);
- spin_unlock_bh(&ls->ls_waiters_lock);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ out:
+ *r_ret = r;
return error;
}
-/* Handles situations where we might be processing a "fake" or "local" reply in
- * the recovery context which stops any locking activity. Only debugfs might
- * change the lockspace waiters but they will held the recovery lock to ensure
- * remove_from_waiters_ms() in local case will be the only user manipulating the
- * lockspace waiters in recovery context.
- */
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-static int remove_from_waiters_ms(struct dlm_lkb *lkb,
- const struct dlm_message *ms, bool local)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
- struct dlm_ls *ls = lkb->lkb_resource->res_ls;
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int recover = (flags & R_RECEIVE_RECOVER);
int error;
- if (!local)
- spin_lock_bh(&ls->ls_waiters_lock);
- else
- WARN_ON_ONCE(!rwsem_is_locked(&ls->ls_in_recovery) ||
- !dlm_locking_stopped(ls));
- error = _remove_from_waiters(lkb, le32_to_cpu(ms->m_type), ms);
- if (!local)
- spin_unlock_bh(&ls->ls_waiters_lock);
- return error;
-}
-
-/* lkb is master or local copy */
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
+ if (error)
+ goto do_new;
-static void set_lvb_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- int b, len = r->res_ls->ls_lvblen;
+ /* check if the rsb is in active state under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
+ }
- /* b=1 lvb returned to caller
- b=0 lvb written to rsb or invalidated
- b=-1 do nothing */
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
+ }
- b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
- if (b == 1) {
- if (!lkb->lkb_lvbptr)
- return;
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
- if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
- return;
+ goto out;
- if (!r->res_lvbptr)
- return;
- memcpy(lkb->lkb_lvbptr, r->res_lvbptr, len);
- lkb->lkb_lvbseq = r->res_lvbseq;
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
- } else if (b == 0) {
- if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
- rsb_set_flag(r, RSB_VALNOTVALID);
- return;
+ /* See comment in find_rsb_dir. */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
}
-
- if (!lkb->lkb_lvbptr)
- return;
-
- if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
- return;
-
- if (!r->res_lvbptr)
- r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
-
- if (!r->res_lvbptr)
- return;
-
- memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
- r->res_lvbseq++;
- lkb->lkb_lvbseq = r->res_lvbseq;
- rsb_clear_flag(r, RSB_VALNOTVALID);
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
}
- if (rsb_flag(r, RSB_VALNOTVALID))
- set_bit(DLM_SBF_VALNOTVALID_BIT, &lkb->lkb_sbflags);
-}
-static void set_lvb_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- if (lkb->lkb_grmode < DLM_LOCK_PW)
- return;
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
+ */
- if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
- rsb_set_flag(r, RSB_VALNOTVALID);
- return;
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
}
- if (!lkb->lkb_lvbptr)
- return;
-
- if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
- return;
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ }
- if (!r->res_lvbptr)
- r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- if (!r->res_lvbptr)
- return;
+ goto out;
- memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
- r->res_lvbseq++;
- rsb_clear_flag(r, RSB_VALNOTVALID);
-}
-/* lkb is process copy (pc) */
+ do_new:
+ /*
+ * rsb not found
+ */
-static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
-{
- int b;
+ if (error == -EBADR && !create)
+ goto out;
- if (!lkb->lkb_lvbptr)
- return;
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
- if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
- return;
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
- b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
- if (b == 1) {
- int len = receive_extralen(ms);
- if (len > r->res_ls->ls_lvblen)
- len = r->res_ls->ls_lvblen;
- memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
- lkb->lkb_lvbseq = le32_to_cpu(ms->m_lvbseq);
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
}
-}
-/* Manipulate lkb's on rsb's convert/granted/waiting queues
- remove_lock -- used for unlock, removes lkb from granted
- revert_lock -- used for cancel, moves lkb from convert to granted
- grant_lock -- used for request and convert, adds lkb to granted or
- moves lkb from convert or waiting to granted
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
+ }
- Each of these is used for master or local copy lkb's. There is
- also a _pc() variation used to make the corresponding change on
- a process copy (pc) lkb. */
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
-static void _remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- del_lkb(r, lkb);
- lkb->lkb_grmode = DLM_LOCK_IV;
- /* this unhold undoes the original ref from create_lkb()
- so this leads to the lkb being freed */
- unhold_lkb(lkb);
-}
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
-static void remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- set_lvb_unlock(r, lkb);
- _remove_lock(r, lkb);
-}
+ out_add:
-static void remove_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- _remove_lock(r, lkb);
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
+ }
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ out:
+ *r_ret = r;
+ return error;
}
-/* returns: 0 did nothing
- 1 moved lock to granted
- -1 removed lock */
+/* During recovery, other nodes can send us new MSTCPY locks (from
+ dlm_recover_locks) before we've made ourself master (in
+ dlm_recover_masters). */
-static int revert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static int find_rsb_nodir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
- int rv = 0;
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int recover = (flags & R_RECEIVE_RECOVER);
+ int error;
- lkb->lkb_rqmode = DLM_LOCK_IV;
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
+ if (error)
+ goto do_new;
- switch (lkb->lkb_status) {
- case DLM_LKSTS_GRANTED:
- break;
- case DLM_LKSTS_CONVERT:
- move_lkb(r, lkb, DLM_LKSTS_GRANTED);
- rv = 1;
- break;
- case DLM_LKSTS_WAITING:
- del_lkb(r, lkb);
- lkb->lkb_grmode = DLM_LOCK_IV;
- /* this unhold undoes the original ref from create_lkb()
- so this leads to the lkb being freed */
- unhold_lkb(lkb);
- rv = -1;
- break;
- default:
- log_print("invalid status for revert %d", lkb->lkb_status);
+ /* check if the rsb is in active state under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
}
- return rv;
-}
-
-static int revert_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- return revert_lock(r, lkb);
-}
-static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- if (lkb->lkb_grmode != lkb->lkb_rqmode) {
- lkb->lkb_grmode = lkb->lkb_rqmode;
- if (lkb->lkb_status)
- move_lkb(r, lkb, DLM_LKSTS_GRANTED);
- else
- add_lkb(r, lkb, DLM_LKSTS_GRANTED);
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
}
- lkb->lkb_rqmode = DLM_LOCK_IV;
- lkb->lkb_highbast = 0;
-}
-
-static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- set_lvb_lock(r, lkb);
- _grant_lock(r, lkb);
-}
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
-static void grant_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
-{
- set_lvb_lock_pc(r, lkb, ms);
- _grant_lock(r, lkb);
-}
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
-/* called by grant_pending_locks() which means an async grant message must
- be sent to the requesting node in addition to granting the lock if the
- lkb belongs to a remote node. */
+ goto out;
-static void grant_lock_pending(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- grant_lock(r, lkb);
- if (is_master_copy(lkb))
- send_grant(r, lkb);
- else
- queue_cast(r, lkb, 0);
-}
-/* The special CONVDEADLK, ALTPR and ALTCW flags allow the master to
- change the granted/requested modes. We're munging things accordingly in
- the process copy.
- CONVDEADLK: our grmode may have been forced down to NL to resolve a
- conversion deadlock
- ALTPR/ALTCW: our rqmode may have been changed to PR or CW to become
- compatible with other granted locks */
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
-static void munge_demoted(struct dlm_lkb *lkb)
-{
- if (lkb->lkb_rqmode == DLM_LOCK_IV || lkb->lkb_grmode == DLM_LOCK_IV) {
- log_print("munge_demoted %x invalid modes gr %d rq %d",
- lkb->lkb_id, lkb->lkb_grmode, lkb->lkb_rqmode);
- return;
+ /* See comment in find_rsb_dir. */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
+ }
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_new;
}
- lkb->lkb_grmode = DLM_LOCK_NL;
-}
-static void munge_altmode(struct dlm_lkb *lkb, const struct dlm_message *ms)
-{
- if (ms->m_type != cpu_to_le32(DLM_MSG_REQUEST_REPLY) &&
- ms->m_type != cpu_to_le32(DLM_MSG_GRANT)) {
- log_print("munge_altmode %x invalid reply type %d",
- lkb->lkb_id, le32_to_cpu(ms->m_type));
- return;
+ /*
+ * rsb found inactive. No other thread is using this rsb because
+ * it's inactive, so we can look at or update res_master_nodeid
+ * without lock_rsb.
+ */
+
+ if (!recover && (r->res_master_nodeid != our_nodeid) && from_nodeid) {
+ /* our rsb is not master, and another node has sent us a
+ request; this should never happen */
+ log_error(ls, "find_rsb inactive from_nodeid %d master %d dir %d",
+ from_nodeid, r->res_master_nodeid, dir_nodeid);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
}
- if (lkb->lkb_exflags & DLM_LKF_ALTPR)
- lkb->lkb_rqmode = DLM_LOCK_PR;
- else if (lkb->lkb_exflags & DLM_LKF_ALTCW)
- lkb->lkb_rqmode = DLM_LOCK_CW;
- else {
- log_print("munge_altmode invalid exflags %x", lkb->lkb_exflags);
- dlm_print_lkb(lkb);
+ if (!recover && (r->res_master_nodeid != our_nodeid) &&
+ (dir_nodeid == our_nodeid)) {
+ /* our rsb is not master, and we are dir; may as well fix it;
+ this should never happen */
+ log_error(ls, "find_rsb inactive our %d master %d dir %d",
+ our_nodeid, r->res_master_nodeid, dir_nodeid);
+ dlm_print_rsb(r);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
}
-}
-static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
-{
- struct dlm_lkb *first = list_entry(head->next, struct dlm_lkb,
- lkb_statequeue);
- if (lkb->lkb_id == first->lkb_id)
- return 1;
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- return 0;
-}
+ goto out;
-/* Check if the given lkb conflicts with another lkb on the queue. */
-static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
-{
- struct dlm_lkb *this;
+ do_new:
+ /*
+ * rsb not found
+ */
- list_for_each_entry(this, head, lkb_statequeue) {
- if (this == lkb)
- continue;
- if (!modes_compat(this, lkb))
- return 1;
- }
- return 0;
-}
-
-/*
- * "A conversion deadlock arises with a pair of lock requests in the converting
- * queue for one resource. The granted mode of each lock blocks the requested
- * mode of the other lock."
- *
- * Part 2: if the granted mode of lkb is preventing an earlier lkb in the
- * convert queue from being granted, then deadlk/demote lkb.
- *
- * Example:
- * Granted Queue: empty
- * Convert Queue: NL->EX (first lock)
- * PR->EX (second lock)
- *
- * The first lock can't be granted because of the granted mode of the second
- * lock and the second lock can't be granted because it's not first in the
- * list. We either cancel lkb's conversion (PR->EX) and return EDEADLK, or we
- * demote the granted mode of lkb (from PR to NL) if it has the CONVDEADLK
- * flag set and return DEMOTED in the lksb flags.
- *
- * Originally, this function detected conv-deadlk in a more limited scope:
- * - if !modes_compat(lkb1, lkb2) && !modes_compat(lkb2, lkb1), or
- * - if lkb1 was the first entry in the queue (not just earlier), and was
- * blocked by the granted mode of lkb2, and there was nothing on the
- * granted queue preventing lkb1 from being granted immediately, i.e.
- * lkb2 was the only thing preventing lkb1 from being granted.
- *
- * That second condition meant we'd only say there was conv-deadlk if
- * resolving it (by demotion) would lead to the first lock on the convert
- * queue being granted right away. It allowed conversion deadlocks to exist
- * between locks on the convert queue while they couldn't be granted anyway.
- *
- * Now, we detect and take action on conversion deadlocks immediately when
- * they're created, even if they may not be immediately consequential. If
- * lkb1 exists anywhere in the convert queue and lkb2 comes in with a granted
- * mode that would prevent lkb1's conversion from being granted, we do a
- * deadlk/demote on lkb2 right away and don't let it onto the convert queue.
- * I think this means that the lkb_is_ahead condition below should always
- * be zero, i.e. there will never be conv-deadlk between two locks that are
- * both already on the convert queue.
- */
-
-static int conversion_deadlock_detect(struct dlm_rsb *r, struct dlm_lkb *lkb2)
-{
- struct dlm_lkb *lkb1;
- int lkb_is_ahead = 0;
-
- list_for_each_entry(lkb1, &r->res_convertqueue, lkb_statequeue) {
- if (lkb1 == lkb2) {
- lkb_is_ahead = 1;
- continue;
- }
-
- if (!lkb_is_ahead) {
- if (!modes_compat(lkb2, lkb1))
- return 1;
- } else {
- if (!modes_compat(lkb2, lkb1) &&
- !modes_compat(lkb1, lkb2))
- return 1;
- }
- }
- return 0;
-}
-
-/*
- * Return 1 if the lock can be granted, 0 otherwise.
- * Also detect and resolve conversion deadlocks.
- *
- * lkb is the lock to be granted
- *
- * now is 1 if the function is being called in the context of the
- * immediate request, it is 0 if called later, after the lock has been
- * queued.
- *
- * recover is 1 if dlm_recover_grant() is trying to grant conversions
- * after recovery.
- *
- * References are from chapter 6 of "VAXcluster Principles" by Roy Davis
- */
-
-static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
- int recover)
-{
- int8_t conv = (lkb->lkb_grmode != DLM_LOCK_IV);
-
- /*
- * 6-10: Version 5.4 introduced an option to address the phenomenon of
- * a new request for a NL mode lock being blocked.
- *
- * 6-11: If the optional EXPEDITE flag is used with the new NL mode
- * request, then it would be granted. In essence, the use of this flag
- * tells the Lock Manager to expedite theis request by not considering
- * what may be in the CONVERTING or WAITING queues... As of this
- * writing, the EXPEDITE flag can be used only with new requests for NL
- * mode locks. This flag is not valid for conversion requests.
- *
- * A shortcut. Earlier checks return an error if EXPEDITE is used in a
- * conversion or used with a non-NL requested mode. We also know an
- * EXPEDITE request is always granted immediately, so now must always
- * be 1. The full condition to grant an expedite request: (now &&
- * !conv && lkb->rqmode == DLM_LOCK_NL && (flags & EXPEDITE)) can
- * therefore be shortened to just checking the flag.
- */
-
- if (lkb->lkb_exflags & DLM_LKF_EXPEDITE)
- return 1;
-
- /*
- * A shortcut. Without this, !queue_conflict(grantqueue, lkb) would be
- * added to the remaining conditions.
- */
-
- if (queue_conflict(&r->res_grantqueue, lkb))
- return 0;
-
- /*
- * 6-3: By default, a conversion request is immediately granted if the
- * requested mode is compatible with the modes of all other granted
- * locks
- */
-
- if (queue_conflict(&r->res_convertqueue, lkb))
- return 0;
-
- /*
- * The RECOVER_GRANT flag means dlm_recover_grant() is granting
- * locks for a recovered rsb, on which lkb's have been rebuilt.
- * The lkb's may have been rebuilt on the queues in a different
- * order than they were in on the previous master. So, granting
- * queued conversions in order after recovery doesn't make sense
- * since the order hasn't been preserved anyway. The new order
- * could also have created a new "in place" conversion deadlock.
- * (e.g. old, failed master held granted EX, with PR->EX, NL->EX.
- * After recovery, there would be no granted locks, and possibly
- * NL->EX, PR->EX, an in-place conversion deadlock.) So, after
- * recovery, grant conversions without considering order.
- */
-
- if (conv && recover)
- return 1;
-
- /*
- * 6-5: But the default algorithm for deciding whether to grant or
- * queue conversion requests does not by itself guarantee that such
- * requests are serviced on a "first come first serve" basis. This, in
- * turn, can lead to a phenomenon known as "indefinate postponement".
- *
- * 6-7: This issue is dealt with by using the optional QUECVT flag with
- * the system service employed to request a lock conversion. This flag
- * forces certain conversion requests to be queued, even if they are
- * compatible with the granted modes of other locks on the same
- * resource. Thus, the use of this flag results in conversion requests
- * being ordered on a "first come first servce" basis.
- *
- * DCT: This condition is all about new conversions being able to occur
- * "in place" while the lock remains on the granted queue (assuming
- * nothing else conflicts.) IOW if QUECVT isn't set, a conversion
- * doesn't _have_ to go onto the convert queue where it's processed in
- * order. The "now" variable is necessary to distinguish converts
- * being received and processed for the first time now, because once a
- * convert is moved to the conversion queue the condition below applies
- * requiring fifo granting.
- */
+ if (error == -EBADR && !create)
+ goto out;
- if (now && conv && !(lkb->lkb_exflags & DLM_LKF_QUECVT))
- return 1;
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
- /*
- * Even if the convert is compat with all granted locks,
- * QUECVT forces it behind other locks on the convert queue.
- */
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
- if (now && conv && (lkb->lkb_exflags & DLM_LKF_QUECVT)) {
- if (list_empty(&r->res_convertqueue))
- return 1;
- else
- return 0;
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
}
- /*
- * The NOORDER flag is set to avoid the standard vms rules on grant
- * order.
- */
-
- if (lkb->lkb_exflags & DLM_LKF_NOORDER)
- return 1;
-
- /*
- * 6-3: Once in that queue [CONVERTING], a conversion request cannot be
- * granted until all other conversion requests ahead of it are granted
- * and/or canceled.
- */
-
- if (!now && conv && first_in_list(lkb, &r->res_convertqueue))
- return 1;
-
- /*
- * 6-4: By default, a new request is immediately granted only if all
- * three of the following conditions are satisfied when the request is
- * issued:
- * - The queue of ungranted conversion requests for the resource is
- * empty.
- * - The queue of ungranted new requests for the resource is empty.
- * - The mode of the new request is compatible with the most
- * restrictive mode of all granted locks on the resource.
- */
-
- if (now && !conv && list_empty(&r->res_convertqueue) &&
- list_empty(&r->res_waitqueue))
- return 1;
-
- /*
- * 6-4: Once a lock request is in the queue of ungranted new requests,
- * it cannot be granted until the queue of ungranted conversion
- * requests is empty, all ungranted new requests ahead of it are
- * granted and/or canceled, and it is compatible with the granted mode
- * of the most restrictive lock granted on the resource.
- */
-
- if (!now && !conv && list_empty(&r->res_convertqueue) &&
- first_in_list(lkb, &r->res_waitqueue))
- return 1;
-
- return 0;
-}
-
-static int can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
- int recover, int *err)
-{
- int rv;
- int8_t alt = 0, rqmode = lkb->lkb_rqmode;
- int8_t is_convert = (lkb->lkb_grmode != DLM_LOCK_IV);
-
- if (err)
- *err = 0;
-
- rv = _can_be_granted(r, lkb, now, recover);
- if (rv)
- goto out;
-
- /*
- * The CONVDEADLK flag is non-standard and tells the dlm to resolve
- * conversion deadlocks by demoting grmode to NL, otherwise the dlm
- * cancels one of the locks.
- */
-
- if (is_convert && can_be_queued(lkb) &&
- conversion_deadlock_detect(r, lkb)) {
- if (lkb->lkb_exflags & DLM_LKF_CONVDEADLK) {
- lkb->lkb_grmode = DLM_LOCK_NL;
- set_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
- } else if (err) {
- *err = -EDEADLK;
- } else {
- log_print("can_be_granted deadlock %x now %d",
- lkb->lkb_id, now);
- dlm_dump_rsb(r);
- }
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
goto out;
}
- /*
- * The ALTPR and ALTCW flags are non-standard and tell the dlm to try
- * to grant a request in a mode other than the normal rqmode. It's a
- * simple way to provide a big optimization to applications that can
- * use them.
- */
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
- if (rqmode != DLM_LOCK_PR && (lkb->lkb_exflags & DLM_LKF_ALTPR))
- alt = DLM_LOCK_PR;
- else if (rqmode != DLM_LOCK_CW && (lkb->lkb_exflags & DLM_LKF_ALTCW))
- alt = DLM_LOCK_CW;
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
- if (alt) {
- lkb->lkb_rqmode = alt;
- rv = _can_be_granted(r, lkb, now, 0);
- if (rv)
- set_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
- else
- lkb->lkb_rqmode = rqmode;
+ out_add:
+
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
}
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
out:
- return rv;
+ *r_ret = r;
+ return error;
}
-/* Returns the highest requested mode of all blocked conversions; sets
- cw if there's a blocked conversion to DLM_LOCK_CW. */
-
-static int grant_pending_convert(struct dlm_rsb *r, int high, int *cw,
- unsigned int *count)
-{
- struct dlm_lkb *lkb, *s;
- int recover = rsb_flag(r, RSB_RECOVER_GRANT);
- int hi, demoted, quit, grant_restart, demote_restart;
- int deadlk;
-
- quit = 0;
- restart:
- grant_restart = 0;
- demote_restart = 0;
- hi = DLM_LOCK_IV;
-
- list_for_each_entry_safe(lkb, s, &r->res_convertqueue, lkb_statequeue) {
- demoted = is_demoted(lkb);
- deadlk = 0;
-
- if (can_be_granted(r, lkb, 0, recover, &deadlk)) {
- grant_lock_pending(r, lkb);
- grant_restart = 1;
- if (count)
- (*count)++;
- continue;
- }
-
- if (!demoted && is_demoted(lkb)) {
- log_print("WARN: pending demoted %x node %d %s",
- lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
- demote_restart = 1;
- continue;
- }
-
- if (deadlk) {
- /*
- * If DLM_LKB_NODLKWT flag is set and conversion
- * deadlock is detected, we request blocking AST and
- * down (or cancel) conversion.
- */
- if (lkb->lkb_exflags & DLM_LKF_NODLCKWT) {
- if (lkb->lkb_highbast < lkb->lkb_rqmode) {
- queue_bast(r, lkb, lkb->lkb_rqmode);
- lkb->lkb_highbast = lkb->lkb_rqmode;
- }
- } else {
- log_print("WARN: pending deadlock %x node %d %s",
- lkb->lkb_id, lkb->lkb_nodeid,
- r->res_name);
- dlm_dump_rsb(r);
- }
- continue;
- }
-
- hi = max_t(int, lkb->lkb_rqmode, hi);
+/*
+ * Compatibility matrix for conversions with QUECVT set.
+ * Granted mode is the row; requested mode is the column.
+ * Usage: matrix[grmode+1][rqmode+1]
+ */
- if (cw && lkb->lkb_rqmode == DLM_LOCK_CW)
- *cw = 1;
- }
+static const int __quecvt_compat_matrix[8][8] = {
+ /* UN NL CR CW PR PW EX PD */
+ {0, 0, 0, 0, 0, 0, 0, 0}, /* UN */
+ {0, 0, 1, 1, 1, 1, 1, 0}, /* NL */
+ {0, 0, 0, 1, 1, 1, 1, 0}, /* CR */
+ {0, 0, 0, 0, 1, 1, 1, 0}, /* CW */
+ {0, 0, 0, 1, 0, 1, 1, 0}, /* PR */
+ {0, 0, 0, 0, 0, 0, 1, 0}, /* PW */
+ {0, 0, 0, 0, 0, 0, 0, 0}, /* EX */
+ {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
+};
- if (grant_restart)
- goto restart;
- if (demote_restart && !quit) {
- quit = 1;
- goto restart;
- }
+void dlm_print_lkb(struct dlm_lkb *lkb)
+{
+ printk(KERN_ERR "lkb: nodeid %d id %x remid %x exflags %x flags %x "
+ "sts %d rq %d gr %d wait_type %d wait_nodeid %d seq %llu\n",
+ lkb->lkb_nodeid, lkb->lkb_id, lkb->lkb_remid, lkb->lkb_exflags,
+ dlm_iflags_val(lkb), lkb->lkb_status, lkb->lkb_rqmode,
+ lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_wait_nodeid,
+ (unsigned long long)lkb->lkb_recover_seq);
+}
- return max_t(int, high, hi);
+static void dlm_print_rsb(struct dlm_rsb *r)
+{
+ printk(KERN_ERR "rsb: nodeid %d master %d dir %d flags %lx first %x "
+ "rlc %d name %s\n",
+ r->res_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
+ r->res_flags, r->res_first_lkid, r->res_recover_locks_count,
+ r->res_name);
}
-static int grant_pending_wait(struct dlm_rsb *r, int high, int *cw,
- unsigned int *count)
+void dlm_dump_rsb(struct dlm_rsb *r)
{
- struct dlm_lkb *lkb, *s;
+ struct dlm_lkb *lkb;
- list_for_each_entry_safe(lkb, s, &r->res_waitqueue, lkb_statequeue) {
- if (can_be_granted(r, lkb, 0, 0, NULL)) {
- grant_lock_pending(r, lkb);
- if (count)
- (*count)++;
- } else {
- high = max_t(int, lkb->lkb_rqmode, high);
- if (lkb->lkb_rqmode == DLM_LOCK_CW)
- *cw = 1;
- }
- }
+ dlm_print_rsb(r);
- return high;
+ printk(KERN_ERR "rsb: root_list empty %d recover_list empty %d\n",
+ list_empty(&r->res_root_list), list_empty(&r->res_recover_list));
+ printk(KERN_ERR "rsb lookup list\n");
+ list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb grant queue:\n");
+ list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb convert queue:\n");
+ list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb wait queue:\n");
+ list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
}
-/* cw of 1 means there's a lock with a rqmode of DLM_LOCK_CW that's blocked
- on either the convert or waiting queue.
- high is the largest rqmode of all locks blocked on the convert or
- waiting queue. */
+/* Threads cannot use the lockspace while it's being recovered */
-static int lock_requires_bast(struct dlm_lkb *gr, int high, int cw)
+void dlm_lock_recovery(struct dlm_ls *ls)
{
- if (gr->lkb_grmode == DLM_LOCK_PR && cw) {
- if (gr->lkb_highbast < DLM_LOCK_EX)
- return 1;
- return 0;
- }
+ down_read(&ls->ls_in_recovery);
+}
- if (gr->lkb_highbast < high &&
- !__dlm_compat_matrix[gr->lkb_grmode+1][high+1])
- return 1;
- return 0;
+void dlm_unlock_recovery(struct dlm_ls *ls)
+{
+ up_read(&ls->ls_in_recovery);
}
-static void grant_pending_locks(struct dlm_rsb *r, unsigned int *count)
+int dlm_lock_recovery_try(struct dlm_ls *ls)
{
- struct dlm_lkb *lkb, *s;
- int high = DLM_LOCK_IV;
- int cw = 0;
+ return down_read_trylock(&ls->ls_in_recovery);
+}
- if (!is_master(r)) {
- log_print("grant_pending_locks r nodeid %d", r->res_nodeid);
- dlm_dump_rsb(r);
- return;
- }
+static inline int can_be_queued(struct dlm_lkb *lkb)
+{
+ return !(lkb->lkb_exflags & DLM_LKF_NOQUEUE);
+}
- high = grant_pending_convert(r, high, &cw, count);
- high = grant_pending_wait(r, high, &cw, count);
+static inline int force_blocking_asts(struct dlm_lkb *lkb)
+{
+ return (lkb->lkb_exflags & DLM_LKF_NOQUEUEBAST);
+}
- if (high == DLM_LOCK_IV)
- return;
+static inline int is_demoted(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
+}
- /*
- * If there are locks left on the wait/convert queue then send blocking
- * ASTs to granted locks based on the largest requested mode (high)
- * found above.
- */
+static inline int is_altmode(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
+}
- list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
- if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
- if (cw && high == DLM_LOCK_PR &&
- lkb->lkb_grmode == DLM_LOCK_PR)
- queue_bast(r, lkb, DLM_LOCK_CW);
- else
- queue_bast(r, lkb, high);
- lkb->lkb_highbast = high;
- }
- }
+static inline int is_granted(struct dlm_lkb *lkb)
+{
+ return (lkb->lkb_status == DLM_LKSTS_GRANTED);
+}
+
+static inline int is_remote(struct dlm_rsb *r)
+{
+ DLM_ASSERT(r->res_nodeid >= 0, dlm_print_rsb(r););
+ return !!r->res_nodeid;
}
-static int modes_require_bast(struct dlm_lkb *gr, struct dlm_lkb *rq)
+static inline int is_process_copy(struct dlm_lkb *lkb)
{
- if ((gr->lkb_grmode == DLM_LOCK_PR && rq->lkb_rqmode == DLM_LOCK_CW) ||
- (gr->lkb_grmode == DLM_LOCK_CW && rq->lkb_rqmode == DLM_LOCK_PR)) {
- if (gr->lkb_highbast < DLM_LOCK_EX)
- return 1;
- return 0;
- }
+ return lkb->lkb_nodeid &&
+ !test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
+}
- if (gr->lkb_highbast < rq->lkb_rqmode && !modes_compat(gr, rq))
+static inline int is_master_copy(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
+}
+
+static inline int middle_conversion(struct dlm_lkb *lkb)
+{
+ if ((lkb->lkb_grmode==DLM_LOCK_PR && lkb->lkb_rqmode==DLM_LOCK_CW) ||
+ (lkb->lkb_rqmode==DLM_LOCK_PR && lkb->lkb_grmode==DLM_LOCK_CW))
return 1;
return 0;
}
-static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
- struct dlm_lkb *lkb)
+static inline int down_conversion(struct dlm_lkb *lkb)
{
- struct dlm_lkb *gr;
+ return (!middle_conversion(lkb) && lkb->lkb_rqmode < lkb->lkb_grmode);
+}
- list_for_each_entry(gr, head, lkb_statequeue) {
- /* skip self when sending basts to convertqueue */
- if (gr == lkb)
- continue;
- if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
- queue_bast(r, gr, lkb->lkb_rqmode);
- gr->lkb_highbast = lkb->lkb_rqmode;
- }
- }
+static inline int is_overlap_unlock(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
}
-static void send_blocking_asts(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline int is_overlap_cancel(struct dlm_lkb *lkb)
{
- send_bast_queue(r, &r->res_grantqueue, lkb);
+ return test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
}
-static void send_blocking_asts_all(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline int is_overlap(struct dlm_lkb *lkb)
{
- send_bast_queue(r, &r->res_grantqueue, lkb);
- send_bast_queue(r, &r->res_convertqueue, lkb);
+ return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags) ||
+ test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
}
-/* set_master(r, lkb) -- set the master nodeid of a resource
+static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
+{
+ if (is_master_copy(lkb))
+ return;
- The purpose of this function is to set the nodeid field in the given
- lkb using the nodeid field in the given rsb. If the rsb's nodeid is
- known, it can just be copied to the lkb and the function will return
- 0. If the rsb's nodeid is _not_ known, it needs to be looked up
- before it can be copied to the lkb.
+ DLM_ASSERT(lkb->lkb_lksb, dlm_print_lkb(lkb););
- When the rsb nodeid is being looked up remotely, the initial lkb
- causing the lookup is kept on the ls_waiters list waiting for the
- lookup reply. Other lkb's waiting for the same rsb lookup are kept
- on the rsb's res_lookup list until the master is verified.
+ if (rv == -DLM_ECANCEL &&
+ test_and_clear_bit(DLM_IFL_DEADLOCK_CANCEL_BIT, &lkb->lkb_iflags))
+ rv = -EDEADLK;
- Return values:
- 0: nodeid is set in rsb/lkb and the caller should go ahead and use it
- 1: the rsb master is not available and the lkb has been placed on
- a wait queue
-*/
+ dlm_add_cb(lkb, DLM_CB_CAST, lkb->lkb_grmode, rv, dlm_sbflags_val(lkb));
+}
-static int set_master(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- int our_nodeid = dlm_our_nodeid();
+ queue_cast(r, lkb,
+ is_overlap_unlock(lkb) ? -DLM_EUNLOCK : -DLM_ECANCEL);
+}
- if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
- rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
- r->res_first_lkid = lkb->lkb_id;
- lkb->lkb_nodeid = r->res_nodeid;
- return 0;
+static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
+{
+ if (is_master_copy(lkb)) {
+ send_bast(r, lkb, rqmode);
+ } else {
+ dlm_add_cb(lkb, DLM_CB_BAST, rqmode, 0, 0);
}
+}
- if (r->res_first_lkid && r->res_first_lkid != lkb->lkb_id) {
- list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
- return 1;
- }
+/*
+ * Basic operations on rsb's and lkb's
+ */
- if (r->res_master_nodeid == our_nodeid) {
- lkb->lkb_nodeid = 0;
- return 0;
- }
+static inline unsigned long rsb_toss_jiffies(void)
+{
+ return jiffies + (READ_ONCE(dlm_config.ci_toss_secs) * HZ);
+}
- if (r->res_master_nodeid) {
- lkb->lkb_nodeid = r->res_master_nodeid;
- return 0;
+/* This is only called to add a reference when the code already holds
+ a valid reference to the rsb, so there's no need for locking. */
+
+static inline void hold_rsb(struct dlm_rsb *r)
+{
+ /* inactive rsbs are not ref counted */
+ WARN_ON(rsb_flag(r, RSB_INACTIVE));
+ kref_get(&r->res_ref);
+}
+
+void dlm_hold_rsb(struct dlm_rsb *r)
+{
+ hold_rsb(r);
+}
+
+/* TODO move this to lib/refcount.c */
+static __must_check bool
+dlm_refcount_dec_and_write_lock_bh(refcount_t *r, rwlock_t *lock)
+__cond_acquires(lock)
+{
+ if (refcount_dec_not_one(r))
+ return false;
+
+ write_lock_bh(lock);
+ if (!refcount_dec_and_test(r)) {
+ write_unlock_bh(lock);
+ return false;
}
- if (dlm_dir_nodeid(r) == our_nodeid) {
- /* This is a somewhat unusual case; find_rsb will usually
- have set res_master_nodeid when dir nodeid is local, but
- there are cases where we become the dir node after we've
- past find_rsb and go through _request_lock again.
- confirm_master() or process_lookup_list() needs to be
- called after this. */
- log_debug(r->res_ls, "set_master %x self master %d dir %d %s",
- lkb->lkb_id, r->res_master_nodeid, r->res_dir_nodeid,
- r->res_name);
- r->res_master_nodeid = our_nodeid;
- r->res_nodeid = 0;
- lkb->lkb_nodeid = 0;
- return 0;
+ return true;
+}
+
+/* TODO move this to include/linux/kref.h */
+static inline int dlm_kref_put_write_lock_bh(struct kref *kref,
+ void (*release)(struct kref *kref),
+ rwlock_t *lock)
+{
+ if (dlm_refcount_dec_and_write_lock_bh(&kref->refcount, lock)) {
+ release(kref);
+ return 1;
}
- r->res_first_lkid = lkb->lkb_id;
- send_lookup(r, lkb);
- return 1;
+ return 0;
}
-static void process_lookup_list(struct dlm_rsb *r)
+static void put_rsb(struct dlm_rsb *r)
{
- struct dlm_lkb *lkb, *safe;
+ struct dlm_ls *ls = r->res_ls;
+ int rv;
- list_for_each_entry_safe(lkb, safe, &r->res_lookup, lkb_rsb_lookup) {
- list_del_init(&lkb->lkb_rsb_lookup);
- _request_lock(r, lkb);
- }
+ rv = dlm_kref_put_write_lock_bh(&r->res_ref, deactivate_rsb,
+ &ls->ls_rsbtbl_lock);
+ if (rv)
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
}
-/* confirm_master -- confirm (or deny) an rsb's master nodeid */
+void dlm_put_rsb(struct dlm_rsb *r)
+{
+ put_rsb(r);
+}
-static void confirm_master(struct dlm_rsb *r, int error)
+/* connected with timer_delete_sync() in dlm_ls_stop() to stop
+ * new timers when recovery is triggered and don't run them
+ * again until a resume_scan_timer() tries it again.
+ */
+static void enable_scan_timer(struct dlm_ls *ls, unsigned long jiffies)
{
- struct dlm_lkb *lkb;
+ if (!dlm_locking_stopped(ls))
+ mod_timer(&ls->ls_scan_timer, jiffies);
+}
- if (!r->res_first_lkid)
- return;
+/* This function tries to resume the timer callback if a rsb
+ * is on the scan list and no timer is pending. It might that
+ * the first entry is on currently executed as timer callback
+ * but we don't care if a timer queued up again and does
+ * nothing. Should be a rare case.
+ */
+void resume_scan_timer(struct dlm_ls *ls)
+{
+ struct dlm_rsb *r;
- switch (error) {
- case 0:
- case -EINPROGRESS:
- r->res_first_lkid = 0;
- process_lookup_list(r);
- break;
+ spin_lock_bh(&ls->ls_scan_lock);
+ r = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (r && !timer_pending(&ls->ls_scan_timer))
+ enable_scan_timer(ls, r->res_toss_time);
+ spin_unlock_bh(&ls->ls_scan_lock);
+}
- case -EAGAIN:
- case -EBADR:
- case -ENOTBLK:
- /* the remote request failed and won't be retried (it was
- a NOQUEUE, or has been canceled/unlocked); make a waiting
- lkb the first_lkid */
+/* ls_rsbtbl_lock must be held */
- r->res_first_lkid = 0;
+static void del_scan(struct dlm_ls *ls, struct dlm_rsb *r)
+{
+ struct dlm_rsb *first;
- if (!list_empty(&r->res_lookup)) {
- lkb = list_entry(r->res_lookup.next, struct dlm_lkb,
- lkb_rsb_lookup);
- list_del_init(&lkb->lkb_rsb_lookup);
- r->res_first_lkid = lkb->lkb_id;
- _request_lock(r, lkb);
- }
- break;
+ /* active rsbs should never be on the scan list */
+ WARN_ON(!rsb_flag(r, RSB_INACTIVE));
- default:
- log_error(r->res_ls, "confirm_master unknown error %d", error);
+ spin_lock_bh(&ls->ls_scan_lock);
+ r->res_toss_time = 0;
+
+ /* if the rsb is not queued do nothing */
+ if (list_empty(&r->res_scan_list))
+ goto out;
+
+ /* get the first element before delete */
+ first = list_first_entry(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ list_del_init(&r->res_scan_list);
+ /* check if the first element was the rsb we deleted */
+ if (first == r) {
+ /* try to get the new first element, if the list
+ * is empty now try to delete the timer, if we are
+ * too late we don't care.
+ *
+ * if the list isn't empty and a new first element got
+ * in place, set the new timer expire time.
+ */
+ first = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (!first)
+ timer_delete(&ls->ls_scan_timer);
+ else
+ enable_scan_timer(ls, first->res_toss_time);
}
+
+out:
+ spin_unlock_bh(&ls->ls_scan_lock);
}
-static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
- int namelen, void (*ast)(void *astparam),
- void *astparam,
- void (*bast)(void *astparam, int mode),
- struct dlm_args *args)
+static void add_scan(struct dlm_ls *ls, struct dlm_rsb *r)
{
- int rv = -EINVAL;
-
- /* check for invalid arg usage */
+ int our_nodeid = dlm_our_nodeid();
+ struct dlm_rsb *first;
- if (mode < 0 || mode > DLM_LOCK_EX)
- goto out;
+ /* A dir record for a remote master rsb should never be on the scan list. */
+ WARN_ON(!dlm_no_directory(ls) &&
+ (r->res_master_nodeid != our_nodeid) &&
+ (dlm_dir_nodeid(r) == our_nodeid));
- if (!(flags & DLM_LKF_CONVERT) && (namelen > DLM_RESNAME_MAXLEN))
- goto out;
+ /* An active rsb should never be on the scan list. */
+ WARN_ON(!rsb_flag(r, RSB_INACTIVE));
- if (flags & DLM_LKF_CANCEL)
- goto out;
+ /* An rsb should not already be on the scan list. */
+ WARN_ON(!list_empty(&r->res_scan_list));
- if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
- goto out;
+ spin_lock_bh(&ls->ls_scan_lock);
+ /* set the new rsb absolute expire time in the rsb */
+ r->res_toss_time = rsb_toss_jiffies();
+ if (list_empty(&ls->ls_scan_list)) {
+ /* if the queue is empty add the element and it's
+ * our new expire time
+ */
+ list_add_tail(&r->res_scan_list, &ls->ls_scan_list);
+ enable_scan_timer(ls, r->res_toss_time);
+ } else {
+ /* try to get the maybe new first element and then add
+ * to this rsb with the oldest expire time to the end
+ * of the queue. If the list was empty before this
+ * rsb expire time is our next expiration if it wasn't
+ * the now new first elemet is our new expiration time
+ */
+ first = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ list_add_tail(&r->res_scan_list, &ls->ls_scan_list);
+ if (!first)
+ enable_scan_timer(ls, r->res_toss_time);
+ else
+ enable_scan_timer(ls, first->res_toss_time);
+ }
+ spin_unlock_bh(&ls->ls_scan_lock);
+}
- if (flags & DLM_LKF_CONVDEADLK && !(flags & DLM_LKF_CONVERT))
- goto out;
+/* if we hit contention we do in 250 ms a retry to trylock.
+ * if there is any other mod_timer in between we don't care
+ * about that it expires earlier again this is only for the
+ * unlikely case nothing happened in this time.
+ */
+#define DLM_TOSS_TIMER_RETRY (jiffies + msecs_to_jiffies(250))
- if (flags & DLM_LKF_CONVDEADLK && flags & DLM_LKF_NOQUEUE)
- goto out;
+/* Called by lockspace scan_timer to free unused rsb's. */
- if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_CONVERT)
- goto out;
+void dlm_rsb_scan(struct timer_list *timer)
+{
+ struct dlm_ls *ls = timer_container_of(ls, timer, ls_scan_timer);
+ int our_nodeid = dlm_our_nodeid();
+ struct dlm_rsb *r;
+ int rv;
- if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
- goto out;
+ while (1) {
+ /* interrupting point to leave iteration when
+ * recovery waits for timer_delete_sync(), recovery
+ * will take care to delete everything in scan list.
+ */
+ if (dlm_locking_stopped(ls))
+ break;
- if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
- goto out;
+ rv = spin_trylock(&ls->ls_scan_lock);
+ if (!rv) {
+ /* rearm again try timer */
+ enable_scan_timer(ls, DLM_TOSS_TIMER_RETRY);
+ break;
+ }
- if (flags & DLM_LKF_EXPEDITE && mode != DLM_LOCK_NL)
- goto out;
+ r = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (!r) {
+ /* the next add_scan will enable the timer again */
+ spin_unlock(&ls->ls_scan_lock);
+ break;
+ }
- if (!ast || !lksb)
- goto out;
+ /*
+ * If the first rsb is not yet expired, then stop because the
+ * list is sorted with nearest expiration first.
+ */
+ if (time_before(jiffies, r->res_toss_time)) {
+ /* rearm with the next rsb to expire in the future */
+ enable_scan_timer(ls, r->res_toss_time);
+ spin_unlock(&ls->ls_scan_lock);
+ break;
+ }
- if (flags & DLM_LKF_VALBLK && !lksb->sb_lvbptr)
- goto out;
+ /* in find_rsb_dir/nodir there is a reverse order of this
+ * lock, however this is only a trylock if we hit some
+ * possible contention we try it again.
+ */
+ rv = write_trylock(&ls->ls_rsbtbl_lock);
+ if (!rv) {
+ spin_unlock(&ls->ls_scan_lock);
+ /* rearm again try timer */
+ enable_scan_timer(ls, DLM_TOSS_TIMER_RETRY);
+ break;
+ }
- if (flags & DLM_LKF_CONVERT && !lksb->sb_lkid)
- goto out;
+ list_del(&r->res_slow_list);
+ rhashtable_remove_fast(&ls->ls_rsbtbl, &r->res_node,
+ dlm_rhash_rsb_params);
+ rsb_clear_flag(r, RSB_HASHED);
- /* these args will be copied to the lkb in validate_lock_args,
- it cannot be done now because when converting locks, fields in
- an active lkb cannot be modified before locking the rsb */
+ /* ls_rsbtbl_lock is not needed when calling send_remove() */
+ write_unlock(&ls->ls_rsbtbl_lock);
- args->flags = flags;
- args->astfn = ast;
- args->astparam = astparam;
- args->bastfn = bast;
- args->mode = mode;
- args->lksb = lksb;
- rv = 0;
- out:
- return rv;
-}
+ list_del_init(&r->res_scan_list);
+ spin_unlock(&ls->ls_scan_lock);
-static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
-{
- if (flags & ~(DLM_LKF_CANCEL | DLM_LKF_VALBLK | DLM_LKF_IVVALBLK |
- DLM_LKF_FORCEUNLOCK))
- return -EINVAL;
+ /* An rsb that is a dir record for a remote master rsb
+ * cannot be removed, and should not have a timer enabled.
+ */
+ WARN_ON(!dlm_no_directory(ls) &&
+ (r->res_master_nodeid != our_nodeid) &&
+ (dlm_dir_nodeid(r) == our_nodeid));
- if (flags & DLM_LKF_CANCEL && flags & DLM_LKF_FORCEUNLOCK)
- return -EINVAL;
+ /* We're the master of this rsb but we're not
+ * the directory record, so we need to tell the
+ * dir node to remove the dir record
+ */
+ if (!dlm_no_directory(ls) &&
+ (r->res_master_nodeid == our_nodeid) &&
+ (dlm_dir_nodeid(r) != our_nodeid))
+ send_remove(r);
- args->flags = flags;
- args->astparam = astarg;
- return 0;
+ free_inactive_rsb(r);
+ }
}
-static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_args *args)
-{
- int rv = -EBUSY;
-
- if (args->flags & DLM_LKF_CONVERT) {
- if (lkb->lkb_status != DLM_LKSTS_GRANTED)
- goto out;
-
- /* lock not allowed if there's any op in progress */
- if (lkb->lkb_wait_type || lkb->lkb_wait_count)
- goto out;
+/* If ls->ls_new_rsb is empty, return -EAGAIN, so the caller can
+ unlock any spinlocks, go back and call pre_rsb_struct again.
+ Otherwise, take an rsb off the list and return it. */
- if (is_overlap(lkb))
- goto out;
+static int get_rsb_struct(struct dlm_ls *ls, const void *name, int len,
+ struct dlm_rsb **r_ret)
+{
+ struct dlm_rsb *r;
- rv = -EINVAL;
- if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags))
- goto out;
+ r = dlm_allocate_rsb();
+ if (!r)
+ return -ENOMEM;
- if (args->flags & DLM_LKF_QUECVT &&
- !__quecvt_compat_matrix[lkb->lkb_grmode+1][args->mode+1])
- goto out;
- }
+ r->res_ls = ls;
+ r->res_length = len;
+ memcpy(r->res_name, name, len);
+ spin_lock_init(&r->res_lock);
- lkb->lkb_exflags = args->flags;
- dlm_set_sbflags_val(lkb, 0);
- lkb->lkb_astfn = args->astfn;
- lkb->lkb_astparam = args->astparam;
- lkb->lkb_bastfn = args->bastfn;
- lkb->lkb_rqmode = args->mode;
- lkb->lkb_lksb = args->lksb;
- lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
- lkb->lkb_ownpid = (int) current->pid;
- rv = 0;
- out:
- switch (rv) {
- case 0:
- break;
- case -EINVAL:
- /* annoy the user because dlm usage is wrong */
- WARN_ON(1);
- log_error(ls, "%s %d %x %x %x %d %d", __func__,
- rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
- lkb->lkb_status, lkb->lkb_wait_type);
- break;
- default:
- log_debug(ls, "%s %d %x %x %x %d %d", __func__,
- rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
- lkb->lkb_status, lkb->lkb_wait_type);
- break;
- }
+ INIT_LIST_HEAD(&r->res_lookup);
+ INIT_LIST_HEAD(&r->res_grantqueue);
+ INIT_LIST_HEAD(&r->res_convertqueue);
+ INIT_LIST_HEAD(&r->res_waitqueue);
+ INIT_LIST_HEAD(&r->res_root_list);
+ INIT_LIST_HEAD(&r->res_scan_list);
+ INIT_LIST_HEAD(&r->res_recover_list);
+ INIT_LIST_HEAD(&r->res_masters_list);
- return rv;
+ *r_ret = r;
+ return 0;
}
-/* when dlm_unlock() sees -EBUSY with CANCEL/FORCEUNLOCK it returns 0
- for success */
+int dlm_search_rsb_tree(struct rhashtable *rhash, const void *name, int len,
+ struct dlm_rsb **r_ret)
+{
+ char key[DLM_RESNAME_MAXLEN] = {};
-/* note: it's valid for lkb_nodeid/res_nodeid to be -1 when we get here
- because there may be a lookup in progress and it's valid to do
- cancel/unlockf on it */
+ memcpy(key, name, len);
+ *r_ret = rhashtable_lookup_fast(rhash, &key, dlm_rhash_rsb_params);
+ if (*r_ret)
+ return 0;
-static int validate_unlock_args(struct dlm_lkb *lkb, struct dlm_args *args)
+ return -EBADR;
+}
+
+static int rsb_insert(struct dlm_rsb *rsb, struct rhashtable *rhash)
{
- struct dlm_ls *ls = lkb->lkb_resource->res_ls;
- int rv = -EBUSY;
+ int rv;
- /* normal unlock not allowed if there's any op in progress */
- if (!(args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) &&
- (lkb->lkb_wait_type || lkb->lkb_wait_count))
- goto out;
+ rv = rhashtable_insert_fast(rhash, &rsb->res_node,
+ dlm_rhash_rsb_params);
+ if (!rv)
+ rsb_set_flag(rsb, RSB_HASHED);
- /* an lkb may be waiting for an rsb lookup to complete where the
- lookup was initiated by another lock */
+ return rv;
+}
- if (!list_empty(&lkb->lkb_rsb_lookup)) {
- if (args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) {
- log_debug(ls, "unlock on rsb_lookup %x", lkb->lkb_id);
- list_del_init(&lkb->lkb_rsb_lookup);
- queue_cast(lkb->lkb_resource, lkb,
- args->flags & DLM_LKF_CANCEL ?
- -DLM_ECANCEL : -DLM_EUNLOCK);
- unhold_lkb(lkb); /* undoes create_lkb() */
- }
- /* caller changes -EBUSY to 0 for CANCEL and FORCEUNLOCK */
- goto out;
- }
+/*
+ * Find rsb in rsbtbl and potentially create/add one
+ *
+ * Delaying the release of rsb's has a similar benefit to applications keeping
+ * NL locks on an rsb, but without the guarantee that the cached master value
+ * will still be valid when the rsb is reused. Apps aren't always smart enough
+ * to keep NL locks on an rsb that they may lock again shortly; this can lead
+ * to excessive master lookups and removals if we don't delay the release.
+ *
+ * Searching for an rsb means looking through both the normal list and toss
+ * list. When found on the toss list the rsb is moved to the normal list with
+ * ref count of 1; when found on normal list the ref count is incremented.
+ *
+ * rsb's on the keep list are being used locally and refcounted.
+ * rsb's on the toss list are not being used locally, and are not refcounted.
+ *
+ * The toss list rsb's were either
+ * - previously used locally but not any more (were on keep list, then
+ * moved to toss list when last refcount dropped)
+ * - created and put on toss list as a directory record for a lookup
+ * (we are the dir node for the res, but are not using the res right now,
+ * but some other node is)
+ *
+ * The purpose of find_rsb() is to return a refcounted rsb for local use.
+ * So, if the given rsb is on the toss list, it is moved to the keep list
+ * before being returned.
+ *
+ * deactivate_rsb() happens when all local usage of the rsb is done, i.e. no
+ * more refcounts exist, so the rsb is moved from the keep list to the
+ * toss list.
+ *
+ * rsb's on both keep and toss lists are used for doing a name to master
+ * lookups. rsb's that are in use locally (and being refcounted) are on
+ * the keep list, rsb's that are not in use locally (not refcounted) and
+ * only exist for name/master lookups are on the toss list.
+ *
+ * rsb's on the toss list who's dir_nodeid is not local can have stale
+ * name/master mappings. So, remote requests on such rsb's can potentially
+ * return with an error, which means the mapping is stale and needs to
+ * be updated with a new lookup. (The idea behind MASTER UNCERTAIN and
+ * first_lkid is to keep only a single outstanding request on an rsb
+ * while that rsb has a potentially stale master.)
+ */
- rv = -EINVAL;
- if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags)) {
- log_error(ls, "unlock on MSTCPY %x", lkb->lkb_id);
- dlm_print_lkb(lkb);
- goto out;
+static int find_rsb_dir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
+{
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int from_local = 0;
+ int from_other = 0;
+ int from_dir = 0;
+ int create = 0;
+ int error;
+
+ if (flags & R_RECEIVE_REQUEST) {
+ if (from_nodeid == dir_nodeid)
+ from_dir = 1;
+ else
+ from_other = 1;
+ } else if (flags & R_REQUEST) {
+ from_local = 1;
}
- /* an lkb may still exist even though the lock is EOL'ed due to a
- * cancel, unlock or failed noqueue request; an app can't use these
- * locks; return same error as if the lkid had not been found at all
+ /*
+ * flags & R_RECEIVE_RECOVER is from dlm_recover_master_copy, so
+ * from_nodeid has sent us a lock in dlm_recover_locks, believing
+ * we're the new master. Our local recovery may not have set
+ * res_master_nodeid to our_nodeid yet, so allow either. Don't
+ * create the rsb; dlm_recover_process_copy() will handle EBADR
+ * by resending.
+ *
+ * If someone sends us a request, we are the dir node, and we do
+ * not find the rsb anywhere, then recreate it. This happens if
+ * someone sends us a request after we have removed/freed an rsb.
+ * (They sent a request instead of lookup because they are using
+ * an rsb taken from their scan list.)
*/
- if (test_bit(DLM_IFL_ENDOFLIFE_BIT, &lkb->lkb_iflags)) {
- log_debug(ls, "unlock on ENDOFLIFE %x", lkb->lkb_id);
- rv = -ENOENT;
- goto out;
+ if (from_local || from_dir ||
+ (from_other && (dir_nodeid == our_nodeid))) {
+ create = 1;
}
- if (is_overlap_unlock(lkb))
- goto out;
-
- /* cancel not allowed with another cancel/unlock in progress */
-
- if (args->flags & DLM_LKF_CANCEL) {
- if (lkb->lkb_exflags & DLM_LKF_CANCEL)
- goto out;
-
- if (is_overlap_cancel(lkb))
- goto out;
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
+ if (error)
+ goto do_new;
- if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
- set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
- rv = -EBUSY;
- goto out;
- }
+ /* check if the rsb is active under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -EBADR;
+ goto do_new;
+ }
- /* there's nothing to cancel */
- if (lkb->lkb_status == DLM_LKSTS_GRANTED &&
- !lkb->lkb_wait_type) {
- rv = -EBUSY;
- goto out;
- }
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
- switch (lkb->lkb_wait_type) {
- case DLM_MSG_LOOKUP:
- case DLM_MSG_REQUEST:
- set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
- rv = -EBUSY;
- goto out;
- case DLM_MSG_UNLOCK:
- case DLM_MSG_CANCEL:
- goto out;
- }
- /* add_to_waiters() will set OVERLAP_CANCEL */
- goto out_ok;
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
}
- /* do we need to allow a force-unlock if there's a normal unlock
- already in progress? in what conditions could the normal unlock
- fail such that we'd want to send a force-unlock to be sure? */
-
- if (args->flags & DLM_LKF_FORCEUNLOCK) {
- if (lkb->lkb_exflags & DLM_LKF_FORCEUNLOCK)
- goto out;
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto out;
- if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
- set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
- rv = -EBUSY;
- goto out;
- }
- switch (lkb->lkb_wait_type) {
- case DLM_MSG_LOOKUP:
- case DLM_MSG_REQUEST:
- set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
- rv = -EBUSY;
- goto out;
- case DLM_MSG_UNLOCK:
- goto out;
- }
- /* add_to_waiters() will set OVERLAP_UNLOCK */
- }
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
- out_ok:
- /* an overlapping op shouldn't blow away exflags from other op */
- lkb->lkb_exflags |= args->flags;
- dlm_set_sbflags_val(lkb, 0);
- lkb->lkb_astparam = args->astparam;
- rv = 0;
- out:
- switch (rv) {
- case 0:
- break;
- case -EINVAL:
- /* annoy the user because dlm usage is wrong */
- WARN_ON(1);
- log_error(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
- lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
- args->flags, lkb->lkb_wait_type,
- lkb->lkb_resource->res_name);
- break;
- default:
- log_debug(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
- lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
- args->flags, lkb->lkb_wait_type,
- lkb->lkb_resource->res_name);
- break;
+ /*
+ * The expectation here is that the rsb will have HASHED and
+ * INACTIVE flags set, and that the rsb can be moved from
+ * inactive back to active again. However, between releasing
+ * the read lock and acquiring the write lock, this rsb could
+ * have been removed from rsbtbl, and had HASHED cleared, to
+ * be freed. To deal with this case, we would normally need
+ * to repeat dlm_search_rsb_tree while holding the write lock,
+ * but rcu allows us to simply check the HASHED flag, because
+ * the rcu read lock means the rsb will not be freed yet.
+ * If the HASHED flag is not set, then the rsb is being freed,
+ * so we add a new rsb struct. If the HASHED flag is set,
+ * and INACTIVE is not set, it means another thread has
+ * made the rsb active, as we're expecting to do here, and
+ * we just repeat the lookup (this will be very unlikely.)
+ */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
+ }
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -EBADR;
+ goto do_new;
}
- return rv;
-}
-
-/*
- * Four stage 4 varieties:
- * do_request(), do_convert(), do_unlock(), do_cancel()
- * These are called on the master node for the given lock and
- * from the central locking logic.
- */
-
-static int do_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- int error = 0;
+ /*
+ * rsb found inactive (master_nodeid may be out of date unless
+ * we are the dir_nodeid or were the master) No other thread
+ * is using this rsb because it's inactive, so we can
+ * look at or update res_master_nodeid without lock_rsb.
+ */
- if (can_be_granted(r, lkb, 1, 0, NULL)) {
- grant_lock(r, lkb);
- queue_cast(r, lkb, 0);
+ if ((r->res_master_nodeid != our_nodeid) && from_other) {
+ /* our rsb was not master, and another node (not the dir node)
+ has sent us a request */
+ log_debug(ls, "find_rsb inactive from_other %d master %d dir %d %s",
+ from_nodeid, r->res_master_nodeid, dir_nodeid,
+ r->res_name);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
goto out;
}
- if (can_be_queued(lkb)) {
- error = -EINPROGRESS;
- add_lkb(r, lkb, DLM_LKSTS_WAITING);
- goto out;
+ if ((r->res_master_nodeid != our_nodeid) && from_dir) {
+ /* don't think this should ever happen */
+ log_error(ls, "find_rsb inactive from_dir %d master %d",
+ from_nodeid, r->res_master_nodeid);
+ dlm_print_rsb(r);
+ /* fix it and go on */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
+ r->res_first_lkid = 0;
}
- error = -EAGAIN;
- queue_cast(r, lkb, -EAGAIN);
- out:
- return error;
-}
-
-static void do_request_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int error)
-{
- switch (error) {
- case -EAGAIN:
- if (force_blocking_asts(lkb))
- send_blocking_asts_all(r, lkb);
- break;
- case -EINPROGRESS:
- send_blocking_asts(r, lkb);
- break;
+ if (from_local && (r->res_master_nodeid != our_nodeid)) {
+ /* Because we have held no locks on this rsb,
+ res_master_nodeid could have become stale. */
+ rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
+ r->res_first_lkid = 0;
}
-}
-static int do_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- int error = 0;
- int deadlk = 0;
+ /* we always deactivate scan timer for the rsb, when
+ * we move it out of the inactive state as rsb state
+ * can be changed and scan timers are only for inactive
+ * rsbs.
+ */
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- /* changing an existing lock may allow others to be granted */
+ goto out;
- if (can_be_granted(r, lkb, 1, 0, &deadlk)) {
- grant_lock(r, lkb);
- queue_cast(r, lkb, 0);
- goto out;
- }
- /* can_be_granted() detected that this lock would block in a conversion
- deadlock, so we leave it on the granted queue and return EDEADLK in
- the ast for the convert. */
+ do_new:
+ /*
+ * rsb not found
+ */
- if (deadlk && !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
- /* it's left on the granted queue */
- revert_lock(r, lkb);
- queue_cast(r, lkb, -EDEADLK);
- error = -EDEADLK;
+ if (error == -EBADR && !create)
goto out;
- }
- /* is_demoted() means the can_be_granted() above set the grmode
- to NL, and left us on the granted queue. This auto-demotion
- (due to CONVDEADLK) might mean other locks, and/or this lock, are
- now grantable. We have to try to grant other converting locks
- before we try again to grant this one. */
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
+ goto out;
- if (is_demoted(lkb)) {
- grant_pending_convert(r, DLM_LOCK_IV, NULL, NULL);
- if (_can_be_granted(r, lkb, 1, 0)) {
- grant_lock(r, lkb);
- queue_cast(r, lkb, 0);
- goto out;
- }
- /* else fall through and move to convert queue */
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
+
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
}
- if (can_be_queued(lkb)) {
- error = -EINPROGRESS;
- del_lkb(r, lkb);
- add_lkb(r, lkb, DLM_LKSTS_CONVERT);
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
goto out;
}
- error = -EAGAIN;
- queue_cast(r, lkb, -EAGAIN);
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
+
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
+
+ out_add:
+
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
+ }
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
out:
+ *r_ret = r;
return error;
}
-static void do_convert_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int error)
+/*
+ * Compatibility matrix for conversions with QUECVT set.
+ * Granted mode is the row; requested mode is the column.
+ * Usage: matrix[grmode+1][rqmode+1]
+ */
+
+static const int __quecvt_compat_matrix[8][8] = {
+ /* UN NL CR CW PR PW EX PD */
+ {0, 0, 0, 0, 0, 0, 0, 0}, /* UN */
+ {0, 0, 1, 1, 1, 1, 1, 0}, /* NL */
+ {0, 0, 0, 1, 1, 1, 1, 0}, /* CR */
+ {0, 0, 0, 0, 1, 1, 1, 0}, /* CW */
+ {0, 0, 0, 1, 0, 1, 1, 0}, /* PR */
+ {0, 0, 0, 0, 0, 0, 1, 0}, /* PW */
+ {0, 0, 0, 0, 0, 0, 0, 0}, /* EX */
+ {0, 0, 0, 0, 0, 0, 0, 0} /* PD */
+};
+
+void dlm_print_lkb(struct dlm_lkb *lkb)
{
- switch (error) {
- case 0:
- grant_pending_locks(r, NULL);
- /* grant_pending_locks also sends basts */
- break;
- case -EAGAIN:
- if (force_blocking_asts(lkb))
- send_blocking_asts_all(r, lkb);
- break;
- case -EINPROGRESS:
- send_blocking_asts(r, lkb);
- break;
- }
+ printk(KERN_ERR "lkb: nodeid %d id %x remid %x exflags %x flags %x "
+ "sts %d rq %d gr %d wait_type %d wait_nodeid %d seq %llu\n",
+ lkb->lkb_nodeid, lkb->lkb_id, lkb->lkb_remid, lkb->lkb_exflags,
+ dlm_iflags_val(lkb), lkb->lkb_status, lkb->lkb_rqmode,
+ lkb->lkb_grmode, lkb->lkb_wait_type, lkb->lkb_wait_nodeid,
+ (unsigned long long)lkb->lkb_recover_seq);
+}
+
+static void dlm_print_rsb(struct dlm_rsb *r)
+{
+ printk(KERN_ERR "rsb: nodeid %d master %d dir %d flags %lx first %x "
+ "rlc %d name %s\n",
+ r->res_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
+ r->res_flags, r->res_first_lkid, r->res_recover_locks_count,
+ r->res_name);
+}
+
+void dlm_dump_rsb(struct dlm_rsb *r)
+{
+ struct dlm_lkb *lkb;
+
+ dlm_print_rsb(r);
+
+ printk(KERN_ERR "rsb: root_list empty %d recover_list empty %d\n",
+ list_empty(&r->res_root_list), list_empty(&r->res_recover_list));
+ printk(KERN_ERR "rsb lookup list\n");
+ list_for_each_entry(lkb, &r->res_lookup, lkb_rsb_lookup)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb grant queue:\n");
+ list_for_each_entry(lkb, &r->res_grantqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb convert queue:\n");
+ list_for_each_entry(lkb, &r->res_convertqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
+ printk(KERN_ERR "rsb wait queue:\n");
+ list_for_each_entry(lkb, &r->res_waitqueue, lkb_statequeue)
+ dlm_print_lkb(lkb);
}
-static int do_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+/* Threads cannot use the lockspace while it's being recovered */
+
+void dlm_lock_recovery(struct dlm_ls *ls)
{
- remove_lock(r, lkb);
- queue_cast(r, lkb, -DLM_EUNLOCK);
- return -DLM_EUNLOCK;
+ down_read(&ls->ls_in_recovery);
}
-static void do_unlock_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int error)
+void dlm_unlock_recovery(struct dlm_ls *ls)
{
- grant_pending_locks(r, NULL);
+ up_read(&ls->ls_in_recovery);
}
-/* returns: 0 did nothing, -DLM_ECANCEL canceled lock */
-
-static int do_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
+int dlm_lock_recovery_try(struct dlm_ls *ls)
{
- int error;
+ return down_read_trylock(&ls->ls_in_recovery);
+}
- error = revert_lock(r, lkb);
- if (error) {
- queue_cast(r, lkb, -DLM_ECANCEL);
- return -DLM_ECANCEL;
- }
- return 0;
+static inline int can_be_queued(struct dlm_lkb *lkb)
+{
+ return !(lkb->lkb_exflags & DLM_LKF_NOQUEUE);
}
-static void do_cancel_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int error)
+static inline int force_blocking_asts(struct dlm_lkb *lkb)
{
- if (error)
- grant_pending_locks(r, NULL);
+ return (lkb->lkb_exflags & DLM_LKF_NOQUEUEBAST);
}
-/*
- * Four stage 3 varieties:
- * _request_lock(), _convert_lock(), _unlock_lock(), _cancel_lock()
- */
+static inline int is_demoted(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
+}
-/* add a new lkb to a possibly new rsb, called by requesting process */
+static inline int is_altmode(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
+}
-static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline int is_granted(struct dlm_lkb *lkb)
{
- int error;
+ return (lkb->lkb_status == DLM_LKSTS_GRANTED);
+}
- /* set_master: sets lkb nodeid from r */
+static inline int is_remote(struct dlm_rsb *r)
+{
+ DLM_ASSERT(r->res_nodeid >= 0, dlm_print_rsb(r););
+ return !!r->res_nodeid;
+}
- error = set_master(r, lkb);
- if (error < 0)
- goto out;
- if (error) {
- error = 0;
- goto out;
- }
+static inline int is_process_copy(struct dlm_lkb *lkb)
+{
+ return lkb->lkb_nodeid &&
+ !test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
+}
- if (is_remote(r)) {
- /* receive_request() calls do_request() on remote node */
- error = send_request(r, lkb);
- } else {
- error = do_request(r, lkb);
- /* for remote locks the request_reply is sent
- between do_request and do_request_effects */
- do_request_effects(r, lkb, error);
- }
- out:
- return error;
+static inline int is_master_copy(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
}
-/* change some property of an existing lkb, e.g. mode */
+static inline int middle_conversion(struct dlm_lkb *lkb)
+{
+ if ((lkb->lkb_grmode==DLM_LOCK_PR && lkb->lkb_rqmode==DLM_LOCK_CW) ||
+ (lkb->lkb_rqmode==DLM_LOCK_PR && lkb->lkb_grmode==DLM_LOCK_CW))
+ return 1;
+ return 0;
+}
-static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline int down_conversion(struct dlm_lkb *lkb)
{
- int error;
+ return (!middle_conversion(lkb) && lkb->lkb_rqmode < lkb->lkb_grmode);
+}
- if (is_remote(r)) {
- /* receive_convert() calls do_convert() on remote node */
- error = send_convert(r, lkb);
- } else {
- error = do_convert(r, lkb);
- /* for remote locks the convert_reply is sent
- between do_convert and do_convert_effects */
- do_convert_effects(r, lkb, error);
- }
+static inline int is_overlap_unlock(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
+}
- return error;
+static inline int is_overlap_cancel(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
}
-/* remove an existing lkb from the granted queue */
+static inline int is_overlap(struct dlm_lkb *lkb)
+{
+ return test_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags) ||
+ test_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
+}
-static int _unlock_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static void queue_cast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
{
- int error;
+ if (is_master_copy(lkb))
+ return;
- if (is_remote(r)) {
- /* receive_unlock() calls do_unlock() on remote node */
- error = send_unlock(r, lkb);
- } else {
- error = do_unlock(r, lkb);
- /* for remote locks the unlock_reply is sent
- between do_unlock and do_unlock_effects */
- do_unlock_effects(r, lkb, error);
- }
+ DLM_ASSERT(lkb->lkb_lksb, dlm_print_lkb(lkb););
- return error;
-}
+ if (rv == -DLM_ECANCEL &&
+ test_and_clear_bit(DLM_IFL_DEADLOCK_CANCEL_BIT, &lkb->lkb_iflags))
+ rv = -EDEADLK;
-/* remove an existing lkb from the convert or wait queue */
+ dlm_add_cb(lkb, DLM_CB_CAST, lkb->lkb_grmode, rv, dlm_sbflags_val(lkb));
+}
-static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static inline void queue_cast_overlap(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- int error;
+ queue_cast(r, lkb,
+ is_overlap_unlock(lkb) ? -DLM_EUNLOCK : -DLM_ECANCEL);
+}
- if (is_remote(r)) {
- /* receive_cancel() calls do_cancel() on remote node */
- error = send_cancel(r, lkb);
+static void queue_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int rqmode)
+{
+ if (is_master_copy(lkb)) {
+ send_bast(r, lkb, rqmode);
} else {
- error = do_cancel(r, lkb);
- /* for remote locks the cancel_reply is sent
- between do_cancel and do_cancel_effects */
- do_cancel_effects(r, lkb, error);
+ dlm_add_cb(lkb, DLM_CB_BAST, rqmode, 0, 0);
}
-
- return error;
}
/*
- * Four stage 2 varieties:
- * request_lock(), convert_lock(), unlock_lock(), cancel_lock()
+ * Basic operations on rsb's and lkb's
*/
-static int request_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
- const void *name, int len,
- struct dlm_args *args)
+static inline unsigned long rsb_toss_jiffies(void)
{
- struct dlm_rsb *r;
- int error;
-
- error = validate_lock_args(ls, lkb, args);
- if (error)
- return error;
-
- error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
- if (error)
- return error;
-
- lock_rsb(r);
-
- attach_lkb(r, lkb);
- lkb->lkb_lksb->sb_lkid = lkb->lkb_id;
+ return jiffies + (READ_ONCE(dlm_config.ci_toss_secs) * HZ);
+}
- error = _request_lock(r, lkb);
+/* This is only called to add a reference when the code already holds
+ a valid reference to the rsb, so there's no need for locking. */
- unlock_rsb(r);
- put_rsb(r);
- return error;
+static inline void hold_rsb(struct dlm_rsb *r)
+{
+ /* inactive rsbs are not ref counted */
+ WARN_ON(rsb_flag(r, RSB_INACTIVE));
+ kref_get(&r->res_ref);
}
-static int convert_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_args *args)
+void dlm_hold_rsb(struct dlm_rsb *r)
{
- struct dlm_rsb *r;
- int error;
-
- r = lkb->lkb_resource;
-
hold_rsb(r);
- lock_rsb(r);
-
- error = validate_lock_args(ls, lkb, args);
- if (error)
- goto out;
-
- error = _convert_lock(r, lkb);
- out:
- unlock_rsb(r);
- put_rsb(r);
- return error;
}
-static int unlock_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_args *args)
+/* TODO move this to lib/refcount.c */
+static __must_check bool
+dlm_refcount_dec_and_write_lock_bh(refcount_t *r, rwlock_t *lock)
+__cond_acquires(lock)
{
- struct dlm_rsb *r;
- int error;
-
- r = lkb->lkb_resource;
-
- hold_rsb(r);
- lock_rsb(r);
+ if (refcount_dec_not_one(r))
+ return false;
- error = validate_unlock_args(lkb, args);
- if (error)
- goto out;
+ write_lock_bh(lock);
+ if (!refcount_dec_and_test(r)) {
+ write_unlock_bh(lock);
+ return false;
+ }
- error = _unlock_lock(r, lkb);
- out:
- unlock_rsb(r);
- put_rsb(r);
- return error;
+ return true;
}
-static int cancel_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_args *args)
+/* TODO move this to include/linux/kref.h */
+static inline int dlm_kref_put_write_lock_bh(struct kref *kref,
+ void (*release)(struct kref *kref),
+ rwlock_t *lock)
{
- struct dlm_rsb *r;
- int error;
+ if (dlm_refcount_dec_and_write_lock_bh(&kref->refcount, lock)) {
+ release(kref);
+ return 1;
+ }
- r = lkb->lkb_resource;
+ return 0;
+}
- hold_rsb(r);
- lock_rsb(r);
+static void put_rsb(struct dlm_rsb *r)
+{
+ struct dlm_ls *ls = r->res_ls;
+ int rv;
- error = validate_unlock_args(lkb, args);
- if (error)
- goto out;
+ rv = dlm_kref_put_write_lock_bh(&r->res_ref, deactivate_rsb,
+ &ls->ls_rsbtbl_lock);
+ if (rv)
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+}
- error = _cancel_lock(r, lkb);
- out:
- unlock_rsb(r);
+void dlm_put_rsb(struct dlm_rsb *r)
+{
put_rsb(r);
- return error;
}
-/*
- * Two stage 1 varieties: dlm_lock() and dlm_unlock()
+/* connected with timer_delete_sync() in dlm_ls_stop() to stop
+ * new timers when recovery is triggered and don't run them
+ * again until a resume_scan_timer() tries it again.
*/
-
-int dlm_lock(dlm_lockspace_t *lockspace,
- int mode,
- struct dlm_lksb *lksb,
- uint32_t flags,
- const void *name,
- unsigned int namelen,
- uint32_t parent_lkid,
- void (*ast) (void *astarg),
- void *astarg,
- void (*bast) (void *astarg, int mode))
+static void enable_scan_timer(struct dlm_ls *ls, unsigned long jiffies)
{
- struct dlm_ls *ls;
- struct dlm_lkb *lkb;
- struct dlm_args args;
- int error, convert = flags & DLM_LKF_CONVERT;
+ if (!dlm_locking_stopped(ls))
+ mod_timer(&ls->ls_scan_timer, jiffies);
+}
- ls = dlm_find_lockspace_local(lockspace);
- if (!ls)
- return -EINVAL;
+/* This function tries to resume the timer callback if a rsb
+ * is on the scan list and no timer is pending. It might that
+ * the first entry is on currently executed as timer callback
+ * but we don't care if a timer queued up again and does
+ * nothing. Should be a rare case.
+ */
+void resume_scan_timer(struct dlm_ls *ls)
+{
+ struct dlm_rsb *r;
- dlm_lock_recovery(ls);
+ spin_lock_bh(&ls->ls_scan_lock);
+ r = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (r && !timer_pending(&ls->ls_scan_timer))
+ enable_scan_timer(ls, r->res_toss_time);
+ spin_unlock_bh(&ls->ls_scan_lock);
+}
- if (convert)
- error = find_lkb(ls, lksb->sb_lkid, &lkb);
- else
- error = create_lkb(ls, &lkb);
+/* ls_rsbtbl_lock must be held */
- if (error)
- goto out;
+static void del_scan(struct dlm_ls *ls, struct dlm_rsb *r)
+{
+ struct dlm_rsb *first;
- trace_dlm_lock_start(ls, lkb, name, namelen, mode, flags);
+ /* active rsbs should never be on the scan list */
+ WARN_ON(!rsb_flag(r, RSB_INACTIVE));
- error = set_lock_args(mode, lksb, flags, namelen, ast, astarg, bast,
- &args);
- if (error)
- goto out_put;
+ spin_lock_bh(&ls->ls_scan_lock);
+ r->res_toss_time = 0;
- if (convert)
- error = convert_lock(ls, lkb, &args);
- else
- error = request_lock(ls, lkb, name, namelen, &args);
+ /* if the rsb is not queued do nothing */
+ if (list_empty(&r->res_scan_list))
+ goto out;
- if (error == -EINPROGRESS)
- error = 0;
- out_put:
- trace_dlm_lock_end(ls, lkb, name, namelen, mode, flags, error, true);
+ /* get the first element before delete */
+ first = list_first_entry(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ list_del_init(&r->res_scan_list);
+ /* check if the first element was the rsb we deleted */
+ if (first == r) {
+ /* try to get the new first element, if the list
+ * is empty now try to delete the timer, if we are
+ * too late we don't care.
+ *
+ * if the list isn't empty and a new first element got
+ * in place, set the new timer expire time.
+ */
+ first = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (!first)
+ timer_delete(&ls->ls_scan_timer);
+ else
+ enable_scan_timer(ls, first->res_toss_time);
+ }
- if (convert || error)
- __put_lkb(ls, lkb);
- if (error == -EAGAIN || error == -EDEADLK)
- error = 0;
- out:
- dlm_unlock_recovery(ls);
- dlm_put_lockspace(ls);
- return error;
+out:
+ spin_unlock_bh(&ls->ls_scan_lock);
}
-int dlm_unlock(dlm_lockspace_t *lockspace,
- uint32_t lkid,
- uint32_t flags,
- struct dlm_lksb *lksb,
- void *astarg)
+static void add_scan(struct dlm_ls *ls, struct dlm_rsb *r)
{
- struct dlm_ls *ls;
- struct dlm_lkb *lkb;
- struct dlm_args args;
- int error;
+ int our_nodeid = dlm_our_nodeid();
+ struct dlm_rsb *first;
- ls = dlm_find_lockspace_local(lockspace);
- if (!ls)
- return -EINVAL;
+ /* A dir record for a remote master rsb should never be on the scan list. */
+ WARN_ON(!dlm_no_directory(ls) &&
+ (r->res_master_nodeid != our_nodeid) &&
+ (dlm_dir_nodeid(r) == our_nodeid));
- dlm_lock_recovery(ls);
+ /* An active rsb should never be on the scan list. */
+ WARN_ON(!rsb_flag(r, RSB_INACTIVE));
- error = find_lkb(ls, lkid, &lkb);
- if (error)
- goto out;
+ /* An rsb should not already be on the scan list. */
+ WARN_ON(!list_empty(&r->res_scan_list));
- trace_dlm_unlock_start(ls, lkb, flags);
+ spin_lock_bh(&ls->ls_scan_lock);
+ /* set the new rsb absolute expire time in the rsb */
+ r->res_toss_time = rsb_toss_jiffies();
+ if (list_empty(&ls->ls_scan_list)) {
+ /* if the queue is empty add the element and it's
+ * our new expire time
+ */
+ list_add_tail(&r->res_scan_list, &ls->ls_scan_list);
+ enable_scan_timer(ls, r->res_toss_time);
+ } else {
+ /* try to get the maybe new first element and then add
+ * to this rsb with the oldest expire time to the end
+ * of the queue. If the list was empty before this
+ * rsb expire time is our next expiration if it wasn't
+ * the now new first elemet is our new expiration time
+ */
+ first = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ list_add_tail(&r->res_scan_list, &ls->ls_scan_list);
+ if (!first)
+ enable_scan_timer(ls, r->res_toss_time);
+ else
+ enable_scan_timer(ls, first->res_toss_time);
+ }
+ spin_unlock_bh(&ls->ls_scan_lock);
+}
- error = set_unlock_args(flags, astarg, &args);
- if (error)
- goto out_put;
+/* if we hit contention we do in 250 ms a retry to trylock.
+ * if there is any other mod_timer in between we don't care
+ * about that it expires earlier again this is only for the
+ * unlikely case nothing happened in this time.
+ */
+#define DLM_TOSS_TIMER_RETRY (jiffies + msecs_to_jiffies(250))
- if (flags & DLM_LKF_CANCEL)
- error = cancel_lock(ls, lkb, &args);
- else
- error = unlock_lock(ls, lkb, &args);
+/* Called by lockspace scan_timer to free unused rsb's. */
- if (error == -DLM_EUNLOCK || error == -DLM_ECANCEL)
- error = 0;
- if (error == -EBUSY && (flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)))
- error = 0;
- out_put:
- trace_dlm_unlock_end(ls, lkb, flags, error);
+void dlm_rsb_scan(struct timer_list *timer)
+{
+ struct dlm_ls *ls = timer_container_of(ls, timer, ls_scan_timer);
+ int our_nodeid = dlm_our_nodeid();
+ struct dlm_rsb *r;
+ int rv;
- dlm_put_lkb(lkb);
- out:
- dlm_unlock_recovery(ls);
- dlm_put_lockspace(ls);
- return error;
-}
+ while (1) {
+ /* interrupting point to leave iteration when
+ * recovery waits for timer_delete_sync(), recovery
+ * will take care to delete everything in scan list.
+ */
+ if (dlm_locking_stopped(ls))
+ break;
-/*
- * send/receive routines for remote operations and replies
- *
- * send_args
- * send_common
- * send_request receive_request
- * send_convert receive_convert
- * send_unlock receive_unlock
- * send_cancel receive_cancel
- * send_grant receive_grant
- * send_bast receive_bast
- * send_lookup receive_lookup
- * send_remove receive_remove
- *
- * send_common_reply
- * receive_request_reply send_request_reply
- * receive_convert_reply send_convert_reply
- * receive_unlock_reply send_unlock_reply
- * receive_cancel_reply send_cancel_reply
- * receive_lookup_reply send_lookup_reply
- */
+ rv = spin_trylock(&ls->ls_scan_lock);
+ if (!rv) {
+ /* rearm again try timer */
+ enable_scan_timer(ls, DLM_TOSS_TIMER_RETRY);
+ break;
+ }
-static int _create_message(struct dlm_ls *ls, int mb_len,
- int to_nodeid, int mstype,
- struct dlm_message **ms_ret,
- struct dlm_mhandle **mh_ret)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- char *mb;
+ r = list_first_entry_or_null(&ls->ls_scan_list, struct dlm_rsb,
+ res_scan_list);
+ if (!r) {
+ /* the next add_scan will enable the timer again */
+ spin_unlock(&ls->ls_scan_lock);
+ break;
+ }
- /* get_buffer gives us a message handle (mh) that we need to
- pass into midcomms_commit and a message buffer (mb) that we
- write our data into */
+ /*
+ * If the first rsb is not yet expired, then stop because the
+ * list is sorted with nearest expiration first.
+ */
+ if (time_before(jiffies, r->res_toss_time)) {
+ /* rearm with the next rsb to expire in the future */
+ enable_scan_timer(ls, r->res_toss_time);
+ spin_unlock(&ls->ls_scan_lock);
+ break;
+ }
- mh = dlm_midcomms_get_mhandle(to_nodeid, mb_len, &mb);
- if (!mh)
- return -ENOBUFS;
+ /* in find_rsb_dir/nodir there is a reverse order of this
+ * lock, however this is only a trylock if we hit some
+ * possible contention we try it again.
+ */
+ rv = write_trylock(&ls->ls_rsbtbl_lock);
+ if (!rv) {
+ spin_unlock(&ls->ls_scan_lock);
+ /* rearm again try timer */
+ enable_scan_timer(ls, DLM_TOSS_TIMER_RETRY);
+ break;
+ }
- ms = (struct dlm_message *) mb;
+ list_del(&r->res_slow_list);
+ rhashtable_remove_fast(&ls->ls_rsbtbl, &r->res_node,
+ dlm_rhash_rsb_params);
+ rsb_clear_flag(r, RSB_HASHED);
- ms->m_header.h_version = cpu_to_le32(DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
- ms->m_header.u.h_lockspace = cpu_to_le32(ls->ls_global_id);
- ms->m_header.h_nodeid = cpu_to_le32(dlm_our_nodeid());
- ms->m_header.h_length = cpu_to_le16(mb_len);
- ms->m_header.h_cmd = DLM_MSG;
+ /* ls_rsbtbl_lock is not needed when calling send_remove() */
+ write_unlock(&ls->ls_rsbtbl_lock);
- ms->m_type = cpu_to_le32(mstype);
+ list_del_init(&r->res_scan_list);
+ spin_unlock(&ls->ls_scan_lock);
- *mh_ret = mh;
- *ms_ret = ms;
- return 0;
-}
+ /* An rsb that is a dir record for a remote master rsb
+ * cannot be removed, and should not have a timer enabled.
+ */
+ WARN_ON(!dlm_no_directory(ls) &&
+ (r->res_master_nodeid != our_nodeid) &&
+ (dlm_dir_nodeid(r) == our_nodeid));
-static int create_message(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int to_nodeid, int mstype,
- struct dlm_message **ms_ret,
- struct dlm_mhandle **mh_ret)
-{
- int mb_len = sizeof(struct dlm_message);
+ /* We're the master of this rsb but we're not
+ * the directory record, so we need to tell the
+ * dir node to remove the dir record
+ */
+ if (!dlm_no_directory(ls) &&
+ (r->res_master_nodeid == our_nodeid) &&
+ (dlm_dir_nodeid(r) != our_nodeid))
+ send_remove(r);
- switch (mstype) {
- case DLM_MSG_REQUEST:
- case DLM_MSG_LOOKUP:
- case DLM_MSG_REMOVE:
- mb_len += r->res_length;
- break;
- case DLM_MSG_CONVERT:
- case DLM_MSG_UNLOCK:
- case DLM_MSG_REQUEST_REPLY:
- case DLM_MSG_CONVERT_REPLY:
- case DLM_MSG_GRANT:
- if (lkb && lkb->lkb_lvbptr && (lkb->lkb_exflags & DLM_LKF_VALBLK))
- mb_len += r->res_ls->ls_lvblen;
- break;
+ free_inactive_rsb(r);
}
-
- return _create_message(r->res_ls, mb_len, to_nodeid, mstype,
- ms_ret, mh_ret);
-}
-
-/* further lowcomms enhancements or alternate implementations may make
- the return value from this function useful at some point */
-
-static int send_message(struct dlm_mhandle *mh, struct dlm_message *ms,
- const void *name, int namelen)
-{
- dlm_midcomms_commit_mhandle(mh, name, namelen);
- return 0;
}
-static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
- struct dlm_message *ms)
-{
- ms->m_nodeid = cpu_to_le32(lkb->lkb_nodeid);
- ms->m_pid = cpu_to_le32(lkb->lkb_ownpid);
- ms->m_lkid = cpu_to_le32(lkb->lkb_id);
- ms->m_remid = cpu_to_le32(lkb->lkb_remid);
- ms->m_exflags = cpu_to_le32(lkb->lkb_exflags);
- ms->m_sbflags = cpu_to_le32(dlm_sbflags_val(lkb));
- ms->m_flags = cpu_to_le32(dlm_dflags_val(lkb));
- ms->m_lvbseq = cpu_to_le32(lkb->lkb_lvbseq);
- ms->m_status = cpu_to_le32(lkb->lkb_status);
- ms->m_grmode = cpu_to_le32(lkb->lkb_grmode);
- ms->m_rqmode = cpu_to_le32(lkb->lkb_rqmode);
- ms->m_hash = cpu_to_le32(r->res_hash);
-
- /* m_result and m_bastmode are set from function args,
- not from lkb fields */
-
- if (lkb->lkb_bastfn)
- ms->m_asts |= cpu_to_le32(DLM_CB_BAST);
- if (lkb->lkb_astfn)
- ms->m_asts |= cpu_to_le32(DLM_CB_CAST);
-
- /* compare with switch in create_message; send_remove() doesn't
- use send_args() */
-
- switch (ms->m_type) {
- case cpu_to_le32(DLM_MSG_REQUEST):
- case cpu_to_le32(DLM_MSG_LOOKUP):
- memcpy(ms->m_extra, r->res_name, r->res_length);
- break;
- case cpu_to_le32(DLM_MSG_CONVERT):
- case cpu_to_le32(DLM_MSG_UNLOCK):
- case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
- case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
- case cpu_to_le32(DLM_MSG_GRANT):
- if (!lkb->lkb_lvbptr || !(lkb->lkb_exflags & DLM_LKF_VALBLK))
- break;
- memcpy(ms->m_extra, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
- break;
- }
-}
+/* If ls->ls_new_rsb is empty, return -EAGAIN, so the caller can
+ unlock any spinlocks, go back and call pre_rsb_struct again.
+ Otherwise, take an rsb off the list and return it. */
-static int send_common(struct dlm_rsb *r, struct dlm_lkb *lkb, int mstype)
+static int get_rsb_struct(struct dlm_ls *ls, const void *name, int len,
+ struct dlm_rsb **r_ret)
{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
+ struct dlm_rsb *r;
- to_nodeid = r->res_nodeid;
+ r = dlm_allocate_rsb();
+ if (!r)
+ return -ENOMEM;
- add_to_waiters(lkb, mstype, to_nodeid);
- error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
- if (error)
- goto fail;
+ r->res_ls = ls;
+ r->res_length = len;
+ memcpy(r->res_name, name, len);
+ spin_lock_init(&r->res_lock);
- send_args(r, lkb, ms);
+ INIT_LIST_HEAD(&r->res_lookup);
+ INIT_LIST_HEAD(&r->res_grantqueue);
+ INIT_LIST_HEAD(&r->res_convertqueue);
+ INIT_LIST_HEAD(&r->res_waitqueue);
+ INIT_LIST_HEAD(&r->res_root_list);
+ INIT_LIST_HEAD(&r->res_scan_list);
+ INIT_LIST_HEAD(&r->res_recover_list);
+ INIT_LIST_HEAD(&r->res_masters_list);
- error = send_message(mh, ms, r->res_name, r->res_length);
- if (error)
- goto fail;
+ *r_ret = r;
return 0;
-
- fail:
- remove_from_waiters(lkb, msg_reply_type(mstype));
- return error;
}
-static int send_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
+int dlm_search_rsb_tree(struct rhashtable *rhash, const void *name, int len,
+ struct dlm_rsb **r_ret)
{
- return send_common(r, lkb, DLM_MSG_REQUEST);
+ char key[DLM_RESNAME_MAXLEN] = {};
+
+ memcpy(key, name, len);
+ *r_ret = rhashtable_lookup_fast(rhash, &key, dlm_rhash_rsb_params);
+ if (*r_ret)
+ return 0;
+
+ return -EBADR;
}
-static int send_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static int rsb_insert(struct dlm_rsb *rsb, struct rhashtable *rhash)
{
- int error;
-
- error = send_common(r, lkb, DLM_MSG_CONVERT);
+ int rv;
- /* down conversions go without a reply from the master */
- if (!error && down_conversion(lkb)) {
- remove_from_waiters(lkb, DLM_MSG_CONVERT_REPLY);
- r->res_ls->ls_local_ms.m_type = cpu_to_le32(DLM_MSG_CONVERT_REPLY);
- r->res_ls->ls_local_ms.m_result = 0;
- __receive_convert_reply(r, lkb, &r->res_ls->ls_local_ms, true);
- }
+ rv = rhashtable_insert_fast(rhash, &rsb->res_node,
+ dlm_rhash_rsb_params);
+ if (!rv)
+ rsb_set_flag(rsb, RSB_HASHED);
- return error;
+ return rv;
}
-/* FIXME: if this lkb is the only lock we hold on the rsb, then set
- MASTER_UNCERTAIN to force the next request on the rsb to confirm
- that the master is still correct. */
+/*
+ * Find rsb in rsbtbl and potentially create/add one
+ *
+ * Delaying the release of rsb's has a similar benefit to applications keeping
+ * NL locks on an rsb, but without the guarantee that the cached master value
+ * will still be valid when the rsb is reused. Apps aren't always smart enough
+ * to keep NL locks on an rsb that they may lock again shortly; this can lead
+ * to excessive master lookups and removals if we don't delay the release.
+ *
+ * Searching for an rsb means looking through both the normal list and toss
+ * list. When found on the toss list the rsb is moved to the normal list with
+ * ref count of 1; when found on normal list the ref count is incremented.
+ *
+ * rsb's on the keep list are being used locally and refcounted.
+ * rsb's on the toss list are not being used locally, and are not refcounted.
+ *
+ * The toss list rsb's were either
+ * - previously used locally but not any more (were on keep list, then
+ * moved to toss list when last refcount dropped)
+ * - created and put on toss list as a directory record for a lookup
+ * (we are the dir node for the res, but are not using the res right now,
+ * but some other node is)
+ *
+ * The purpose of find_rsb() is to return a refcounted rsb for local use.
+ * So, if the given rsb is on the toss list, it is moved to the keep list
+ * before being returned.
+ *
+ * deactivate_rsb() happens when all local usage of the rsb is done, i.e. no
+ * more refcounts exist, so the rsb is moved from the keep list to the
+ * toss list.
+ *
+ * rsb's on both keep and toss lists are used for doing a name to master
+ * lookups. rsb's that are in use locally (and being refcounted) are on
+ * the keep list, rsb's that are not in use locally (not refcounted) and
+ * only exist for name/master lookups are on the toss list.
+ *
+ * rsb's on the toss list who's dir_nodeid is not local can have stale
+ * name/master mappings. So, remote requests on such rsb's can potentially
+ * return with an error, which means the mapping is stale and needs to
+ * be updated with a new lookup. (The idea behind MASTER UNCERTAIN and
+ * first_lkid is to keep only a single outstanding request on an rsb
+ * while that rsb has a potentially stale master.)
+ */
-static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+static int find_rsb_dir(struct dlm_ls *ls, const void *name, int len,
+ uint32_t hash, int dir_nodeid, int from_nodeid,
+ unsigned int flags, struct dlm_rsb **r_ret)
{
- return send_common(r, lkb, DLM_MSG_UNLOCK);
-}
+ struct dlm_rsb *r = NULL;
+ int our_nodeid = dlm_our_nodeid();
+ int from_local = 0;
+ int from_other = 0;
+ int from_dir = 0;
+ int create = 0;
+ int error;
-static int send_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- return send_common(r, lkb, DLM_MSG_CANCEL);
-}
+ if (flags & R_RECEIVE_REQUEST) {
+ if (from_nodeid == dir_nodeid)
+ from_dir = 1;
+ else
+ from_other = 1;
+ } else if (flags & R_REQUEST) {
+ from_local = 1;
+ }
-static int send_grant(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
+ /*
+ * flags & R_RECEIVE_RECOVER is from dlm_recover_master_copy, so
+ * from_nodeid has sent us a lock in dlm_recover_locks, believing
+ * we're the new master. Our local recovery may not have set
+ * res_master_nodeid to our_nodeid yet, so allow either. Don't
+ * create the rsb; dlm_recover_process_copy() will handle EBADR
+ * by resending.
+ *
+ * If someone sends us a request, we are the dir node, and we do
+ * not find the rsb anywhere, then recreate it. This happens if
+ * someone sends us a request after we have removed/freed an rsb.
+ * (They sent a request instead of lookup because they are using
+ * an rsb taken from their scan list.)
+ */
- to_nodeid = lkb->lkb_nodeid;
+ if (from_local || from_dir ||
+ (from_other && (dir_nodeid == our_nodeid))) {
+ create = 1;
+ }
- error = create_message(r, lkb, to_nodeid, DLM_MSG_GRANT, &ms, &mh);
+ retry:
+ error = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
if (error)
- goto out;
-
- send_args(r, lkb, ms);
-
- ms->m_result = 0;
+ goto do_new;
- error = send_message(mh, ms, r->res_name, r->res_length);
- out:
- return error;
-}
+ /* check if the rsb is active under read lock - likely path */
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ if (!rsb_flag(r, RSB_HASHED)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -EBADR;
+ goto do_new;
+ }
-static int send_bast(struct dlm_rsb *r, struct dlm_lkb *lkb, int mode)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
+ /*
+ * rsb is active, so we can't check master_nodeid without lock_rsb.
+ */
- to_nodeid = lkb->lkb_nodeid;
+ if (rsb_flag(r, RSB_INACTIVE)) {
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto do_inactive;
+ }
- error = create_message(r, NULL, to_nodeid, DLM_MSG_BAST, &ms, &mh);
- if (error)
- goto out;
+ kref_get(&r->res_ref);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto out;
- send_args(r, lkb, ms);
- ms->m_bastmode = cpu_to_le32(mode);
+ do_inactive:
+ write_lock_bh(&ls->ls_rsbtbl_lock);
- error = send_message(mh, ms, r->res_name, r->res_length);
- out:
- return error;
-}
+ /*
+ * The expectation here is that the rsb will have HASHED and
+ * INACTIVE flags set, and that the rsb can be moved from
+ * inactive back to active again. However, between releasing
+ * the read lock and acquiring the write lock, this rsb could
+ * have been removed from rsbtbl, and had HASHED cleared, to
+ * be freed. To deal with this case, we would normally need
+ * to repeat dlm_search_rsb_tree while holding the write lock,
+ * but rcu allows us to simply check the HASHED flag, because
+ * the rcu read lock means the rsb will not be freed yet.
+ * If the HASHED flag is not set, then the rsb is being freed,
+ * so we add a new rsb struct. If the HASHED flag is set,
+ * and INACTIVE is not set, it means another thread has
+ * made the rsb active, as we're expecting to do here, and
+ * we just repeat the lookup (this will be very unlikely.)
+ */
+ if (rsb_flag(r, RSB_HASHED)) {
+ if (!rsb_flag(r, RSB_INACTIVE)) {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ goto retry;
+ }
+ } else {
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -EBADR;
+ goto do_new;
+ }
-static int send_lookup(struct dlm_rsb *r, struct dlm_lkb *lkb)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
+ /*
+ * rsb found inactive (master_nodeid may be out of date unless
+ * we are the dir_nodeid or were the master) No other thread
+ * is using this rsb because it's inactive, so we can
+ * look at or update res_master_nodeid without lock_rsb.
+ */
- to_nodeid = dlm_dir_nodeid(r);
+ if ((r->res_master_nodeid != our_nodeid) && from_other) {
+ /* our rsb was not master, and another node (not the dir node)
+ has sent us a request */
+ log_debug(ls, "find_rsb inactive from_other %d master %d dir %d %s",
+ from_nodeid, r->res_master_nodeid, dir_nodeid,
+ r->res_name);
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ error = -ENOTBLK;
+ goto out;
+ }
- add_to_waiters(lkb, DLM_MSG_LOOKUP, to_nodeid);
- error = create_message(r, NULL, to_nodeid, DLM_MSG_LOOKUP, &ms, &mh);
- if (error)
- goto fail;
+ if ((r->res_master_nodeid != our_nodeid) && from_dir) {
+ /* don't think this should ever happen */
+ log_error(ls, "find_rsb inactive from_dir %d master %d",
+ from_nodeid, r->res_master_nodeid);
+ dlm_print_rsb(r);
+ /* fix it and go on */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
+ r->res_first_lkid = 0;
+ }
- send_args(r, lkb, ms);
+ if (from_local && (r->res_master_nodeid != our_nodeid)) {
+ /* Because we have held no locks on this rsb,
+ res_master_nodeid could have become stale. */
+ rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
+ r->res_first_lkid = 0;
+ }
- error = send_message(mh, ms, r->res_name, r->res_length);
- if (error)
- goto fail;
- return 0;
+ /* we always deactivate scan timer for the rsb, when
+ * we move it out of the inactive state as rsb state
+ * can be changed and scan timers are only for inactive
+ * rsbs.
+ */
+ del_scan(ls, r);
+ list_move(&r->res_slow_list, &ls->ls_slow_active);
+ rsb_clear_flag(r, RSB_INACTIVE);
+ kref_init(&r->res_ref); /* ref is now used in active state */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
- fail:
- remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
- return error;
-}
+ goto out;
-static int send_remove(struct dlm_rsb *r)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
- to_nodeid = dlm_dir_nodeid(r);
+ do_new:
+ /*
+ * rsb not found
+ */
- error = create_message(r, NULL, to_nodeid, DLM_MSG_REMOVE, &ms, &mh);
- if (error)
+ if (error == -EBADR && !create)
goto out;
- memcpy(ms->m_extra, r->res_name, r->res_length);
- ms->m_hash = cpu_to_le32(r->res_hash);
-
- error = send_message(mh, ms, r->res_name, r->res_length);
- out:
- return error;
-}
-
-static int send_common_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
- int mstype, int rv)
-{
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int to_nodeid, error;
-
- to_nodeid = lkb->lkb_nodeid;
-
- error = create_message(r, lkb, to_nodeid, mstype, &ms, &mh);
- if (error)
+ error = get_rsb_struct(ls, name, len, &r);
+ if (WARN_ON_ONCE(error))
goto out;
- send_args(r, lkb, ms);
-
- ms->m_result = cpu_to_le32(to_dlm_errno(rv));
-
- error = send_message(mh, ms, r->res_name, r->res_length);
- out:
- return error;
-}
-
-static int send_request_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
-{
- return send_common_reply(r, lkb, DLM_MSG_REQUEST_REPLY, rv);
-}
-
-static int send_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
-{
- return send_common_reply(r, lkb, DLM_MSG_CONVERT_REPLY, rv);
-}
+ r->res_hash = hash;
+ r->res_dir_nodeid = dir_nodeid;
+ kref_init(&r->res_ref);
-static int send_unlock_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
-{
- return send_common_reply(r, lkb, DLM_MSG_UNLOCK_REPLY, rv);
-}
+ if (from_dir) {
+ /* want to see how often this happens */
+ log_debug(ls, "find_rsb new from_dir %d recreate %s",
+ from_nodeid, r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ goto out_add;
+ }
-static int send_cancel_reply(struct dlm_rsb *r, struct dlm_lkb *lkb, int rv)
-{
- return send_common_reply(r, lkb, DLM_MSG_CANCEL_REPLY, rv);
-}
+ if (from_other && (dir_nodeid != our_nodeid)) {
+ /* should never happen */
+ log_error(ls, "find_rsb new from_other %d dir %d our %d %s",
+ from_nodeid, dir_nodeid, our_nodeid, r->res_name);
+ dlm_free_rsb(r);
+ r = NULL;
+ error = -ENOTBLK;
+ goto out;
+ }
-static int send_lookup_reply(struct dlm_ls *ls,
- const struct dlm_message *ms_in, int ret_nodeid,
- int rv)
-{
- struct dlm_rsb *r = &ls->ls_local_rsb;
- struct dlm_message *ms;
- struct dlm_mhandle *mh;
- int error, nodeid = le32_to_cpu(ms_in->m_header.h_nodeid);
+ if (from_other) {
+ log_debug(ls, "find_rsb new from_other %d dir %d %s",
+ from_nodeid, dir_nodeid, r->res_name);
+ }
- error = create_message(r, NULL, nodeid, DLM_MSG_LOOKUP_REPLY, &ms, &mh);
- if (error)
- goto out;
+ if (dir_nodeid == our_nodeid) {
+ /* When we are the dir nodeid, we can set the master
+ node immediately */
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ } else {
+ /* set_master will send_lookup to dir_nodeid */
+ r->res_master_nodeid = 0;
+ r->res_nodeid = -1;
+ }
- ms->m_lkid = ms_in->m_lkid;
- ms->m_result = cpu_to_le32(to_dlm_errno(rv));
- ms->m_nodeid = cpu_to_le32(ret_nodeid);
+ out_add:
- error = send_message(mh, ms, ms_in->m_extra, receive_extralen(ms_in));
+ write_lock_bh(&ls->ls_rsbtbl_lock);
+ error = rsb_insert(r, &ls->ls_rsbtbl);
+ if (error == -EEXIST) {
+ /* somebody else was faster and it seems the
+ * rsb exists now, we do a whole relookup
+ */
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
+ dlm_free_rsb(r);
+ goto retry;
+ } else if (!error) {
+ list_add(&r->res_slow_list, &ls->ls_slow_active);
+ }
+ write_unlock_bh(&ls->ls_rsbtbl_lock);
out:
+ *r_ret = r;
return error;
}
-/* which args we save from a received message depends heavily on the type
- of message, unlike the send side where we can safely send everything about
- the lkb for any type of message */
-
-static void receive_flags(struct dlm_lkb *lkb, const struct dlm_message *ms)
-{
- lkb->lkb_exflags = le32_to_cpu(ms->m_exflags);
- dlm_set_sbflags_val(lkb, le32_to_cpu(ms->m_sbflags));
- dlm_set_dflags_val(lkb, le32_to_cpu(ms->m_flags));
-}
+/* FIXME: if this lkb is the only lock we hold on the rsb, then set
+ MASTER_UNCERTAIN to force the next request on the rsb to confirm
+ that the master is still correct. */
-static void receive_flags_reply(struct dlm_lkb *lkb,
- const struct dlm_message *ms,
- bool local)
+static int send_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- if (local)
- return;
-
- dlm_set_sbflags_val(lkb, le32_to_cpu(ms->m_sbflags));
- dlm_set_dflags_val(lkb, le32_to_cpu(ms->m_flags));
-}
+ int rv;
+ bool only = true;
+ struct dlm_lkb *iter;
+
+ /* Caller should hold lock_rsb(r) when invoking send_unlock(); it's
+ * therefore safe to inspect the rsb queues without additional locking.
+ * If this lkb is the only locally-held lock on the rsb, mark the
+ * master as uncertain so a subsequent request will reconfirm the
+ * master via lookup.
+ */
-static int receive_extralen(const struct dlm_message *ms)
-{
- return (le16_to_cpu(ms->m_header.h_length) -
- sizeof(struct dlm_message));
-}
+ /* Check grant queue for any other lkbs */
+ list_for_each_entry(iter, &r->res_grantqueue, lkb_statequeue) {
+ if (iter != lkb) {
+ only = false;
+ break;
+ }
+ }
-static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
-{
- int len;
+ /* Check convert queue if still only */
+ if (only) {
+ list_for_each_entry(iter, &r->res_convertqueue, lkb_statequeue) {
+ if (iter != lkb) {
+ only = false;
+ break;
+ }
+ }
+ }
- if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
- if (!lkb->lkb_lvbptr)
- lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
- if (!lkb->lkb_lvbptr)
- return -ENOMEM;
- len = receive_extralen(ms);
- if (len > ls->ls_lvblen)
- len = ls->ls_lvblen;
- memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
+ /* Check wait queue if still only */
+ if (only) {
+ list_for_each_entry(iter, &r->res_waitqueue, lkb_statequeue) {
+ if (iter != lkb) {
+ only = false;
+ break;
+ }
+ }
}
- return 0;
-}
-static void fake_bastfn(void *astparam, int mode)
-{
- log_print("fake_bastfn should not be called");
-}
+ if (only)
+ rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
-static void fake_astfn(void *astparam)
-{
- log_print("fake_astfn should not be called");
+ rv = send_common(r, lkb, DLM_MSG_UNLOCK);
+ return rv;
}
-static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
-{
- lkb->lkb_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
- lkb->lkb_ownpid = le32_to_cpu(ms->m_pid);
- lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
- lkb->lkb_grmode = DLM_LOCK_IV;
- lkb->lkb_rqmode = le32_to_cpu(ms->m_rqmode);
-
- lkb->lkb_bastfn = (ms->m_asts & cpu_to_le32(DLM_CB_BAST)) ? &fake_bastfn : NULL;
- lkb->lkb_astfn = (ms->m_asts & cpu_to_le32(DLM_CB_CAST)) ? &fake_astfn : NULL;
-
- if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
- /* lkb was just created so there won't be an lvb yet */
- lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
- if (!lkb->lkb_lvbptr)
- return -ENOMEM;
- }
-
- return 0;
-}
+/* add/remove lkb to rsb's grant/convert/wait queue */
-static int receive_convert_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
+static void add_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int status)
{
- if (lkb->lkb_status != DLM_LKSTS_GRANTED)
- return -EBUSY;
+ kref_get(&lkb->lkb_ref);
- if (receive_lvb(ls, lkb, ms))
- return -ENOMEM;
+ DLM_ASSERT(!lkb->lkb_status, dlm_print_lkb(lkb););
- lkb->lkb_rqmode = le32_to_cpu(ms->m_rqmode);
- lkb->lkb_lvbseq = le32_to_cpu(ms->m_lvbseq);
+ lkb->lkb_timestamp = ktime_get();
- return 0;
+ lkb->lkb_status = status;
+
+ switch (status) {
+ case DLM_LKSTS_WAITING:
+ if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
+ list_add(&lkb->lkb_statequeue, &r->res_waitqueue);
+ else
+ list_add_tail(&lkb->lkb_statequeue, &r->res_waitqueue);
+ break;
+ case DLM_LKSTS_GRANTED:
+ /* convention says granted locks kept in order of grmode */
+ lkb_add_ordered(&lkb->lkb_statequeue, &r->res_grantqueue,
+ lkb->lkb_grmode);
+ break;
+ case DLM_LKSTS_CONVERT:
+ if (lkb->lkb_exflags & DLM_LKF_HEADQUE)
+ list_add(&lkb->lkb_statequeue, &r->res_convertqueue);
+ else
+ list_add_tail(&lkb->lkb_statequeue,
+ &r->res_convertqueue);
+ break;
+ default:
+ DLM_ASSERT(0, dlm_print_lkb(lkb); printk("sts=%d\n", status););
+ }
}
-static int receive_unlock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
- const struct dlm_message *ms)
+static void del_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- if (receive_lvb(ls, lkb, ms))
- return -ENOMEM;
- return 0;
+ lkb->lkb_status = 0;
+ list_del(&lkb->lkb_statequeue);
+ unhold_lkb(lkb);
}
-/* We fill in the local-lkb fields with the info that send_xxxx_reply()
- uses to send a reply and that the remote end uses to process the reply. */
-
-static void setup_local_lkb(struct dlm_ls *ls, const struct dlm_message *ms)
+static void move_lkb(struct dlm_rsb *r, struct dlm_lkb *lkb, int sts)
{
- struct dlm_lkb *lkb = &ls->ls_local_lkb;
- lkb->lkb_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
- lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
+ del_lkb(r, lkb);
+ add_lkb(r, lkb, sts);
}
-/* This is called after the rsb is locked so that we can safely inspect
- fields in the lkb. */
-
-static int validate_message(struct dlm_lkb *lkb, const struct dlm_message *ms)
+static int msg_reply_type(int mstype)
{
- int from = le32_to_cpu(ms->m_header.h_nodeid);
- int error = 0;
-
- /* currently mixing of user/kernel locks are not supported */
- if (ms->m_flags & cpu_to_le32(BIT(DLM_DFL_USER_BIT)) &&
- !test_bit(DLM_DFL_USER_BIT, &lkb->lkb_dflags)) {
- log_error(lkb->lkb_resource->res_ls,
- "got user dlm message for a kernel lock");
- error = -EINVAL;
- goto out;
- }
-
- switch (ms->m_type) {
- case cpu_to_le32(DLM_MSG_CONVERT):
- case cpu_to_le32(DLM_MSG_UNLOCK):
- case cpu_to_le32(DLM_MSG_CANCEL):
- if (!is_master_copy(lkb) || lkb->lkb_nodeid != from)
- error = -EINVAL;
- break;
-
- case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
- case cpu_to_le32(DLM_MSG_UNLOCK_REPLY):
- case cpu_to_le32(DLM_MSG_CANCEL_REPLY):
- case cpu_to_le32(DLM_MSG_GRANT):
- case cpu_to_le32(DLM_MSG_BAST):
- if (!is_process_copy(lkb) || lkb->lkb_nodeid != from)
- error = -EINVAL;
- break;
-
- case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
- if (!is_process_copy(lkb))
- error = -EINVAL;
- else if (lkb->lkb_nodeid != -1 && lkb->lkb_nodeid != from)
- error = -EINVAL;
- break;
-
- default:
- error = -EINVAL;
+ switch (mstype) {
+ case DLM_MSG_REQUEST:
+ return DLM_MSG_REQUEST_REPLY;
+ case DLM_MSG_CONVERT:
+ return DLM_MSG_CONVERT_REPLY;
+ case DLM_MSG_UNLOCK:
+ return DLM_MSG_UNLOCK_REPLY;
+ case DLM_MSG_CANCEL:
+ return DLM_MSG_CANCEL_REPLY;
+ case DLM_MSG_LOOKUP:
+ return DLM_MSG_LOOKUP_REPLY;
}
-
-out:
- if (error)
- log_error(lkb->lkb_resource->res_ls,
- "ignore invalid message %d from %d %x %x %x %d",
- le32_to_cpu(ms->m_type), from, lkb->lkb_id,
- lkb->lkb_remid, dlm_iflags_val(lkb),
- lkb->lkb_nodeid);
- return error;
+ return -1;
}
-static int receive_request(struct dlm_ls *ls, const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int from_nodeid;
- int error, namelen = 0;
+/* add/remove lkb from global waiters list of lkb's waiting for
+ a reply from a remote node */
- from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
+static void add_to_waiters(struct dlm_lkb *lkb, int mstype, int to_nodeid)
+{
+ struct dlm_ls *ls = lkb->lkb_resource->res_ls;
- error = create_lkb(ls, &lkb);
- if (error)
- goto fail;
+ spin_lock_bh(&ls->ls_waiters_lock);
+ if (lkb->lkb_wait_type || is_overlap_cancel(lkb)) {
+ switch (mstype) {
+ case DLM_MSG_UNLOCK:
+ set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
+ break;
+ case DLM_MSG_CANCEL:
+ set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
+ break;
+ default:
+ /* should never happen as validate_lock_args() checks
+ * on lkb_wait_type and validate_unlock_args() only
+ * creates UNLOCK or CANCEL messages.
+ */
+ WARN_ON_ONCE(1);
+ goto out;
+ }
+ lkb->lkb_wait_count++;
+ hold_lkb(lkb);
- receive_flags(lkb, ms);
- set_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
- error = receive_request_args(ls, lkb, ms);
- if (error) {
- __put_lkb(ls, lkb);
- goto fail;
+ log_debug(ls, "addwait %x cur %d overlap %d count %d f %x",
+ lkb->lkb_id, lkb->lkb_wait_type, mstype,
+ lkb->lkb_wait_count, dlm_iflags_val(lkb));
+ goto out;
}
- /* The dir node is the authority on whether we are the master
- for this rsb or not, so if the master sends us a request, we should
- recreate the rsb if we've destroyed it. This race happens when we
- send a remove message to the dir node at the same time that the dir
- node sends us a request for the rsb. */
+ DLM_ASSERT(!lkb->lkb_wait_count,
+ dlm_print_lkb(lkb);
+ printk("wait_count %d\n", lkb->lkb_wait_count););
- namelen = receive_extralen(ms);
+ lkb->lkb_wait_count++;
+ lkb->lkb_wait_type = mstype;
+ lkb->lkb_wait_nodeid = to_nodeid; /* for debugging */
+ hold_lkb(lkb);
+ list_add(&lkb->lkb_wait_reply, &ls->ls_waiters);
+ out:
+ spin_unlock_bh(&ls->ls_waiters_lock);
+}
- error = find_rsb(ls, ms->m_extra, namelen, from_nodeid,
- R_RECEIVE_REQUEST, &r);
- if (error) {
- __put_lkb(ls, lkb);
- goto fail;
- }
+/* We clear the RESEND flag because we might be taking an lkb off the waiters
+ list as part of process_requestqueue (e.g. a lookup that has an optimized
+ request reply on the requestqueue) between dlm_recover_waiters_pre() which
+ set RESEND and dlm_recover_waiters_post() */
- lock_rsb(r);
+static int _remove_from_waiters(struct dlm_lkb *lkb, int mstype,
+ const struct dlm_message *ms)
+{
+ struct dlm_ls *ls = lkb->lkb_resource->res_ls;
+ int overlap_done = 0;
- if (r->res_master_nodeid != dlm_our_nodeid()) {
- error = validate_master_nodeid(ls, r, from_nodeid);
- if (error) {
- unlock_rsb(r);
- put_rsb(r);
- __put_lkb(ls, lkb);
- goto fail;
- }
+ if (mstype == DLM_MSG_UNLOCK_REPLY &&
+ test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags)) {
+ log_debug(ls, "remwait %x unlock_reply overlap", lkb->lkb_id);
+ overlap_done = 1;
+ goto out_del;
}
- attach_lkb(r, lkb);
- error = do_request(r, lkb);
- send_request_reply(r, lkb, error);
- do_request_effects(r, lkb, error);
-
- unlock_rsb(r);
- put_rsb(r);
-
- if (error == -EINPROGRESS)
- error = 0;
- if (error)
- dlm_put_lkb(lkb);
- return 0;
+ if (mstype == DLM_MSG_CANCEL_REPLY &&
+ test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
+ log_debug(ls, "remwait %x cancel_reply overlap", lkb->lkb_id);
+ overlap_done = 1;
+ goto out_del;
+ }
- fail:
- /* TODO: instead of returning ENOTBLK, add the lkb to res_lookup
- and do this receive_request again from process_lookup_list once
- we get the lookup reply. This would avoid a many repeated
- ENOTBLK request failures when the lookup reply designating us
- as master is delayed. */
+ /* Cancel state was preemptively cleared by a successful convert,
+ see next comment, nothing to do. */
- if (error != -ENOTBLK) {
- log_limit(ls, "receive_request %x from %d %d",
- le32_to_cpu(ms->m_lkid), from_nodeid, error);
+ if ((mstype == DLM_MSG_CANCEL_REPLY) &&
+ (lkb->lkb_wait_type != DLM_MSG_CANCEL)) {
+ log_debug(ls, "remwait %x cancel_reply wait_type %d",
+ lkb->lkb_id, lkb->lkb_wait_type);
+ return -1;
}
- setup_local_lkb(ls, ms);
- send_request_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
- return error;
-}
-
-static int receive_convert(struct dlm_ls *ls, const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error, reply = 1;
+ /* Remove for the convert reply, and premptively remove for the
+ cancel reply. A convert has been granted while there's still
+ an outstanding cancel on it (the cancel is moot and the result
+ in the cancel reply should be 0). We preempt the cancel reply
+ because the app gets the convert result and then can follow up
+ with another op, like convert. This subsequent op would see the
+ lingering state of the cancel and fail with -EBUSY. */
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- goto fail;
-
- if (lkb->lkb_remid != le32_to_cpu(ms->m_lkid)) {
- log_error(ls, "receive_convert %x remid %x recover_seq %llu "
- "remote %d %x", lkb->lkb_id, lkb->lkb_remid,
- (unsigned long long)lkb->lkb_recover_seq,
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid));
- error = -ENOENT;
- dlm_put_lkb(lkb);
- goto fail;
+ if ((mstype == DLM_MSG_CONVERT_REPLY) &&
+ (lkb->lkb_wait_type == DLM_MSG_CONVERT) && ms && !ms->m_result &&
+ test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags)) {
+ log_debug(ls, "remwait %x convert_reply zap overlap_cancel",
+ lkb->lkb_id);
+ lkb->lkb_wait_type = 0;
+ lkb->lkb_wait_count--;
+ unhold_lkb(lkb);
+ goto out_del;
}
- r = lkb->lkb_resource;
+ /* N.B. type of reply may not always correspond to type of original
+ msg due to lookup->request optimization, verify others? */
- hold_rsb(r);
- lock_rsb(r);
+ if (lkb->lkb_wait_type) {
+ lkb->lkb_wait_type = 0;
+ goto out_del;
+ }
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ log_error(ls, "remwait error %x remote %d %x msg %d flags %x no wait",
+ lkb->lkb_id, ms ? le32_to_cpu(ms->m_header.h_nodeid) : 0,
+ lkb->lkb_remid, mstype, dlm_iflags_val(lkb));
+ return -1;
- receive_flags(lkb, ms);
+ out_del:
+ /* the force-unlock/cancel has completed and we haven't received a reply
+ to the op that was in progress prior to the unlock/cancel; we
+ give up on any reply to the earlier op.
+ NOTE: not sure when/how this would happen */
- error = receive_convert_args(ls, lkb, ms);
- if (error) {
- send_convert_reply(r, lkb, error);
- goto out;
+ if (overlap_done && lkb->lkb_wait_type) {
+ log_error(ls, "remwait error %x reply %d wait_type %d overlap",
+ lkb->lkb_id, mstype, lkb->lkb_wait_type);
+ lkb->lkb_wait_count--;
+ unhold_lkb(lkb);
+ lkb->lkb_wait_type = 0;
}
- reply = !down_conversion(lkb);
+ DLM_ASSERT(lkb->lkb_wait_count, dlm_print_lkb(lkb););
- error = do_convert(r, lkb);
- if (reply)
- send_convert_reply(r, lkb, error);
- do_convert_effects(r, lkb, error);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
+ clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
+ lkb->lkb_wait_count--;
+ if (!lkb->lkb_wait_count)
+ list_del_init(&lkb->lkb_wait_reply);
+ unhold_lkb(lkb);
return 0;
+}
+
+static int remove_from_waiters(struct dlm_lkb *lkb, int mstype)
+{
+ struct dlm_ls *ls = lkb->lkb_resource->res_ls;
+ int error;
- fail:
- setup_local_lkb(ls, ms);
- send_convert_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
+ spin_lock_bh(&ls->ls_waiters_lock);
+ error = _remove_from_waiters(lkb, mstype, NULL);
+ spin_unlock_bh(&ls->ls_waiters_lock);
return error;
}
-static int receive_unlock(struct dlm_ls *ls, const struct dlm_message *ms)
+/* Handles situations where we might be processing a "fake" or "local" reply in
+ * the recovery context which stops any locking activity. Only debugfs might
+ * change the lockspace waiters but they will held the recovery lock to ensure
+ * remove_from_waiters_ms() in local case will be the only user manipulating the
+ * lockspace waiters in recovery context.
+ */
+
+static int remove_from_waiters_ms(struct dlm_lkb *lkb,
+ const struct dlm_message *ms, bool local)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
+ struct dlm_ls *ls = lkb->lkb_resource->res_ls;
int error;
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- goto fail;
-
- if (lkb->lkb_remid != le32_to_cpu(ms->m_lkid)) {
- log_error(ls, "receive_unlock %x remid %x remote %d %x",
- lkb->lkb_id, lkb->lkb_remid,
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid));
- error = -ENOENT;
- dlm_put_lkb(lkb);
- goto fail;
- }
+ if (!local)
+ spin_lock_bh(&ls->ls_waiters_lock);
+ else
+ WARN_ON_ONCE(!rwsem_is_locked(&ls->ls_in_recovery) ||
+ !dlm_locking_stopped(ls));
+ error = _remove_from_waiters(lkb, le32_to_cpu(ms->m_type), ms);
+ if (!local)
+ spin_unlock_bh(&ls->ls_waiters_lock);
+ return error;
+}
- r = lkb->lkb_resource;
+/* lkb is master or local copy */
- hold_rsb(r);
- lock_rsb(r);
+static void set_lvb_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int b, len = r->res_ls->ls_lvblen;
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ /* b=1 lvb returned to caller
+ b=0 lvb written to rsb or invalidated
+ b=-1 do nothing */
- receive_flags(lkb, ms);
+ b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
- error = receive_unlock_args(ls, lkb, ms);
- if (error) {
- send_unlock_reply(r, lkb, error);
- goto out;
- }
+ if (b == 1) {
+ if (!lkb->lkb_lvbptr)
+ return;
- error = do_unlock(r, lkb);
- send_unlock_reply(r, lkb, error);
- do_unlock_effects(r, lkb, error);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
- return 0;
+ if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
+ return;
- fail:
- setup_local_lkb(ls, ms);
- send_unlock_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
- return error;
-}
+ if (!r->res_lvbptr)
+ return;
-static int receive_cancel(struct dlm_ls *ls, const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error;
+ memcpy(lkb->lkb_lvbptr, r->res_lvbptr, len);
+ lkb->lkb_lvbseq = r->res_lvbseq;
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- goto fail;
+ } else if (b == 0) {
+ if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
+ rsb_set_flag(r, RSB_VALNOTVALID);
+ return;
+ }
- receive_flags(lkb, ms);
+ if (!lkb->lkb_lvbptr)
+ return;
- r = lkb->lkb_resource;
+ if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
+ return;
- hold_rsb(r);
- lock_rsb(r);
+ if (!r->res_lvbptr)
+ r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ if (!r->res_lvbptr)
+ return;
- error = do_cancel(r, lkb);
- send_cancel_reply(r, lkb, error);
- do_cancel_effects(r, lkb, error);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
- return 0;
+ memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
+ r->res_lvbseq++;
+ lkb->lkb_lvbseq = r->res_lvbseq;
+ rsb_clear_flag(r, RSB_VALNOTVALID);
+ }
- fail:
- setup_local_lkb(ls, ms);
- send_cancel_reply(&ls->ls_local_rsb, &ls->ls_local_lkb, error);
- return error;
+ if (rsb_flag(r, RSB_VALNOTVALID))
+ set_bit(DLM_SBF_VALNOTVALID_BIT, &lkb->lkb_sbflags);
}
-static int receive_grant(struct dlm_ls *ls, const struct dlm_message *ms)
+static void set_lvb_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error;
+ if (lkb->lkb_grmode < DLM_LOCK_PW)
+ return;
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
+ if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
+ rsb_set_flag(r, RSB_VALNOTVALID);
+ return;
+ }
- r = lkb->lkb_resource;
+ if (!lkb->lkb_lvbptr)
+ return;
- hold_rsb(r);
- lock_rsb(r);
+ if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
+ return;
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ if (!r->res_lvbptr)
+ r->res_lvbptr = dlm_allocate_lvb(r->res_ls);
- receive_flags_reply(lkb, ms, false);
- if (is_altmode(lkb))
- munge_altmode(lkb, ms);
- grant_lock_pc(r, lkb, ms);
- queue_cast(r, lkb, 0);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
- return 0;
+ if (!r->res_lvbptr)
+ return;
+
+ memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
+ r->res_lvbseq++;
+ rsb_clear_flag(r, RSB_VALNOTVALID);
}
-static int receive_bast(struct dlm_ls *ls, const struct dlm_message *ms)
+/* lkb is process copy (pc) */
+
+static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ const struct dlm_message *ms)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error;
+ int b;
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
+ if (!lkb->lkb_lvbptr)
+ return;
- r = lkb->lkb_resource;
+ if (!(lkb->lkb_exflags & DLM_LKF_VALBLK))
+ return;
- hold_rsb(r);
- lock_rsb(r);
+ b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
+ if (b == 1) {
+ int len = receive_extralen(ms);
+ if (len > r->res_ls->ls_lvblen)
+ len = r->res_ls->ls_lvblen;
+ memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
+ lkb->lkb_lvbseq = le32_to_cpu(ms->m_lvbseq);
+ }
+}
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+/* Manipulate lkb's on rsb's convert/granted/waiting queues
+ remove_lock -- used for unlock, removes lkb from granted
+ revert_lock -- used for cancel, moves lkb from convert to granted
+ grant_lock -- used for request and convert, adds lkb to granted or
+ moves lkb from convert or waiting to granted
- queue_bast(r, lkb, le32_to_cpu(ms->m_bastmode));
- lkb->lkb_highbast = le32_to_cpu(ms->m_bastmode);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
- return 0;
+ Each of these is used for master or local copy lkb's. There is
+ also a _pc() variation used to make the corresponding change on
+ a process copy (pc) lkb. */
+
+static void _remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ del_lkb(r, lkb);
+ lkb->lkb_grmode = DLM_LOCK_IV;
+ /* this unhold undoes the original ref from create_lkb()
+ so this leads to the lkb being freed */
+ unhold_lkb(lkb);
+}
+
+static void remove_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ set_lvb_unlock(r, lkb);
+ _remove_lock(r, lkb);
}
-static void receive_lookup(struct dlm_ls *ls, const struct dlm_message *ms)
+static void remove_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- int len, error, ret_nodeid, from_nodeid, our_nodeid;
+ _remove_lock(r, lkb);
+}
- from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
- our_nodeid = dlm_our_nodeid();
+/* returns: 0 did nothing
+ 1 moved lock to granted
+ -1 removed lock */
- len = receive_extralen(ms);
+static int revert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int rv = 0;
- error = dlm_master_lookup(ls, from_nodeid, ms->m_extra, len, 0,
- &ret_nodeid, NULL);
+ lkb->lkb_rqmode = DLM_LOCK_IV;
- /* Optimization: we're master so treat lookup as a request */
- if (!error && ret_nodeid == our_nodeid) {
- receive_request(ls, ms);
- return;
+ switch (lkb->lkb_status) {
+ case DLM_LKSTS_GRANTED:
+ break;
+ case DLM_LKSTS_CONVERT:
+ move_lkb(r, lkb, DLM_LKSTS_GRANTED);
+ rv = 1;
+ break;
+ case DLM_LKSTS_WAITING:
+ del_lkb(r, lkb);
+ lkb->lkb_grmode = DLM_LOCK_IV;
+ /* this unhold undoes the original ref from create_lkb()
+ so this leads to the lkb being freed */
+ unhold_lkb(lkb);
+ rv = -1;
+ break;
+ default:
+ log_print("invalid status for revert %d", lkb->lkb_status);
}
- send_lookup_reply(ls, ms, ret_nodeid, error);
+ return rv;
}
-static void receive_remove(struct dlm_ls *ls, const struct dlm_message *ms)
+static int revert_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- char name[DLM_RESNAME_MAXLEN+1];
- struct dlm_rsb *r;
- int rv, len, dir_nodeid, from_nodeid;
+ return revert_lock(r, lkb);
+}
- from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
+static void _grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ if (lkb->lkb_grmode != lkb->lkb_rqmode) {
+ lkb->lkb_grmode = lkb->lkb_rqmode;
+ if (lkb->lkb_status)
+ move_lkb(r, lkb, DLM_LKSTS_GRANTED);
+ else
+ add_lkb(r, lkb, DLM_LKSTS_GRANTED);
+ }
- len = receive_extralen(ms);
+ lkb->lkb_rqmode = DLM_LOCK_IV;
+ lkb->lkb_highbast = 0;
+}
- if (len > DLM_RESNAME_MAXLEN) {
- log_error(ls, "receive_remove from %d bad len %d",
- from_nodeid, len);
- return;
- }
+static void grant_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ set_lvb_lock(r, lkb);
+ _grant_lock(r, lkb);
+}
- dir_nodeid = dlm_hash2nodeid(ls, le32_to_cpu(ms->m_hash));
- if (dir_nodeid != dlm_our_nodeid()) {
- log_error(ls, "receive_remove from %d bad nodeid %d",
- from_nodeid, dir_nodeid);
- return;
- }
+static void grant_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ const struct dlm_message *ms)
+{
+ set_lvb_lock_pc(r, lkb, ms);
+ _grant_lock(r, lkb);
+}
- /*
- * Look for inactive rsb, if it's there, free it.
- * If the rsb is active, it's being used, and we should ignore this
- * message. This is an expected race between the dir node sending a
- * request to the master node at the same time as the master node sends
- * a remove to the dir node. The resolution to that race is for the
- * dir node to ignore the remove message, and the master node to
- * recreate the master rsb when it gets a request from the dir node for
- * an rsb it doesn't have.
- */
+/* called by grant_pending_locks() which means an async grant message must
+ be sent to the requesting node in addition to granting the lock if the
+ lkb belongs to a remote node. */
- memset(name, 0, sizeof(name));
- memcpy(name, ms->m_extra, len);
+static void grant_lock_pending(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ grant_lock(r, lkb);
+ if (is_master_copy(lkb))
+ send_grant(r, lkb);
+ else
+ queue_cast(r, lkb, 0);
+}
- rcu_read_lock();
- rv = dlm_search_rsb_tree(&ls->ls_rsbtbl, name, len, &r);
- if (rv) {
- rcu_read_unlock();
- /* should not happen */
- log_error(ls, "%s from %d not found %s", __func__,
- from_nodeid, name);
- return;
- }
+/* The special CONVDEADLK, ALTPR and ALTCW flags allow the master to
+ change the granted/requested modes. We're munging things accordingly in
+ the process copy.
+ CONVDEADLK: our grmode may have been forced down to NL to resolve a
+ conversion deadlock
+ ALTPR/ALTCW: our rqmode may have been changed to PR or CW to become
+ compatible with other granted locks */
- write_lock_bh(&ls->ls_rsbtbl_lock);
- if (!rsb_flag(r, RSB_HASHED)) {
- rcu_read_unlock();
- write_unlock_bh(&ls->ls_rsbtbl_lock);
- /* should not happen */
- log_error(ls, "%s from %d got removed during removal %s",
- __func__, from_nodeid, name);
+static void munge_demoted(struct dlm_lkb *lkb)
+{
+ if (lkb->lkb_rqmode == DLM_LOCK_IV || lkb->lkb_grmode == DLM_LOCK_IV) {
+ log_print("munge_demoted %x invalid modes gr %d rq %d",
+ lkb->lkb_id, lkb->lkb_grmode, lkb->lkb_rqmode);
return;
}
- /* at this stage the rsb can only being freed here */
- rcu_read_unlock();
-
- if (!rsb_flag(r, RSB_INACTIVE)) {
- if (r->res_master_nodeid != from_nodeid) {
- /* should not happen */
- log_error(ls, "receive_remove on active rsb from %d master %d",
- from_nodeid, r->res_master_nodeid);
- dlm_print_rsb(r);
- write_unlock_bh(&ls->ls_rsbtbl_lock);
- return;
- }
- /* Ignore the remove message, see race comment above. */
+ lkb->lkb_grmode = DLM_LOCK_NL;
+}
- log_debug(ls, "receive_remove from %d master %d first %x %s",
- from_nodeid, r->res_master_nodeid, r->res_first_lkid,
- name);
- write_unlock_bh(&ls->ls_rsbtbl_lock);
+static void munge_altmode(struct dlm_lkb *lkb, const struct dlm_message *ms)
+{
+ if (ms->m_type != cpu_to_le32(DLM_MSG_REQUEST_REPLY) &&
+ ms->m_type != cpu_to_le32(DLM_MSG_GRANT)) {
+ log_print("munge_altmode %x invalid reply type %d",
+ lkb->lkb_id, le32_to_cpu(ms->m_type));
return;
}
- if (r->res_master_nodeid != from_nodeid) {
- log_error(ls, "receive_remove inactive from %d master %d",
- from_nodeid, r->res_master_nodeid);
- dlm_print_rsb(r);
- write_unlock_bh(&ls->ls_rsbtbl_lock);
- return;
+ if (lkb->lkb_exflags & DLM_LKF_ALTPR)
+ lkb->lkb_rqmode = DLM_LOCK_PR;
+ else if (lkb->lkb_exflags & DLM_LKF_ALTCW)
+ lkb->lkb_rqmode = DLM_LOCK_CW;
+ else {
+ log_print("munge_altmode invalid exflags %x", lkb->lkb_exflags);
+ dlm_print_lkb(lkb);
}
+}
- list_del(&r->res_slow_list);
- rhashtable_remove_fast(&ls->ls_rsbtbl, &r->res_node,
- dlm_rhash_rsb_params);
- rsb_clear_flag(r, RSB_HASHED);
- write_unlock_bh(&ls->ls_rsbtbl_lock);
+static inline int first_in_list(struct dlm_lkb *lkb, struct list_head *head)
+{
+ struct dlm_lkb *first = list_entry(head->next, struct dlm_lkb,
+ lkb_statequeue);
+ if (lkb->lkb_id == first->lkb_id)
+ return 1;
- free_inactive_rsb(r);
+ return 0;
}
-static void receive_purge(struct dlm_ls *ls, const struct dlm_message *ms)
+/* Check if the given lkb conflicts with another lkb on the queue. */
+
+static int queue_conflict(struct list_head *head, struct dlm_lkb *lkb)
{
- do_purge(ls, le32_to_cpu(ms->m_nodeid), le32_to_cpu(ms->m_pid));
+ struct dlm_lkb *this;
+
+ list_for_each_entry(this, head, lkb_statequeue) {
+ if (this == lkb)
+ continue;
+ if (!modes_compat(this, lkb))
+ return 1;
+ }
+ return 0;
}
-static int receive_request_reply(struct dlm_ls *ls,
- const struct dlm_message *ms)
+/*
+ * "A conversion deadlock arises with a pair of lock requests in the converting
+ * queue for one resource. The granted mode of each lock blocks the requested
+ * mode of the other lock."
+ *
+ * Part 2: if the granted mode of lkb is preventing an earlier lkb in the
+ * convert queue from being granted, then deadlk/demote lkb.
+ *
+ * Example:
+ * Granted Queue: empty
+ * Convert Queue: NL->EX (first lock)
+ * PR->EX (second lock)
+ *
+ * The first lock can't be granted because of the granted mode of the second
+ * lock and the second lock can't be granted because it's not first in the
+ * list. We either cancel lkb's conversion (PR->EX) and return EDEADLK, or we
+ * demote the granted mode of lkb (from PR to NL) if it has the CONVDEADLK
+ * flag set and return DEMOTED in the lksb flags.
+ *
+ * Originally, this function detected conv-deadlk in a more limited scope:
+ * - if !modes_compat(lkb1, lkb2) && !modes_compat(lkb2, lkb1), or
+ * - if lkb1 was the first entry in the queue (not just earlier), and was
+ * blocked by the granted mode of lkb2, and there was nothing on the
+ * granted queue preventing lkb1 from being granted immediately, i.e.
+ * lkb2 was the only thing preventing lkb1 from being granted.
+ *
+ * That second condition meant we'd only say there was conv-deadlk if
+ * resolving it (by demotion) would lead to the first lock on the convert
+ * queue being granted right away. It allowed conversion deadlocks to exist
+ * between locks on the convert queue while they couldn't be granted anyway.
+ *
+ * Now, we detect and take action on conversion deadlocks immediately when
+ * they're created, even if they may not be immediately consequential. If
+ * lkb1 exists anywhere in the convert queue and lkb2 comes in with a granted
+ * mode that would prevent lkb1's conversion from being granted, we do a
+ * deadlk/demote on lkb2 right away and don't let it onto the convert queue.
+ * I think this means that the lkb_is_ahead condition below should always
+ * be zero, i.e. there will never be conv-deadlk between two locks that are
+ * both already on the convert queue.
+ */
+
+static int conversion_deadlock_detect(struct dlm_rsb *r, struct dlm_lkb *lkb2)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error, mstype, result;
- int from_nodeid = le32_to_cpu(ms->m_header.h_nodeid);
-
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
-
- r = lkb->lkb_resource;
- hold_rsb(r);
- lock_rsb(r);
-
- error = validate_message(lkb, ms);
- if (error)
- goto out;
-
- mstype = lkb->lkb_wait_type;
- error = remove_from_waiters(lkb, DLM_MSG_REQUEST_REPLY);
- if (error) {
- log_error(ls, "receive_request_reply %x remote %d %x result %d",
- lkb->lkb_id, from_nodeid, le32_to_cpu(ms->m_lkid),
- from_dlm_errno(le32_to_cpu(ms->m_result)));
- dlm_dump_rsb(r);
- goto out;
- }
-
- /* Optimization: the dir node was also the master, so it took our
- lookup as a request and sent request reply instead of lookup reply */
- if (mstype == DLM_MSG_LOOKUP) {
- r->res_master_nodeid = from_nodeid;
- r->res_nodeid = from_nodeid;
- lkb->lkb_nodeid = from_nodeid;
- }
-
- /* this is the value returned from do_request() on the master */
- result = from_dlm_errno(le32_to_cpu(ms->m_result));
-
- switch (result) {
- case -EAGAIN:
- /* request would block (be queued) on remote master */
- queue_cast(r, lkb, -EAGAIN);
- confirm_master(r, -EAGAIN);
- unhold_lkb(lkb); /* undoes create_lkb() */
- break;
-
- case -EINPROGRESS:
- case 0:
- /* request was queued or granted on remote master */
- receive_flags_reply(lkb, ms, false);
- lkb->lkb_remid = le32_to_cpu(ms->m_lkid);
- if (is_altmode(lkb))
- munge_altmode(lkb, ms);
- if (result) {
- add_lkb(r, lkb, DLM_LKSTS_WAITING);
- } else {
- grant_lock_pc(r, lkb, ms);
- queue_cast(r, lkb, 0);
- }
- confirm_master(r, result);
- break;
+ struct dlm_lkb *lkb1;
+ int lkb_is_ahead = 0;
- case -EBADR:
- case -ENOTBLK:
- /* find_rsb failed to find rsb or rsb wasn't master */
- log_limit(ls, "receive_request_reply %x from %d %d "
- "master %d dir %d first %x %s", lkb->lkb_id,
- from_nodeid, result, r->res_master_nodeid,
- r->res_dir_nodeid, r->res_first_lkid, r->res_name);
-
- if (r->res_dir_nodeid != dlm_our_nodeid() &&
- r->res_master_nodeid != dlm_our_nodeid()) {
- /* cause _request_lock->set_master->send_lookup */
- r->res_master_nodeid = 0;
- r->res_nodeid = -1;
- lkb->lkb_nodeid = -1;
+ list_for_each_entry(lkb1, &r->res_convertqueue, lkb_statequeue) {
+ if (lkb1 == lkb2) {
+ lkb_is_ahead = 1;
+ continue;
}
- if (is_overlap(lkb)) {
- /* we'll ignore error in cancel/unlock reply */
- queue_cast_overlap(r, lkb);
- confirm_master(r, result);
- unhold_lkb(lkb); /* undoes create_lkb() */
+ if (!lkb_is_ahead) {
+ if (!modes_compat(lkb2, lkb1))
+ return 1;
} else {
- _request_lock(r, lkb);
-
- if (r->res_master_nodeid == dlm_our_nodeid())
- confirm_master(r, 0);
+ if (!modes_compat(lkb2, lkb1) &&
+ !modes_compat(lkb1, lkb2))
+ return 1;
}
- break;
-
- default:
- log_error(ls, "receive_request_reply %x error %d",
- lkb->lkb_id, result);
- }
-
- if ((result == 0 || result == -EINPROGRESS) &&
- test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags)) {
- log_debug(ls, "receive_request_reply %x result %d unlock",
- lkb->lkb_id, result);
- clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
- send_unlock(r, lkb);
- } else if ((result == -EINPROGRESS) &&
- test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT,
- &lkb->lkb_iflags)) {
- log_debug(ls, "receive_request_reply %x cancel", lkb->lkb_id);
- clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
- send_cancel(r, lkb);
- } else {
- clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
- clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
}
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
return 0;
}
-static void __receive_convert_reply(struct dlm_rsb *r, struct dlm_lkb *lkb,
- const struct dlm_message *ms, bool local)
+/*
+ * Return 1 if the lock can be granted, 0 otherwise.
+ * Also detect and resolve conversion deadlocks.
+ *
+ * lkb is the lock to be granted
+ *
+ * now is 1 if the function is being called in the context of the
+ * immediate request, it is 0 if called later, after the lock has been
+ * queued.
+ *
+ * recover is 1 if dlm_recover_grant() is trying to grant conversions
+ * after recovery.
+ *
+ * References are from chapter 6 of "VAXcluster Principles" by Roy Davis
+ */
+
+static int _can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
+ int recover)
{
- /* this is the value returned from do_convert() on the master */
- switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
- case -EAGAIN:
- /* convert would block (be queued) on remote master */
- queue_cast(r, lkb, -EAGAIN);
- break;
+ int8_t conv = (lkb->lkb_grmode != DLM_LOCK_IV);
- case -EDEADLK:
- receive_flags_reply(lkb, ms, local);
- revert_lock_pc(r, lkb);
- queue_cast(r, lkb, -EDEADLK);
- break;
+ /*
+ * 6-10: Version 5.4 introduced an option to address the phenomenon of
+ * a new request for a NL mode lock being blocked.
+ *
+ * 6-11: If the optional EXPEDITE flag is used with the new NL mode
+ * request, then it would be granted. In essence, the use of this flag
+ * tells the Lock Manager to expedite theis request by not considering
+ * what may be in the CONVERTING or WAITING queues... As of this
+ * writing, the EXPEDITE flag can be used only with new requests for NL
+ * mode locks. This flag is not valid for conversion requests.
+ *
+ * A shortcut. Earlier checks return an error if EXPEDITE is used in a
+ * conversion or used with a non-NL requested mode. We also know an
+ * EXPEDITE request is always granted immediately, so now must always
+ * be 1. The full condition to grant an expedite request: (now &&
+ * !conv && lkb->rqmode == DLM_LOCK_NL && (flags & EXPEDITE)) can
+ * therefore be shortened to just checking the flag.
+ */
- case -EINPROGRESS:
- /* convert was queued on remote master */
- receive_flags_reply(lkb, ms, local);
- if (is_demoted(lkb))
- munge_demoted(lkb);
- del_lkb(r, lkb);
- add_lkb(r, lkb, DLM_LKSTS_CONVERT);
- break;
+ if (lkb->lkb_exflags & DLM_LKF_EXPEDITE)
+ return 1;
- case 0:
- /* convert was granted on remote master */
- receive_flags_reply(lkb, ms, local);
- if (is_demoted(lkb))
- munge_demoted(lkb);
- grant_lock_pc(r, lkb, ms);
- queue_cast(r, lkb, 0);
- break;
+ /*
+ * A shortcut. Without this, !queue_conflict(grantqueue, lkb) would be
+ * added to the remaining conditions.
+ */
- default:
- log_error(r->res_ls, "receive_convert_reply %x remote %d %x %d",
- lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid),
- from_dlm_errno(le32_to_cpu(ms->m_result)));
- dlm_print_rsb(r);
- dlm_print_lkb(lkb);
- }
-}
+ if (queue_conflict(&r->res_grantqueue, lkb))
+ return 0;
-static void _receive_convert_reply(struct dlm_lkb *lkb,
- const struct dlm_message *ms, bool local)
-{
- struct dlm_rsb *r = lkb->lkb_resource;
- int error;
+ /*
+ * 6-3: By default, a conversion request is immediately granted if the
+ * requested mode is compatible with the modes of all other granted
+ * locks
+ */
- hold_rsb(r);
- lock_rsb(r);
+ if (queue_conflict(&r->res_convertqueue, lkb))
+ return 0;
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ /*
+ * The RECOVER_GRANT flag means dlm_recover_grant() is granting
+ * locks for a recovered rsb, on which lkb's have been rebuilt.
+ * The lkb's may have been rebuilt on the queues in a different
+ * order than they were in on the previous master. So, granting
+ * queued conversions in order after recovery doesn't make sense
+ * since the order hasn't been preserved anyway. The new order
+ * could also have created a new "in place" conversion deadlock.
+ * (e.g. old, failed master held granted EX, with PR->EX, NL->EX.
+ * After recovery, there would be no granted locks, and possibly
+ * NL->EX, PR->EX, an in-place conversion deadlock.) So, after
+ * recovery, grant conversions without considering order.
+ */
- error = remove_from_waiters_ms(lkb, ms, local);
- if (error)
- goto out;
+ if (conv && recover)
+ return 1;
- __receive_convert_reply(r, lkb, ms, local);
- out:
- unlock_rsb(r);
- put_rsb(r);
-}
+ /*
+ * 6-5: But the default algorithm for deciding whether to grant or
+ * queue conversion requests does not by itself guarantee that such
+ * requests are serviced on a "first come first serve" basis. This, in
+ * turn, can lead to a phenomenon known as "indefinate postponement".
+ *
+ * 6-7: This issue is dealt with by using the optional QUECVT flag with
+ * the system service employed to request a lock conversion. This flag
+ * forces certain conversion requests to be queued, even if they are
+ * compatible with the granted modes of other locks on the same
+ * resource. Thus, the use of this flag results in conversion requests
+ * being ordered on a "first come first servce" basis.
+ *
+ * DCT: This condition is all about new conversions being able to occur
+ * "in place" while the lock remains on the granted queue (assuming
+ * nothing else conflicts.) IOW if QUECVT isn't set, a conversion
+ * doesn't _have_ to go onto the convert queue where it's processed in
+ * order. The "now" variable is necessary to distinguish converts
+ * being received and processed for the first time now, because once a
+ * convert is moved to the conversion queue the condition below applies
+ * requiring fifo granting.
+ */
-static int receive_convert_reply(struct dlm_ls *ls,
- const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- int error;
+ if (now && conv && !(lkb->lkb_exflags & DLM_LKF_QUECVT))
+ return 1;
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
+ /*
+ * Even if the convert is compat with all granted locks,
+ * QUECVT forces it behind other locks on the convert queue.
+ */
- _receive_convert_reply(lkb, ms, false);
- dlm_put_lkb(lkb);
- return 0;
-}
+ if (now && conv && (lkb->lkb_exflags & DLM_LKF_QUECVT)) {
+ if (list_empty(&r->res_convertqueue))
+ return 1;
+ else
+ return 0;
+ }
-static void _receive_unlock_reply(struct dlm_lkb *lkb,
- const struct dlm_message *ms, bool local)
-{
- struct dlm_rsb *r = lkb->lkb_resource;
- int error;
+ /*
+ * The NOORDER flag is set to avoid the standard vms rules on grant
+ * order.
+ */
- hold_rsb(r);
- lock_rsb(r);
+ if (lkb->lkb_exflags & DLM_LKF_NOORDER)
+ return 1;
- error = validate_message(lkb, ms);
- if (error)
- goto out;
+ /*
+ * 6-3: Once in that queue [CONVERTING], a conversion request cannot be
+ * granted until all other conversion requests ahead of it are granted
+ * and/or canceled.
+ */
- error = remove_from_waiters_ms(lkb, ms, local);
- if (error)
- goto out;
+ if (!now && conv && first_in_list(lkb, &r->res_convertqueue))
+ return 1;
- /* this is the value returned from do_unlock() on the master */
+ /*
+ * 6-4: By default, a new request is immediately granted only if all
+ * three of the following conditions are satisfied when the request is
+ * issued:
+ * - The queue of ungranted conversion requests for the resource is
+ * empty.
+ * - The queue of ungranted new requests for the resource is empty.
+ * - The mode of the new request is compatible with the most
+ * restrictive mode of all granted locks on the resource.
+ */
- switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
- case -DLM_EUNLOCK:
- receive_flags_reply(lkb, ms, local);
- remove_lock_pc(r, lkb);
- queue_cast(r, lkb, -DLM_EUNLOCK);
- break;
- case -ENOENT:
- break;
- default:
- log_error(r->res_ls, "receive_unlock_reply %x error %d",
- lkb->lkb_id, from_dlm_errno(le32_to_cpu(ms->m_result)));
- }
- out:
- unlock_rsb(r);
- put_rsb(r);
-}
+ if (now && !conv && list_empty(&r->res_convertqueue) &&
+ list_empty(&r->res_waitqueue))
+ return 1;
-static int receive_unlock_reply(struct dlm_ls *ls,
- const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- int error;
+ /*
+ * 6-4: Once a lock request is in the queue of ungranted new requests,
+ * it cannot be granted until the queue of ungranted conversion
+ * requests is empty, all ungranted new requests ahead of it are
+ * granted and/or canceled, and it is compatible with the granted mode
+ * of the most restrictive lock granted on the resource.
+ */
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
+ if (!now && !conv && list_empty(&r->res_convertqueue) &&
+ first_in_list(lkb, &r->res_waitqueue))
+ return 1;
- _receive_unlock_reply(lkb, ms, false);
- dlm_put_lkb(lkb);
return 0;
}
-static void _receive_cancel_reply(struct dlm_lkb *lkb,
- const struct dlm_message *ms, bool local)
+static int can_be_granted(struct dlm_rsb *r, struct dlm_lkb *lkb, int now,
+ int recover, int *err)
{
- struct dlm_rsb *r = lkb->lkb_resource;
- int error;
+ int rv;
+ int8_t alt = 0, rqmode = lkb->lkb_rqmode;
+ int8_t is_convert = (lkb->lkb_grmode != DLM_LOCK_IV);
- hold_rsb(r);
- lock_rsb(r);
+ if (err)
+ *err = 0;
- error = validate_message(lkb, ms);
- if (error)
+ rv = _can_be_granted(r, lkb, now, recover);
+ if (rv)
goto out;
- error = remove_from_waiters_ms(lkb, ms, local);
- if (error)
+ /*
+ * The CONVDEADLK flag is non-standard and tells the dlm to resolve
+ * conversion deadlocks by demoting grmode to NL, otherwise the dlm
+ * cancels one of the locks.
+ */
+
+ if (is_convert && can_be_queued(lkb) &&
+ conversion_deadlock_detect(r, lkb)) {
+ if (lkb->lkb_exflags & DLM_LKF_CONVDEADLK) {
+ lkb->lkb_grmode = DLM_LOCK_NL;
+ set_bit(DLM_SBF_DEMOTED_BIT, &lkb->lkb_sbflags);
+ } else if (err) {
+ *err = -EDEADLK;
+ } else {
+ log_print("can_be_granted deadlock %x now %d",
+ lkb->lkb_id, now);
+ dlm_dump_rsb(r);
+ }
goto out;
+ }
+
+ /*
+ * The ALTPR and ALTCW flags are non-standard and tell the dlm to try
+ * to grant a request in a mode other than the normal rqmode. It's a
+ * simple way to provide a big optimization to applications that can
+ * use them.
+ */
- /* this is the value returned from do_cancel() on the master */
+ if (rqmode != DLM_LOCK_PR && (lkb->lkb_exflags & DLM_LKF_ALTPR))
+ alt = DLM_LOCK_PR;
+ else if (rqmode != DLM_LOCK_CW && (lkb->lkb_exflags & DLM_LKF_ALTCW))
+ alt = DLM_LOCK_CW;
- switch (from_dlm_errno(le32_to_cpu(ms->m_result))) {
- case -DLM_ECANCEL:
- receive_flags_reply(lkb, ms, local);
- revert_lock_pc(r, lkb);
- queue_cast(r, lkb, -DLM_ECANCEL);
- break;
- case 0:
- break;
- default:
- log_error(r->res_ls, "receive_cancel_reply %x error %d",
- lkb->lkb_id,
- from_dlm_errno(le32_to_cpu(ms->m_result)));
+ if (alt) {
+ lkb->lkb_rqmode = alt;
+ rv = _can_be_granted(r, lkb, now, 0);
+ if (rv)
+ set_bit(DLM_SBF_ALTMODE_BIT, &lkb->lkb_sbflags);
+ else
+ lkb->lkb_rqmode = rqmode;
}
out:
- unlock_rsb(r);
- put_rsb(r);
+ return rv;
}
-static int receive_cancel_reply(struct dlm_ls *ls,
- const struct dlm_message *ms)
-{
- struct dlm_lkb *lkb;
- int error;
-
- error = find_lkb(ls, le32_to_cpu(ms->m_remid), &lkb);
- if (error)
- return error;
-
- _receive_cancel_reply(lkb, ms, false);
- dlm_put_lkb(lkb);
- return 0;
-}
+/* Returns the highest requested mode of all blocked conversions; sets
+ cw if there's a blocked conversion to DLM_LOCK_CW. */
-static void receive_lookup_reply(struct dlm_ls *ls,
- const struct dlm_message *ms)
+static int grant_pending_convert(struct dlm_rsb *r, int high, int *cw,
+ unsigned int *count)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error, ret_nodeid;
- int do_lookup_list = 0;
+ struct dlm_lkb *lkb, *s;
+ int recover = rsb_flag(r, RSB_RECOVER_GRANT);
+ int hi, demoted, quit, grant_restart, demote_restart;
+ int deadlk;
- error = find_lkb(ls, le32_to_cpu(ms->m_lkid), &lkb);
- if (error) {
- log_error(ls, "%s no lkid %x", __func__,
- le32_to_cpu(ms->m_lkid));
- return;
- }
+ quit = 0;
+ restart:
+ grant_restart = 0;
+ demote_restart = 0;
+ hi = DLM_LOCK_IV;
- /* ms->m_result is the value returned by dlm_master_lookup on dir node
- FIXME: will a non-zero error ever be returned? */
+ list_for_each_entry_safe(lkb, s, &r->res_convertqueue, lkb_statequeue) {
+ demoted = is_demoted(lkb);
+ deadlk = 0;
- r = lkb->lkb_resource;
- hold_rsb(r);
- lock_rsb(r);
+ if (can_be_granted(r, lkb, 0, recover, &deadlk)) {
+ grant_lock_pending(r, lkb);
+ grant_restart = 1;
+ if (count)
+ (*count)++;
+ continue;
+ }
- error = remove_from_waiters(lkb, DLM_MSG_LOOKUP_REPLY);
- if (error)
- goto out;
+ if (!demoted && is_demoted(lkb)) {
+ log_print("WARN: pending demoted %x node %d %s",
+ lkb->lkb_id, lkb->lkb_nodeid, r->res_name);
+ demote_restart = 1;
+ continue;
+ }
- ret_nodeid = le32_to_cpu(ms->m_nodeid);
+ if (deadlk) {
+ /*
+ * If DLM_LKB_NODLKWT flag is set and conversion
+ * deadlock is detected, we request blocking AST and
+ * down (or cancel) conversion.
+ */
+ if (lkb->lkb_exflags & DLM_LKF_NODLCKWT) {
+ if (lkb->lkb_highbast < lkb->lkb_rqmode) {
+ queue_bast(r, lkb, lkb->lkb_rqmode);
+ lkb->lkb_highbast = lkb->lkb_rqmode;
+ }
+ } else {
+ log_print("WARN: pending deadlock %x node %d %s",
+ lkb->lkb_id, lkb->lkb_nodeid,
+ r->res_name);
+ dlm_dump_rsb(r);
+ }
+ continue;
+ }
- /* We sometimes receive a request from the dir node for this
- rsb before we've received the dir node's loookup_reply for it.
- The request from the dir node implies we're the master, so we set
- ourself as master in receive_request_reply, and verify here that
- we are indeed the master. */
+ hi = max_t(int, lkb->lkb_rqmode, hi);
- if (r->res_master_nodeid && (r->res_master_nodeid != ret_nodeid)) {
- /* This should never happen */
- log_error(ls, "receive_lookup_reply %x from %d ret %d "
- "master %d dir %d our %d first %x %s",
- lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid),
- ret_nodeid, r->res_master_nodeid, r->res_dir_nodeid,
- dlm_our_nodeid(), r->res_first_lkid, r->res_name);
+ if (cw && lkb->lkb_rqmode == DLM_LOCK_CW)
+ *cw = 1;
}
- if (ret_nodeid == dlm_our_nodeid()) {
- r->res_master_nodeid = ret_nodeid;
- r->res_nodeid = 0;
- do_lookup_list = 1;
- r->res_first_lkid = 0;
- } else if (ret_nodeid == -1) {
- /* the remote node doesn't believe it's the dir node */
- log_error(ls, "receive_lookup_reply %x from %d bad ret_nodeid",
- lkb->lkb_id, le32_to_cpu(ms->m_header.h_nodeid));
- r->res_master_nodeid = 0;
- r->res_nodeid = -1;
- lkb->lkb_nodeid = -1;
- } else {
- /* set_master() will set lkb_nodeid from r */
- r->res_master_nodeid = ret_nodeid;
- r->res_nodeid = ret_nodeid;
+ if (grant_restart)
+ goto restart;
+ if (demote_restart && !quit) {
+ quit = 1;
+ goto restart;
}
- if (is_overlap(lkb)) {
- log_debug(ls, "receive_lookup_reply %x unlock %x",
- lkb->lkb_id, dlm_iflags_val(lkb));
- queue_cast_overlap(r, lkb);
- unhold_lkb(lkb); /* undoes create_lkb() */
- goto out_list;
- }
+ return max_t(int, high, hi);
+}
+
+static int grant_pending_wait(struct dlm_rsb *r, int high, int *cw,
+ unsigned int *count)
+{
+ struct dlm_lkb *lkb, *s;
- _request_lock(r, lkb);
+ list_for_each_entry_safe(lkb, s, &r->res_waitqueue, lkb_statequeue) {
+ if (can_be_granted(r, lkb, 0, 0, NULL)) {
+ grant_lock_pending(r, lkb);
+ if (count)
+ (*count)++;
+ } else {
+ high = max_t(int, lkb->lkb_rqmode, high);
+ if (lkb->lkb_rqmode == DLM_LOCK_CW)
+ *cw = 1;
+ }
+ }
- out_list:
- if (do_lookup_list)
- process_lookup_list(r);
- out:
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
+ return high;
}
-static void _receive_message(struct dlm_ls *ls, const struct dlm_message *ms,
- uint32_t saved_seq)
-{
- int error = 0, noent = 0;
+/* cw of 1 means there's a lock with a rqmode of DLM_LOCK_CW that's blocked
+ on either the convert or waiting queue.
+ high is the largest rqmode of all locks blocked on the convert or
+ waiting queue. */
- if (WARN_ON_ONCE(!dlm_is_member(ls, le32_to_cpu(ms->m_header.h_nodeid)))) {
- log_limit(ls, "receive %d from non-member %d %x %x %d",
- le32_to_cpu(ms->m_type),
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid), le32_to_cpu(ms->m_remid),
- from_dlm_errno(le32_to_cpu(ms->m_result)));
- return;
+static int lock_requires_bast(struct dlm_lkb *gr, int high, int cw)
+{
+ if (gr->lkb_grmode == DLM_LOCK_PR && cw) {
+ if (gr->lkb_highbast < DLM_LOCK_EX)
+ return 1;
+ return 0;
}
- switch (ms->m_type) {
+ if (gr->lkb_highbast < high &&
+ !__dlm_compat_matrix[gr->lkb_grmode+1][high+1])
+ return 1;
+ return 0;
+}
- /* messages sent to a master node */
+static void grant_pending_locks(struct dlm_rsb *r, unsigned int *count)
+{
+ struct dlm_lkb *lkb, *s;
+ int high = DLM_LOCK_IV;
+ int cw = 0;
- case cpu_to_le32(DLM_MSG_REQUEST):
- error = receive_request(ls, ms);
- break;
+ if (!is_master(r)) {
+ log_print("grant_pending_locks r nodeid %d", r->res_nodeid);
+ dlm_dump_rsb(r);
+ return;
+ }
- case cpu_to_le32(DLM_MSG_CONVERT):
- error = receive_convert(ls, ms);
- break;
+ high = grant_pending_convert(r, high, &cw, count);
+ high = grant_pending_wait(r, high, &cw, count);
- case cpu_to_le32(DLM_MSG_UNLOCK):
- error = receive_unlock(ls, ms);
- break;
+ if (high == DLM_LOCK_IV)
+ return;
- case cpu_to_le32(DLM_MSG_CANCEL):
- noent = 1;
- error = receive_cancel(ls, ms);
- break;
+ /*
+ * If there are locks left on the wait/convert queue then send blocking
+ * ASTs to granted locks based on the largest requested mode (high)
+ * found above.
+ */
- /* messages sent from a master node (replies to above) */
+ list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
+ if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
+ if (cw && high == DLM_LOCK_PR &&
+ lkb->lkb_grmode == DLM_LOCK_PR)
+ queue_bast(r, lkb, DLM_LOCK_CW);
+ else
+ queue_bast(r, lkb, high);
+ lkb->lkb_highbast = high;
+ }
+ }
+}
- case cpu_to_le32(DLM_MSG_REQUEST_REPLY):
- error = receive_request_reply(ls, ms);
- break;
+static int modes_require_bast(struct dlm_lkb *gr, struct dlm_lkb *rq)
+{
+ if ((gr->lkb_grmode == DLM_LOCK_PR && rq->lkb_rqmode == DLM_LOCK_CW) ||
+ (gr->lkb_grmode == DLM_LOCK_CW && rq->lkb_rqmode == DLM_LOCK_PR)) {
+ if (gr->lkb_highbast < DLM_LOCK_EX)
+ return 1;
+ return 0;
+ }
- case cpu_to_le32(DLM_MSG_CONVERT_REPLY):
- error = receive_convert_reply(ls, ms);
- break;
+ if (gr->lkb_highbast < rq->lkb_rqmode && !modes_compat(gr, rq))
+ return 1;
+ return 0;
+}
- case cpu_to_le32(DLM_MSG_UNLOCK_REPLY):
- error = receive_unlock_reply(ls, ms);
- break;
+static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
+ struct dlm_lkb *lkb)
+{
+ struct dlm_lkb *gr;
- case cpu_to_le32(DLM_MSG_CANCEL_REPLY):
- error = receive_cancel_reply(ls, ms);
- break;
+ list_for_each_entry(gr, head, lkb_statequeue) {
+ /* skip self when sending basts to convertqueue */
+ if (gr == lkb)
+ continue;
+ if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
+ queue_bast(r, gr, lkb->lkb_rqmode);
+ gr->lkb_highbast = lkb->lkb_rqmode;
+ }
+ }
+}
- /* messages sent from a master node (only two types of async msg) */
+static void send_blocking_asts(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ send_bast_queue(r, &r->res_grantqueue, lkb);
+}
- case cpu_to_le32(DLM_MSG_GRANT):
- noent = 1;
- error = receive_grant(ls, ms);
- break;
+static void send_blocking_asts_all(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ send_bast_queue(r, &r->res_grantqueue, lkb);
+ send_bast_queue(r, &r->res_convertqueue, lkb);
+}
- case cpu_to_le32(DLM_MSG_BAST):
- noent = 1;
- error = receive_bast(ls, ms);
- break;
+/* set_master(r, lkb) -- set the master nodeid of a resource
- /* messages sent to a dir node */
+ The purpose of this function is to set the nodeid field in the given
+ lkb using the nodeid field in the given rsb. If the rsb's nodeid is
+ known, it can just be copied to the lkb and the function will return
+ 0. If the rsb's nodeid is _not_ known, it needs to be looked up
+ before it can be copied to the lkb.
- case cpu_to_le32(DLM_MSG_LOOKUP):
- receive_lookup(ls, ms);
- break;
+ When the rsb nodeid is being looked up remotely, the initial lkb
+ causing the lookup is kept on the ls_waiters list waiting for the
+ lookup reply. Other lkb's waiting for the same rsb lookup are kept
+ on the rsb's res_lookup list until the master is verified.
- case cpu_to_le32(DLM_MSG_REMOVE):
- receive_remove(ls, ms);
- break;
+ Return values:
+ 0: nodeid is set in rsb/lkb and the caller should go ahead and use it
+ 1: the rsb master is not available and the lkb has been placed on
+ a wait queue
+*/
- /* messages sent from a dir node (remove has no reply) */
+static int set_master(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int our_nodeid = dlm_our_nodeid();
- case cpu_to_le32(DLM_MSG_LOOKUP_REPLY):
- receive_lookup_reply(ls, ms);
- break;
+ if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
+ rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
+ r->res_first_lkid = lkb->lkb_id;
+ lkb->lkb_nodeid = r->res_nodeid;
+ return 0;
+ }
- /* other messages */
+ if (r->res_first_lkid && r->res_first_lkid != lkb->lkb_id) {
+ list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
+ return 1;
+ }
- case cpu_to_le32(DLM_MSG_PURGE):
- receive_purge(ls, ms);
- break;
+ if (r->res_master_nodeid == our_nodeid) {
+ lkb->lkb_nodeid = 0;
+ return 0;
+ }
- default:
- log_error(ls, "unknown message type %d",
- le32_to_cpu(ms->m_type));
+ if (r->res_master_nodeid) {
+ lkb->lkb_nodeid = r->res_master_nodeid;
+ return 0;
}
- /*
- * When checking for ENOENT, we're checking the result of
- * find_lkb(m_remid):
- *
- * The lock id referenced in the message wasn't found. This may
- * happen in normal usage for the async messages and cancel, so
- * only use log_debug for them.
- *
- * Some errors are expected and normal.
- */
+ if (dlm_dir_nodeid(r) == our_nodeid) {
+ /* This is a somewhat unusual case; find_rsb will usually
+ have set res_master_nodeid when dir nodeid is local, but
+ there are cases where we become the dir node after we've
+ past find_rsb and go through _request_lock again.
+ confirm_master() or process_lookup_list() needs to be
+ called after this. */
+ log_debug(r->res_ls, "set_master %x self master %d dir %d %s",
+ lkb->lkb_id, r->res_master_nodeid, r->res_dir_nodeid,
+ r->res_name);
+ r->res_master_nodeid = our_nodeid;
+ r->res_nodeid = 0;
+ lkb->lkb_nodeid = 0;
+ return 0;
+ }
- if (error == -ENOENT && noent) {
- log_debug(ls, "receive %d no %x remote %d %x saved_seq %u",
- le32_to_cpu(ms->m_type), le32_to_cpu(ms->m_remid),
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid), saved_seq);
- } else if (error == -ENOENT) {
- log_error(ls, "receive %d no %x remote %d %x saved_seq %u",
- le32_to_cpu(ms->m_type), le32_to_cpu(ms->m_remid),
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid), saved_seq);
-
- if (ms->m_type == cpu_to_le32(DLM_MSG_CONVERT))
- dlm_dump_rsb_hash(ls, le32_to_cpu(ms->m_hash));
- }
-
- if (error == -EINVAL) {
- log_error(ls, "receive %d inval from %d lkid %x remid %x "
- "saved_seq %u",
- le32_to_cpu(ms->m_type),
- le32_to_cpu(ms->m_header.h_nodeid),
- le32_to_cpu(ms->m_lkid), le32_to_cpu(ms->m_remid),
- saved_seq);
- }
-}
-
-/* If the lockspace is in recovery mode (locking stopped), then normal
- messages are saved on the requestqueue for processing after recovery is
- done. When not in recovery mode, we wait for dlm_recoverd to drain saved
- messages off the requestqueue before we process new ones. This occurs right
- after recovery completes when we transition from saving all messages on
- requestqueue, to processing all the saved messages, to processing new
- messages as they arrive. */
-
-static void dlm_receive_message(struct dlm_ls *ls, const struct dlm_message *ms,
- int nodeid)
-{
-try_again:
- read_lock_bh(&ls->ls_requestqueue_lock);
- if (test_bit(LSFL_RECV_MSG_BLOCKED, &ls->ls_flags)) {
- /* If we were a member of this lockspace, left, and rejoined,
- other nodes may still be sending us messages from the
- lockspace generation before we left. */
- if (WARN_ON_ONCE(!ls->ls_generation)) {
- read_unlock_bh(&ls->ls_requestqueue_lock);
- log_limit(ls, "receive %d from %d ignore old gen",
- le32_to_cpu(ms->m_type), nodeid);
- return;
- }
+ r->res_first_lkid = lkb->lkb_id;
+ send_lookup(r, lkb);
+ return 1;
+}
- read_unlock_bh(&ls->ls_requestqueue_lock);
- write_lock_bh(&ls->ls_requestqueue_lock);
- /* recheck because we hold writelock now */
- if (!test_bit(LSFL_RECV_MSG_BLOCKED, &ls->ls_flags)) {
- write_unlock_bh(&ls->ls_requestqueue_lock);
- goto try_again;
- }
+static void process_lookup_list(struct dlm_rsb *r)
+{
+ struct dlm_lkb *lkb, *safe;
- dlm_add_requestqueue(ls, nodeid, ms);
- write_unlock_bh(&ls->ls_requestqueue_lock);
- } else {
- _receive_message(ls, ms, 0);
- read_unlock_bh(&ls->ls_requestqueue_lock);
+ list_for_each_entry_safe(lkb, safe, &r->res_lookup, lkb_rsb_lookup) {
+ list_del_init(&lkb->lkb_rsb_lookup);
+ _request_lock(r, lkb);
}
}
-/* This is called by dlm_recoverd to process messages that were saved on
- the requestqueue. */
+/* confirm_master -- confirm (or deny) an rsb's master nodeid */
-void dlm_receive_message_saved(struct dlm_ls *ls, const struct dlm_message *ms,
- uint32_t saved_seq)
+static void confirm_master(struct dlm_rsb *r, int error)
{
- _receive_message(ls, ms, saved_seq);
-}
-
-/* This is called by the midcomms layer when something is received for
- the lockspace. It could be either a MSG (normal message sent as part of
- standard locking activity) or an RCOM (recovery message sent as part of
- lockspace recovery). */
+ struct dlm_lkb *lkb;
-void dlm_receive_buffer(const union dlm_packet *p, int nodeid)
-{
- const struct dlm_header *hd = &p->header;
- struct dlm_ls *ls;
- int type = 0;
+ if (!r->res_first_lkid)
+ return;
- switch (hd->h_cmd) {
- case DLM_MSG:
- type = le32_to_cpu(p->message.m_type);
- break;
- case DLM_RCOM:
- type = le32_to_cpu(p->rcom.rc_type);
+ switch (error) {
+ case 0:
+ case -EINPROGRESS:
+ r->res_first_lkid = 0;
+ process_lookup_list(r);
break;
- default:
- log_print("invalid h_cmd %d from %u", hd->h_cmd, nodeid);
- return;
- }
- if (le32_to_cpu(hd->h_nodeid) != nodeid) {
- log_print("invalid h_nodeid %d from %d lockspace %x",
- le32_to_cpu(hd->h_nodeid), nodeid,
- le32_to_cpu(hd->u.h_lockspace));
- return;
- }
+ case -EAGAIN:
+ case -EBADR:
+ case -ENOTBLK:
+ /* the remote request failed and won't be retried (it was
+ a NOQUEUE, or has been canceled/unlocked); make a waiting
+ lkb the first_lkid */
+
+ r->res_first_lkid = 0;
- ls = dlm_find_lockspace_global(le32_to_cpu(hd->u.h_lockspace));
- if (!ls) {
- if (dlm_config.ci_log_debug) {
- printk_ratelimited(KERN_DEBUG "dlm: invalid lockspace "
- "%u from %d cmd %d type %d\n",
- le32_to_cpu(hd->u.h_lockspace), nodeid,
- hd->h_cmd, type);
+ if (!list_empty(&r->res_lookup)) {
+ lkb = list_entry(r->res_lookup.next, struct dlm_lkb,
+ lkb_rsb_lookup);
+ list_del_init(&lkb->lkb_rsb_lookup);
+ r->res_first_lkid = lkb->lkb_id;
+ _request_lock(r, lkb);
}
+ break;
- if (hd->h_cmd == DLM_RCOM && type == DLM_RCOM_STATUS)
- dlm_send_ls_not_ready(nodeid, &p->rcom);
- return;
+ default:
+ log_error(r->res_ls, "confirm_master unknown error %d", error);
}
-
- /* this rwsem allows dlm_ls_stop() to wait for all dlm_recv threads to
- be inactive (in this ls) before transitioning to recovery mode */
-
- read_lock_bh(&ls->ls_recv_active);
- if (hd->h_cmd == DLM_MSG)
- dlm_receive_message(ls, &p->message, nodeid);
- else if (hd->h_cmd == DLM_RCOM)
- dlm_receive_rcom(ls, &p->rcom, nodeid);
- else
- log_error(ls, "invalid h_cmd %d from %d lockspace %x",
- hd->h_cmd, nodeid, le32_to_cpu(hd->u.h_lockspace));
- read_unlock_bh(&ls->ls_recv_active);
-
- dlm_put_lockspace(ls);
}
-static void recover_convert_waiter(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_message *ms_local)
+static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
+ int namelen, void (*ast)(void *astparam),
+ void *astparam,
+ void (*bast)(void *astparam, int mode),
+ struct dlm_args *args)
{
- if (middle_conversion(lkb)) {
- log_rinfo(ls, "%s %x middle convert in progress", __func__,
- lkb->lkb_id);
-
- /* We sent this lock to the new master. The new master will
- * tell us when it's granted. We no longer need a reply, so
- * use a fake reply to put the lkb into the right state.
- */
- hold_lkb(lkb);
- memset(ms_local, 0, sizeof(struct dlm_message));
- ms_local->m_type = cpu_to_le32(DLM_MSG_CONVERT_REPLY);
- ms_local->m_result = cpu_to_le32(to_dlm_errno(-EINPROGRESS));
- ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
- _receive_convert_reply(lkb, ms_local, true);
- unhold_lkb(lkb);
-
- } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
- set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
- }
+ int rv = -EINVAL;
- /* lkb->lkb_rqmode < lkb->lkb_grmode shouldn't happen since down
- conversions are async; there's no reply from the remote master */
-}
+ /* check for invalid arg usage */
-/* A waiting lkb needs recovery if the master node has failed, or
- the master node is changing (only when no directory is used) */
+ if (mode < 0 || mode > DLM_LOCK_EX)
+ goto out;
-static int waiter_needs_recovery(struct dlm_ls *ls, struct dlm_lkb *lkb,
- int dir_nodeid)
-{
- if (dlm_no_directory(ls))
- return 1;
+ if (!(flags & DLM_LKF_CONVERT) && (namelen > DLM_RESNAME_MAXLEN))
+ goto out;
- if (dlm_is_removed(ls, lkb->lkb_wait_nodeid))
- return 1;
+ if (flags & DLM_LKF_CANCEL)
+ goto out;
- return 0;
-}
+ if (flags & DLM_LKF_QUECVT && !(flags & DLM_LKF_CONVERT))
+ goto out;
-/* Recovery for locks that are waiting for replies from nodes that are now
- gone. We can just complete unlocks and cancels by faking a reply from the
- dead node. Requests and up-conversions we flag to be resent after
- recovery. Down-conversions can just be completed with a fake reply like
- unlocks. Conversions between PR and CW need special attention. */
+ if (flags & DLM_LKF_CONVDEADLK && !(flags & DLM_LKF_CONVERT))
+ goto out;
-void dlm_recover_waiters_pre(struct dlm_ls *ls)
-{
- struct dlm_lkb *lkb, *safe;
- struct dlm_message *ms_local;
- int wait_type, local_unlock_result, local_cancel_result;
- int dir_nodeid;
+ if (flags & DLM_LKF_CONVDEADLK && flags & DLM_LKF_NOQUEUE)
+ goto out;
- ms_local = kmalloc(sizeof(*ms_local), GFP_KERNEL);
- if (!ms_local)
- return;
+ if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_CONVERT)
+ goto out;
- list_for_each_entry_safe(lkb, safe, &ls->ls_waiters, lkb_wait_reply) {
+ if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_QUECVT)
+ goto out;
- dir_nodeid = dlm_dir_nodeid(lkb->lkb_resource);
+ if (flags & DLM_LKF_EXPEDITE && flags & DLM_LKF_NOQUEUE)
+ goto out;
- /* exclude debug messages about unlocks because there can be so
- many and they aren't very interesting */
+ if (flags & DLM_LKF_EXPEDITE && mode != DLM_LOCK_NL)
+ goto out;
- if (lkb->lkb_wait_type != DLM_MSG_UNLOCK) {
- log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
- "lkb_nodeid %d wait_nodeid %d dir_nodeid %d",
- lkb->lkb_id,
- lkb->lkb_remid,
- lkb->lkb_wait_type,
- lkb->lkb_resource->res_nodeid,
- lkb->lkb_nodeid,
- lkb->lkb_wait_nodeid,
- dir_nodeid);
- }
+ if (!ast || !lksb)
+ goto out;
- /* all outstanding lookups, regardless of destination will be
- resent after recovery is done */
+ if (flags & DLM_LKF_VALBLK && !lksb->sb_lvbptr)
+ goto out;
- if (lkb->lkb_wait_type == DLM_MSG_LOOKUP) {
- set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
- continue;
- }
+ if (flags & DLM_LKF_CONVERT && !lksb->sb_lkid)
+ goto out;
- if (!waiter_needs_recovery(ls, lkb, dir_nodeid))
- continue;
+ /* these args will be copied to the lkb in validate_lock_args,
+ it cannot be done now because when converting locks, fields in
+ an active lkb cannot be modified before locking the rsb */
- wait_type = lkb->lkb_wait_type;
- local_unlock_result = -DLM_EUNLOCK;
- local_cancel_result = -DLM_ECANCEL;
+ args->flags = flags;
+ args->astfn = ast;
+ args->astparam = astparam;
+ args->bastfn = bast;
+ args->mode = mode;
+ args->lksb = lksb;
+ rv = 0;
+ out:
+ return rv;
+}
- /* Main reply may have been received leaving a zero wait_type,
- but a reply for the overlapping op may not have been
- received. In that case we need to fake the appropriate
- reply for the overlap op. */
+static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
+{
+ if (flags & ~(DLM_LKF_CANCEL | DLM_LKF_VALBLK | DLM_LKF_IVVALBLK |
+ DLM_LKF_FORCEUNLOCK))
+ return -EINVAL;
- if (!wait_type) {
- if (is_overlap_cancel(lkb)) {
- wait_type = DLM_MSG_CANCEL;
- if (lkb->lkb_grmode == DLM_LOCK_IV)
- local_cancel_result = 0;
- }
- if (is_overlap_unlock(lkb)) {
- wait_type = DLM_MSG_UNLOCK;
- if (lkb->lkb_grmode == DLM_LOCK_IV)
- local_unlock_result = -ENOENT;
- }
+ if (flags & DLM_LKF_CANCEL && flags & DLM_LKF_FORCEUNLOCK)
+ return -EINVAL;
- log_debug(ls, "rwpre overlap %x %x %d %d %d",
- lkb->lkb_id, dlm_iflags_val(lkb), wait_type,
- local_cancel_result, local_unlock_result);
- }
+ args->flags = flags;
+ args->astparam = astarg;
+ return 0;
+}
- switch (wait_type) {
+static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ struct dlm_args *args)
+{
+ int rv = -EBUSY;
- case DLM_MSG_REQUEST:
- set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
- break;
+ if (args->flags & DLM_LKF_CONVERT) {
+ if (lkb->lkb_status != DLM_LKSTS_GRANTED)
+ goto out;
- case DLM_MSG_CONVERT:
- recover_convert_waiter(ls, lkb, ms_local);
- break;
+ /* lock not allowed if there's any op in progress */
+ if (lkb->lkb_wait_type || lkb->lkb_wait_count)
+ goto out;
- case DLM_MSG_UNLOCK:
- hold_lkb(lkb);
- memset(ms_local, 0, sizeof(struct dlm_message));
- ms_local->m_type = cpu_to_le32(DLM_MSG_UNLOCK_REPLY);
- ms_local->m_result = cpu_to_le32(to_dlm_errno(local_unlock_result));
- ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
- _receive_unlock_reply(lkb, ms_local, true);
- dlm_put_lkb(lkb);
- break;
+ if (is_overlap(lkb))
+ goto out;
- case DLM_MSG_CANCEL:
- hold_lkb(lkb);
- memset(ms_local, 0, sizeof(struct dlm_message));
- ms_local->m_type = cpu_to_le32(DLM_MSG_CANCEL_REPLY);
- ms_local->m_result = cpu_to_le32(to_dlm_errno(local_cancel_result));
- ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
- _receive_cancel_reply(lkb, ms_local, true);
- dlm_put_lkb(lkb);
- break;
+ rv = -EINVAL;
+ if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags))
+ goto out;
- default:
- log_error(ls, "invalid lkb wait_type %d %d",
- lkb->lkb_wait_type, wait_type);
- }
- schedule();
+ if (args->flags & DLM_LKF_QUECVT &&
+ !__quecvt_compat_matrix[lkb->lkb_grmode+1][args->mode+1])
+ goto out;
}
- kfree(ms_local);
-}
-
-static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
-{
- struct dlm_lkb *lkb = NULL, *iter;
- spin_lock_bh(&ls->ls_waiters_lock);
- list_for_each_entry(iter, &ls->ls_waiters, lkb_wait_reply) {
- if (test_bit(DLM_IFL_RESEND_BIT, &iter->lkb_iflags)) {
- hold_lkb(iter);
- lkb = iter;
- break;
- }
+ lkb->lkb_exflags = args->flags;
+ dlm_set_sbflags_val(lkb, 0);
+ lkb->lkb_astfn = args->astfn;
+ lkb->lkb_astparam = args->astparam;
+ lkb->lkb_bastfn = args->bastfn;
+ lkb->lkb_rqmode = args->mode;
+ lkb->lkb_lksb = args->lksb;
+ lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
+ lkb->lkb_ownpid = (int) current->pid;
+ rv = 0;
+ out:
+ switch (rv) {
+ case 0:
+ break;
+ case -EINVAL:
+ /* annoy the user because dlm usage is wrong */
+ WARN_ON(1);
+ log_error(ls, "%s %d %x %x %x %d %d", __func__,
+ rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
+ lkb->lkb_status, lkb->lkb_wait_type);
+ break;
+ default:
+ log_debug(ls, "%s %d %x %x %x %d %d", __func__,
+ rv, lkb->lkb_id, dlm_iflags_val(lkb), args->flags,
+ lkb->lkb_status, lkb->lkb_wait_type);
+ break;
}
- spin_unlock_bh(&ls->ls_waiters_lock);
- return lkb;
+ return rv;
}
-/*
- * Forced state reset for locks that were in the middle of remote operations
- * when recovery happened (i.e. lkbs that were on the waiters list, waiting
- * for a reply from a remote operation.) The lkbs remaining on the waiters
- * list need to be reevaluated; some may need resending to a different node
- * than previously, and some may now need local handling rather than remote.
- *
- * First, the lkb state for the voided remote operation is forcibly reset,
- * equivalent to what remove_from_waiters() would normally do:
- * . lkb removed from ls_waiters list
- * . lkb wait_type cleared
- * . lkb waiters_count cleared
- * . lkb ref count decremented for each waiters_count (almost always 1,
- * but possibly 2 in case of cancel/unlock overlapping, which means
- * two remote replies were being expected for the lkb.)
- *
- * Second, the lkb is reprocessed like an original operation would be,
- * by passing it to _request_lock or _convert_lock, which will either
- * process the lkb operation locally, or send it to a remote node again
- * and put the lkb back onto the waiters list.
- *
- * When reprocessing the lkb, we may find that it's flagged for an overlapping
- * force-unlock or cancel, either from before recovery began, or after recovery
- * finished. If this is the case, the unlock/cancel is done directly, and the
- * original operation is not initiated again (no _request_lock/_convert_lock.)
- */
+/* when dlm_unlock() sees -EBUSY with CANCEL/FORCEUNLOCK it returns 0
+ for success */
-int dlm_recover_waiters_post(struct dlm_ls *ls)
+/* note: it's valid for lkb_nodeid/res_nodeid to be -1 when we get here
+ because there may be a lookup in progress and it's valid to do
+ cancel/unlockf on it */
+
+static int validate_unlock_args(struct dlm_lkb *lkb, struct dlm_args *args)
{
- struct dlm_lkb *lkb;
- struct dlm_rsb *r;
- int error = 0, mstype, err, oc, ou;
+ struct dlm_ls *ls = lkb->lkb_resource->res_ls;
+ int rv = -EBUSY;
- while (1) {
- if (dlm_locking_stopped(ls)) {
- log_debug(ls, "recover_waiters_post aborted");
- error = -EINTR;
- break;
+ /* normal unlock not allowed if there's any op in progress */
+ if (!(args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) &&
+ (lkb->lkb_wait_type || lkb->lkb_wait_count))
+ goto out;
+
+ /* an lkb may be waiting for an rsb lookup to complete where the
+ lookup was initiated by another lock */
+
+ if (!list_empty(&lkb->lkb_rsb_lookup)) {
+ if (args->flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)) {
+ log_debug(ls, "unlock on rsb_lookup %x", lkb->lkb_id);
+ list_del_init(&lkb->lkb_rsb_lookup);
+ queue_cast(lkb->lkb_resource, lkb,
+ args->flags & DLM_LKF_CANCEL ?
+ -DLM_ECANCEL : -DLM_EUNLOCK);
+ unhold_lkb(lkb); /* undoes create_lkb() */
}
+ /* caller changes -EBUSY to 0 for CANCEL and FORCEUNLOCK */
+ goto out;
+ }
- /*
- * Find an lkb from the waiters list that's been affected by
- * recovery node changes, and needs to be reprocessed. Does
- * hold_lkb(), adding a refcount.
- */
- lkb = find_resend_waiter(ls);
- if (!lkb)
- break;
+ rv = -EINVAL;
+ if (test_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags)) {
+ log_error(ls, "unlock on MSTCPY %x", lkb->lkb_id);
+ dlm_print_lkb(lkb);
+ goto out;
+ }
- r = lkb->lkb_resource;
- hold_rsb(r);
- lock_rsb(r);
+ /* an lkb may still exist even though the lock is EOL'ed due to a
+ * cancel, unlock or failed noqueue request; an app can't use these
+ * locks; return same error as if the lkid had not been found at all
+ */
- /*
- * If the lkb has been flagged for a force unlock or cancel,
- * then the reprocessing below will be replaced by just doing
- * the unlock/cancel directly.
- */
- mstype = lkb->lkb_wait_type;
- oc = test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT,
- &lkb->lkb_iflags);
- ou = test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT,
- &lkb->lkb_iflags);
- err = 0;
+ if (test_bit(DLM_IFL_ENDOFLIFE_BIT, &lkb->lkb_iflags)) {
+ log_debug(ls, "unlock on ENDOFLIFE %x", lkb->lkb_id);
+ rv = -ENOENT;
+ goto out;
+ }
- log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
- "lkb_nodeid %d wait_nodeid %d dir_nodeid %d "
- "overlap %d %d", lkb->lkb_id, lkb->lkb_remid, mstype,
- r->res_nodeid, lkb->lkb_nodeid, lkb->lkb_wait_nodeid,
- dlm_dir_nodeid(r), oc, ou);
+ if (is_overlap_unlock(lkb))
+ goto out;
- /*
- * No reply to the pre-recovery operation will now be received,
- * so a forced equivalent of remove_from_waiters() is needed to
- * reset the waiters state that was in place before recovery.
- */
+ /* cancel not allowed with another cancel/unlock in progress */
- clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
+ if (args->flags & DLM_LKF_CANCEL) {
+ if (lkb->lkb_exflags & DLM_LKF_CANCEL)
+ goto out;
- /* Forcibly clear wait_type */
- lkb->lkb_wait_type = 0;
+ if (is_overlap_cancel(lkb))
+ goto out;
- /*
- * Forcibly reset wait_count and associated refcount. The
- * wait_count will almost always be 1, but in case of an
- * overlapping unlock/cancel it could be 2: see where
- * add_to_waiters() finds the lkb is already on the waiters
- * list and does lkb_wait_count++; hold_lkb().
- */
- while (lkb->lkb_wait_count) {
- lkb->lkb_wait_count--;
- unhold_lkb(lkb);
+ if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
+ set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
+ rv = -EBUSY;
+ goto out;
+ }
+
+ /* there's nothing to cancel */
+ if (lkb->lkb_status == DLM_LKSTS_GRANTED &&
+ !lkb->lkb_wait_type) {
+ rv = -EBUSY;
+ goto out;
+ }
+
+ switch (lkb->lkb_wait_type) {
+ case DLM_MSG_LOOKUP:
+ case DLM_MSG_REQUEST:
+ set_bit(DLM_IFL_OVERLAP_CANCEL_BIT, &lkb->lkb_iflags);
+ rv = -EBUSY;
+ goto out;
+ case DLM_MSG_UNLOCK:
+ case DLM_MSG_CANCEL:
+ goto out;
}
+ /* add_to_waiters() will set OVERLAP_CANCEL */
+ goto out_ok;
+ }
- /* Forcibly remove from waiters list */
- spin_lock_bh(&ls->ls_waiters_lock);
- list_del_init(&lkb->lkb_wait_reply);
- spin_unlock_bh(&ls->ls_waiters_lock);
+ /* do we need to allow a force-unlock if there's a normal unlock
+ already in progress? in what conditions could the normal unlock
+ fail such that we'd want to send a force-unlock to be sure? */
- /*
- * The lkb is now clear of all prior waiters state and can be
- * processed locally, or sent to remote node again, or directly
- * cancelled/unlocked.
- */
+ if (args->flags & DLM_LKF_FORCEUNLOCK) {
+ if (lkb->lkb_exflags & DLM_LKF_FORCEUNLOCK)
+ goto out;
- if (oc || ou) {
- /* do an unlock or cancel instead of resending */
- switch (mstype) {
- case DLM_MSG_LOOKUP:
- case DLM_MSG_REQUEST:
- queue_cast(r, lkb, ou ? -DLM_EUNLOCK :
- -DLM_ECANCEL);
- unhold_lkb(lkb); /* undoes create_lkb() */
- break;
- case DLM_MSG_CONVERT:
- if (oc) {
- queue_cast(r, lkb, -DLM_ECANCEL);
- } else {
- lkb->lkb_exflags |= DLM_LKF_FORCEUNLOCK;
- _unlock_lock(r, lkb);
- }
- break;
- default:
- err = 1;
- }
- } else {
- switch (mstype) {
- case DLM_MSG_LOOKUP:
- case DLM_MSG_REQUEST:
- _request_lock(r, lkb);
- if (r->res_nodeid != -1 && is_master(r))
- confirm_master(r, 0);
- break;
- case DLM_MSG_CONVERT:
- _convert_lock(r, lkb);
- break;
- default:
- err = 1;
- }
+ if (test_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags)) {
+ set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
+ rv = -EBUSY;
+ goto out;
}
- if (err) {
- log_error(ls, "waiter %x msg %d r_nodeid %d "
- "dir_nodeid %d overlap %d %d",
- lkb->lkb_id, mstype, r->res_nodeid,
- dlm_dir_nodeid(r), oc, ou);
+ switch (lkb->lkb_wait_type) {
+ case DLM_MSG_LOOKUP:
+ case DLM_MSG_REQUEST:
+ set_bit(DLM_IFL_OVERLAP_UNLOCK_BIT, &lkb->lkb_iflags);
+ rv = -EBUSY;
+ goto out;
+ case DLM_MSG_UNLOCK:
+ goto out;
}
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
+ /* add_to_waiters() will set OVERLAP_UNLOCK */
}
- return error;
-}
-
-static void purge_mstcpy_list(struct dlm_ls *ls, struct dlm_rsb *r,
- struct list_head *list)
-{
- struct dlm_lkb *lkb, *safe;
+ out_ok:
+ /* an overlapping op shouldn't blow away exflags from other op */
+ lkb->lkb_exflags |= args->flags;
+ dlm_set_sbflags_val(lkb, 0);
+ lkb->lkb_astparam = args->astparam;
+ rv = 0;
+ out:
+ switch (rv) {
+ case 0:
+ break;
+ case -EINVAL:
+ /* annoy the user because dlm usage is wrong */
+ WARN_ON(1);
+ log_error(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
+ lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
+ args->flags, lkb->lkb_wait_type,
+ lkb->lkb_resource->res_name);
+ break;
+ default:
+ log_debug(ls, "%s %d %x %x %x %x %d %s", __func__, rv,
+ lkb->lkb_id, dlm_iflags_val(lkb), lkb->lkb_exflags,
+ args->flags, lkb->lkb_wait_type,
+ lkb->lkb_resource->res_name);
+ break;
+ }
- list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
- if (!is_master_copy(lkb))
- continue;
+ return rv;
+}
- /* don't purge lkbs we've added in recover_master_copy for
- the current recovery seq */
+/*
+ * Four stage 4 varieties:
+ * do_request(), do_convert(), do_unlock(), do_cancel()
+ * These are called on the master node for the given lock and
+ * from the central locking logic.
+ */
- if (lkb->lkb_recover_seq == ls->ls_recover_seq)
- continue;
+static int do_request(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int error = 0;
- del_lkb(r, lkb);
+ if (can_be_granted(r, lkb, 1, 0, NULL)) {
+ grant_lock(r, lkb);
+ queue_cast(r, lkb, 0);
+ goto out;
+ }
- /* this put should free the lkb */
- if (!dlm_put_lkb(lkb))
- log_error(ls, "purged mstcpy lkb not released");
+ if (can_be_queued(lkb)) {
+ error = -EINPROGRESS;
+ add_lkb(r, lkb, DLM_LKSTS_WAITING);
+ goto out;
}
+
+ error = -EAGAIN;
+ queue_cast(r, lkb, -EAGAIN);
+ out:
+ return error;
}
-void dlm_purge_mstcpy_locks(struct dlm_rsb *r)
+static void do_request_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ int error)
{
- struct dlm_ls *ls = r->res_ls;
-
- purge_mstcpy_list(ls, r, &r->res_grantqueue);
- purge_mstcpy_list(ls, r, &r->res_convertqueue);
- purge_mstcpy_list(ls, r, &r->res_waitqueue);
+ switch (error) {
+ case -EAGAIN:
+ if (force_blocking_asts(lkb))
+ send_blocking_asts_all(r, lkb);
+ break;
+ case -EINPROGRESS:
+ send_blocking_asts(r, lkb);
+ break;
+ }
}
-static void purge_dead_list(struct dlm_ls *ls, struct dlm_rsb *r,
- struct list_head *list,
- int nodeid_gone, unsigned int *count)
+static int do_convert(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- struct dlm_lkb *lkb, *safe;
-
- list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
- if (!is_master_copy(lkb))
- continue;
+ int error = 0;
+ int deadlk = 0;
- if ((lkb->lkb_nodeid == nodeid_gone) ||
- dlm_is_removed(ls, lkb->lkb_nodeid)) {
+ /* changing an existing lock may allow others to be granted */
- /* tell recover_lvb to invalidate the lvb
- because a node holding EX/PW failed */
- if ((lkb->lkb_exflags & DLM_LKF_VALBLK) &&
- (lkb->lkb_grmode >= DLM_LOCK_PW)) {
- rsb_set_flag(r, RSB_RECOVER_LVB_INVAL);
- }
+ if (can_be_granted(r, lkb, 1, 0, &deadlk)) {
+ grant_lock(r, lkb);
+ queue_cast(r, lkb, 0);
+ goto out;
+ }
- del_lkb(r, lkb);
+ /* can_be_granted() detected that this lock would block in a conversion
+ deadlock, so we leave it on the granted queue and return EDEADLK in
+ the ast for the convert. */
- /* this put should free the lkb */
- if (!dlm_put_lkb(lkb))
- log_error(ls, "purged dead lkb not released");
+ if (deadlk && !(lkb->lkb_exflags & DLM_LKF_NODLCKWT)) {
+ /* it's left on the granted queue */
+ revert_lock(r, lkb);
+ queue_cast(r, lkb, -EDEADLK);
+ error = -EDEADLK;
+ goto out;
+ }
- rsb_set_flag(r, RSB_RECOVER_GRANT);
+ /* is_demoted() means the can_be_granted() above set the grmode
+ to NL, and left us on the granted queue. This auto-demotion
+ (due to CONVDEADLK) might mean other locks, and/or this lock, are
+ now grantable. We have to try to grant other converting locks
+ before we try again to grant this one. */
- (*count)++;
+ if (is_demoted(lkb)) {
+ grant_pending_convert(r, DLM_LOCK_IV, NULL, NULL);
+ if (_can_be_granted(r, lkb, 1, 0)) {
+ grant_lock(r, lkb);
+ queue_cast(r, lkb, 0);
+ goto out;
}
+ /* else fall through and move to convert queue */
}
-}
-/* Get rid of locks held by nodes that are gone. */
+ if (can_be_queued(lkb)) {
+ error = -EINPROGRESS;
+ del_lkb(r, lkb);
+ add_lkb(r, lkb, DLM_LKSTS_CONVERT);
+ goto out;
+ }
-void dlm_recover_purge(struct dlm_ls *ls, const struct list_head *root_list)
+ error = -EAGAIN;
+ queue_cast(r, lkb, -EAGAIN);
+ out:
+ return error;
+}
+
+static void do_convert_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ int error)
{
- struct dlm_rsb *r;
- struct dlm_member *memb;
- int nodes_count = 0;
- int nodeid_gone = 0;
- unsigned int lkb_count = 0;
+ switch (error) {
+ case 0:
+ grant_pending_locks(r, NULL);
+ /* grant_pending_locks also sends basts */
+ break;
+ case -EAGAIN:
+ if (force_blocking_asts(lkb))
+ send_blocking_asts_all(r, lkb);
+ break;
+ case -EINPROGRESS:
+ send_blocking_asts(r, lkb);
+ break;
+ }
+}
- /* cache one removed nodeid to optimize the common
- case of a single node removed */
+static int do_unlock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ remove_lock(r, lkb);
+ queue_cast(r, lkb, -DLM_EUNLOCK);
+ return -DLM_EUNLOCK;
+}
- list_for_each_entry(memb, &ls->ls_nodes_gone, list) {
- nodes_count++;
- nodeid_gone = memb->nodeid;
- }
+static void do_unlock_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ int error)
+{
+ grant_pending_locks(r, NULL);
+}
- if (!nodes_count)
- return;
+/* returns: 0 did nothing, -DLM_ECANCEL canceled lock */
- list_for_each_entry(r, root_list, res_root_list) {
- lock_rsb(r);
- if (r->res_nodeid != -1 && is_master(r)) {
- purge_dead_list(ls, r, &r->res_grantqueue,
- nodeid_gone, &lkb_count);
- purge_dead_list(ls, r, &r->res_convertqueue,
- nodeid_gone, &lkb_count);
- purge_dead_list(ls, r, &r->res_waitqueue,
- nodeid_gone, &lkb_count);
- }
- unlock_rsb(r);
+static int do_cancel(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int error;
- cond_resched();
+ error = revert_lock(r, lkb);
+ if (error) {
+ queue_cast(r, lkb, -DLM_ECANCEL);
+ return -DLM_ECANCEL;
}
-
- if (lkb_count)
- log_rinfo(ls, "dlm_recover_purge %u locks for %u nodes",
- lkb_count, nodes_count);
+ return 0;
}
-static struct dlm_rsb *find_grant_rsb(struct dlm_ls *ls)
+static void do_cancel_effects(struct dlm_rsb *r, struct dlm_lkb *lkb,
+ int error)
{
- struct dlm_rsb *r;
-
- read_lock_bh(&ls->ls_rsbtbl_lock);
- list_for_each_entry(r, &ls->ls_slow_active, res_slow_list) {
- if (!rsb_flag(r, RSB_RECOVER_GRANT))
- continue;
- if (!is_master(r)) {
- rsb_clear_flag(r, RSB_RECOVER_GRANT);
- continue;
- }
- hold_rsb(r);
- read_unlock_bh(&ls->ls_rsbtbl_lock);
- return r;
- }
- read_unlock_bh(&ls->ls_rsbtbl_lock);
- return NULL;
+ if (error)
+ grant_pending_locks(r, NULL);
}
/*
- * Attempt to grant locks on resources that we are the master of.
- * Locks may have become grantable during recovery because locks
- * from departed nodes have been purged (or not rebuilt), allowing
- * previously blocked locks to now be granted. The subset of rsb's
- * we are interested in are those with lkb's on either the convert or
- * waiting queues.
- *
- * Simplest would be to go through each master rsb and check for non-empty
- * convert or waiting queues, and attempt to grant on those rsbs.
- * Checking the queues requires lock_rsb, though, for which we'd need
- * to release the rsbtbl lock. This would make iterating through all
- * rsb's very inefficient. So, we rely on earlier recovery routines
- * to set RECOVER_GRANT on any rsb's that we should attempt to grant
- * locks for.
+ * Four stage 3 varieties:
+ * _request_lock(), _convert_lock(), _unlock_lock(), _cancel_lock()
*/
-void dlm_recover_grant(struct dlm_ls *ls)
+/* add a new lkb to a possibly new rsb, called by requesting process */
+
+static int _request_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- struct dlm_rsb *r;
- unsigned int count = 0;
- unsigned int rsb_count = 0;
- unsigned int lkb_count = 0;
+ int error;
- while (1) {
- r = find_grant_rsb(ls);
- if (!r)
- break;
+ /* set_master: sets lkb nodeid from r */
- rsb_count++;
- count = 0;
- lock_rsb(r);
- /* the RECOVER_GRANT flag is checked in the grant path */
- grant_pending_locks(r, &count);
- rsb_clear_flag(r, RSB_RECOVER_GRANT);
- lkb_count += count;
- confirm_master(r, 0);
- unlock_rsb(r);
- put_rsb(r);
- cond_resched();
+ error = set_master(r, lkb);
+ if (error < 0)
+ goto out;
+ if (error) {
+ error = 0;
+ goto out;
}
- if (lkb_count)
- log_rinfo(ls, "dlm_recover_grant %u locks on %u resources",
- lkb_count, rsb_count);
+ if (is_remote(r)) {
+ /* receive_request() calls do_request() on remote node */
+ error = send_request(r, lkb);
+ } else {
+ error = do_request(r, lkb);
+ /* for remote locks the request_reply is sent
+ between do_request and do_request_effects */
+ do_request_effects(r, lkb, error);
+ }
+ out:
+ return error;
}
-static struct dlm_lkb *search_remid_list(struct list_head *head, int nodeid,
- uint32_t remid)
+/* change some property of an existing lkb, e.g. mode */
+
+static int _convert_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- struct dlm_lkb *lkb;
+ int error;
- list_for_each_entry(lkb, head, lkb_statequeue) {
- if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid)
- return lkb;
+ if (is_remote(r)) {
+ /* receive_convert() calls do_convert() on remote node */
+ error = send_convert(r, lkb);
+ } else {
+ error = do_convert(r, lkb);
+ /* for remote locks the convert_reply is sent
+ between do_convert and do_convert_effects */
+ do_convert_effects(r, lkb, error);
}
- return NULL;
-}
-
-static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
- uint32_t remid)
-{
- struct dlm_lkb *lkb;
- lkb = search_remid_list(&r->res_grantqueue, nodeid, remid);
- if (lkb)
- return lkb;
- lkb = search_remid_list(&r->res_convertqueue, nodeid, remid);
- if (lkb)
- return lkb;
- lkb = search_remid_list(&r->res_waitqueue, nodeid, remid);
- if (lkb)
- return lkb;
- return NULL;
+ return error;
}
-/* needs at least dlm_rcom + rcom_lock */
-static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
- struct dlm_rsb *r, const struct dlm_rcom *rc)
+/* remove an existing lkb from the granted queue */
+
+static int _unlock_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
{
- struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
+ int error;
- lkb->lkb_nodeid = le32_to_cpu(rc->rc_header.h_nodeid);
- lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
- lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
- lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
- dlm_set_dflags_val(lkb, le32_to_cpu(rl->rl_flags));
- set_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
- lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
- lkb->lkb_rqmode = rl->rl_rqmode;
- lkb->lkb_grmode = rl->rl_grmode;
- /* don't set lkb_status because add_lkb wants to itself */
+ if (is_remote(r)) {
+ /* receive_unlock() calls do_unlock() on remote node */
+ error = send_unlock(r, lkb);
+ } else {
+ error = do_unlock(r, lkb);
+ /* for remote locks the unlock_reply is sent
+ between do_unlock and do_unlock_effects */
+ do_unlock_effects(r, lkb, error);
+ }
- lkb->lkb_bastfn = (rl->rl_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
- lkb->lkb_astfn = (rl->rl_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
+ return error;
+}
- if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
- int lvblen = le16_to_cpu(rc->rc_header.h_length) -
- sizeof(struct dlm_rcom) - sizeof(struct rcom_lock);
- if (lvblen > ls->ls_lvblen)
- return -EINVAL;
- lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
- if (!lkb->lkb_lvbptr)
- return -ENOMEM;
- memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
- }
+/* remove an existing lkb from the convert or wait queue */
- /* Conversions between PR and CW (middle modes) need special handling.
- The real granted mode of these converting locks cannot be determined
- until all locks have been rebuilt on the rsb (recover_conversion) */
+static int _cancel_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
+{
+ int error;
- if (rl->rl_status == DLM_LKSTS_CONVERT && middle_conversion(lkb)) {
- /* We may need to adjust grmode depending on other granted locks. */
- log_limit(ls, "%s %x middle convert gr %d rq %d remote %d %x",
- __func__, lkb->lkb_id, lkb->lkb_grmode,
- lkb->lkb_rqmode, lkb->lkb_nodeid, lkb->lkb_remid);
- rsb_set_flag(r, RSB_RECOVER_CONVERT);
+ if (is_remote(r)) {
+ /* receive_cancel() calls do_cancel() on remote node */
+ error = send_cancel(r, lkb);
+ } else {
+ error = do_cancel(r, lkb);
+ /* for remote locks the cancel_reply is sent
+ between do_cancel and do_cancel_effects */
+ do_cancel_effects(r, lkb, error);
}
- return 0;
+ return error;
}
-/* This lkb may have been recovered in a previous aborted recovery so we need
- to check if the rsb already has an lkb with the given remote nodeid/lkid.
- If so we just send back a standard reply. If not, we create a new lkb with
- the given values and send back our lkid. We send back our lkid by sending
- back the rcom_lock struct we got but with the remid field filled in. */
+/*
+ * Four stage 2 varieties:
+ * request_lock(), convert_lock(), unlock_lock(), cancel_lock()
+ */
-/* needs at least dlm_rcom + rcom_lock */
-int dlm_recover_master_copy(struct dlm_ls *ls, const struct dlm_rcom *rc,
- __le32 *rl_remid, __le32 *rl_result)
+static int request_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ const void *name, int len,
+ struct dlm_args *args)
{
- struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
struct dlm_rsb *r;
- struct dlm_lkb *lkb;
- uint32_t remid = 0;
- int from_nodeid = le32_to_cpu(rc->rc_header.h_nodeid);
int error;
- /* init rl_remid with rcom lock rl_remid */
- *rl_remid = rl->rl_remid;
+ error = validate_lock_args(ls, lkb, args);
+ if (error)
+ return error;
- if (rl->rl_parent_lkid) {
- error = -EOPNOTSUPP;
- goto out;
- }
+ error = find_rsb(ls, name, len, 0, R_REQUEST, &r);
+ if (error)
+ return error;
+
+ lock_rsb(r);
+
+ attach_lkb(r, lkb);
+ lkb->lkb_lksb->sb_lkid = lkb->lkb_id;
+
+ error = _request_lock(r, lkb);
- remid = le32_to_cpu(rl->rl_lkid);
+ unlock_rsb(r);
+ put_rsb(r);
+ return error;
+}
- /* In general we expect the rsb returned to be R_MASTER, but we don't
- have to require it. Recovery of masters on one node can overlap
- recovery of locks on another node, so one node can send us MSTCPY
- locks before we've made ourselves master of this rsb. We can still
- add new MSTCPY locks that we receive here without any harm; when
- we make ourselves master, dlm_recover_masters() won't touch the
- MSTCPY locks we've received early. */
+static int convert_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ struct dlm_args *args)
+{
+ struct dlm_rsb *r;
+ int error;
- error = find_rsb(ls, rl->rl_name, le16_to_cpu(rl->rl_namelen),
- from_nodeid, R_RECEIVE_RECOVER, &r);
- if (error)
- goto out;
+ r = lkb->lkb_resource;
+ hold_rsb(r);
lock_rsb(r);
- if (dlm_no_directory(ls) && (dlm_dir_nodeid(r) != dlm_our_nodeid())) {
- log_error(ls, "dlm_recover_master_copy remote %d %x not dir",
- from_nodeid, remid);
- error = -EBADR;
- goto out_unlock;
- }
-
- lkb = search_remid(r, from_nodeid, remid);
- if (lkb) {
- error = -EEXIST;
- goto out_remid;
- }
-
- error = create_lkb(ls, &lkb);
+ error = validate_lock_args(ls, lkb, args);
if (error)
- goto out_unlock;
+ goto out;
- error = receive_rcom_lock_args(ls, lkb, r, rc);
- if (error) {
- __put_lkb(ls, lkb);
- goto out_unlock;
- }
+ error = _convert_lock(r, lkb);
+ out:
+ unlock_rsb(r);
+ put_rsb(r);
+ return error;
+}
- attach_lkb(r, lkb);
- add_lkb(r, lkb, rl->rl_status);
- ls->ls_recover_locks_in++;
+static int unlock_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ struct dlm_args *args)
+{
+ struct dlm_rsb *r;
+ int error;
- if (!list_empty(&r->res_waitqueue) || !list_empty(&r->res_convertqueue))
- rsb_set_flag(r, RSB_RECOVER_GRANT);
+ r = lkb->lkb_resource;
- out_remid:
- /* this is the new value returned to the lock holder for
- saving in its process-copy lkb */
- *rl_remid = cpu_to_le32(lkb->lkb_id);
+ hold_rsb(r);
+ lock_rsb(r);
- lkb->lkb_recover_seq = ls->ls_recover_seq;
+ error = validate_unlock_args(lkb, args);
+ if (error)
+ goto out;
- out_unlock:
+ error = _unlock_lock(r, lkb);
+ out:
unlock_rsb(r);
put_rsb(r);
- out:
- if (error && error != -EEXIST)
- log_rinfo(ls, "dlm_recover_master_copy remote %d %x error %d",
- from_nodeid, remid, error);
- *rl_result = cpu_to_le32(error);
return error;
}
-/* needs at least dlm_rcom + rcom_lock */
-int dlm_recover_process_copy(struct dlm_ls *ls, const struct dlm_rcom *rc,
- uint64_t seq)
+static int cancel_lock(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ struct dlm_args *args)
{
- struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
struct dlm_rsb *r;
- struct dlm_lkb *lkb;
- uint32_t lkid, remid;
- int error, result;
-
- lkid = le32_to_cpu(rl->rl_lkid);
- remid = le32_to_cpu(rl->rl_remid);
- result = le32_to_cpu(rl->rl_result);
-
- error = find_lkb(ls, lkid, &lkb);
- if (error) {
- log_error(ls, "dlm_recover_process_copy no %x remote %d %x %d",
- lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
- result);
- return error;
- }
+ int error;
r = lkb->lkb_resource;
+
hold_rsb(r);
lock_rsb(r);
- if (!is_process_copy(lkb)) {
- log_error(ls, "dlm_recover_process_copy bad %x remote %d %x %d",
- lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
- result);
- dlm_dump_rsb(r);
- unlock_rsb(r);
- put_rsb(r);
- dlm_put_lkb(lkb);
- return -EINVAL;
- }
-
- switch (result) {
- case -EBADR:
- /* There's a chance the new master received our lock before
- dlm_recover_master_reply(), this wouldn't happen if we did
- a barrier between recover_masters and recover_locks. */
-
- log_debug(ls, "dlm_recover_process_copy %x remote %d %x %d",
- lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
- result);
-
- dlm_send_rcom_lock(r, lkb, seq);
+ error = validate_unlock_args(lkb, args);
+ if (error)
goto out;
- case -EEXIST:
- case 0:
- lkb->lkb_remid = remid;
- break;
- default:
- log_error(ls, "dlm_recover_process_copy %x remote %d %x %d unk",
- lkid, le32_to_cpu(rc->rc_header.h_nodeid), remid,
- result);
- }
- /* an ack for dlm_recover_locks() which waits for replies from
- all the locks it sends to new masters */
- dlm_recovered_lock(r);
+ error = _cancel_lock(r, lkb);
out:
unlock_rsb(r);
put_rsb(r);
- dlm_put_lkb(lkb);
-
- return 0;
+ return error;
}
-int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,
- int mode, uint32_t flags, void *name, unsigned int namelen)
+/*
+ * Two stage 1 varieties: dlm_lock() and dlm_unlock()
+ */
+
+int dlm_lock(dlm_lockspace_t *lockspace,
+ int mode,
+ struct dlm_lksb *lksb,
+ uint32_t flags,
+ const void *name,
+ unsigned int namelen,
+ uint32_t parent_lkid,
+ void (*ast) (void *astarg),
+ void *astarg,
+ void (*bast) (void *astarg, int mode))
{
+ struct dlm_ls *ls;
struct dlm_lkb *lkb;
struct dlm_args args;
- bool do_put = true;
- int error;
+ int error, convert = flags & DLM_LKF_CONVERT;
+
+ ls = dlm_find_lockspace_local(lockspace);
+ if (!ls)
+ return -EINVAL;
dlm_lock_recovery(ls);
- error = create_lkb(ls, &lkb);
- if (error) {
- kfree(ua);
+ if (convert)
+ error = find_lkb(ls, lksb->sb_lkid, &lkb);
+ else
+ error = create_lkb(ls, &lkb);
+
+ if (error)
goto out;
- }
trace_dlm_lock_start(ls, lkb, name, namelen, mode, flags);
- if (flags & DLM_LKF_VALBLK) {
- ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
- if (!ua->lksb.sb_lvbptr) {
- kfree(ua);
- error = -ENOMEM;
- goto out_put;
- }
- }
- error = set_lock_args(mode, &ua->lksb, flags, namelen, fake_astfn, ua,
- fake_bastfn, &args);
- if (error) {
- kfree(ua->lksb.sb_lvbptr);
- ua->lksb.sb_lvbptr = NULL;
- kfree(ua);
+ error = set_lock_args(mode, lksb, flags, namelen, ast, astarg, bast,
+ &args);
+ if (error)
goto out_put;
- }
- /* After ua is attached to lkb it will be freed by dlm_free_lkb().
- When DLM_DFL_USER_BIT is set, the dlm knows that this is a userspace
- lock and that lkb_astparam is the dlm_user_args structure. */
- set_bit(DLM_DFL_USER_BIT, &lkb->lkb_dflags);
- error = request_lock(ls, lkb, name, namelen, &args);
+ if (convert)
+ error = convert_lock(ls, lkb, &args);
+ else
+ error = request_lock(ls, lkb, name, namelen, &args);
- switch (error) {
- case 0:
- break;
- case -EINPROGRESS:
- error = 0;
- break;
- case -EAGAIN:
+ if (error == -EINPROGRESS)
error = 0;
- fallthrough;
- default:
- goto out_put;
- }
-
- /* add this new lkb to the per-process list of locks */
- spin_lock_bh(&ua->proc->locks_spin);
- hold_lkb(lkb);
- list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
- spin_unlock_bh(&ua->proc->locks_spin);
- do_put = false;
out_put:
- trace_dlm_lock_end(ls, lkb, name, namelen, mode, flags, error, false);
- if (do_put)
+ trace_dlm_lock_end(ls, lkb, name, namelen, mode, flags, error, true);
+
+ if (convert || error)
__put_lkb(ls, lkb);
+ if (error == -EAGAIN || error == -EDEADLK)
+ error = 0;
out:
dlm_unlock_recovery(ls);
+ dlm_put_lockspace(ls);
return error;
}
-int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
- int mode, uint32_t flags, uint32_t lkid, char *lvb_in)
+int dlm_unlock(dlm_lockspace_t *lockspace,
+ uint32_t lkid,
+ uint32_t flags,
+ struct dlm_lksb *lksb,
+ void *astarg)
{
+ struct dlm_ls *ls;
struct dlm_lkb *lkb;
struct dlm_args args;
- struct dlm_user_args *ua;
int error;
+ ls = dlm_find_lockspace_local(lockspace);
+ if (!ls)
+ return -EINVAL;
+
dlm_lock_recovery(ls);
error = find_lkb(ls, lkid, &lkb);
if (error)
goto out;
- trace_dlm_lock_start(ls, lkb, NULL, 0, mode, flags);
+ trace_dlm_unlock_start(ls, lkb, flags);
+
+ error = set_unlock_args(flags, astarg, &args);
+ if (error)
+ goto out_put;
+
+ if (flags & DLM_LKF_CANCEL)
+ error = cancel_lock(ls, lkb, &args);
+ else
+ error = unlock_lock(ls, lkb, &args);
+
+ if (error == -DLM_EUNLOCK || error == -DLM_ECANCEL)
+ error = 0;
+ if (error == -EBUSY && (flags & (DLM_LKF_CANCEL | DLM_LKF_FORCEUNLOCK)))
+ error = 0;
+ out_put:
+ trace_dlm_unlock_end(ls, lkb, flags, error);
+
+ dlm_put_lkb(lkb);
+ out:
+ dlm_unlock_recovery(ls);
+ dlm_put_lockspace(ls);
+ return error;
+}
+
+static void purge_mstcpy_list(struct dlm_ls *ls, struct dlm_rsb *r,
+ struct list_head *list)
+{
+ struct dlm_lkb *lkb, *safe;
+
+ list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
+ if (!is_master_copy(lkb))
+ continue;
+
+ /* don't purge lkbs we've added in recover_master_copy for
+ the current recovery seq */
+
+ if (lkb->lkb_recover_seq == ls->ls_recover_seq)
+ continue;
+
+ del_lkb(r, lkb);
+
+ /* this put should free the lkb */
+ if (!dlm_put_lkb(lkb))
+ log_error(ls, "purged mstcpy lkb not released");
+ }
+}
+
+void dlm_purge_mstcpy_locks(struct dlm_rsb *r)
+{
+ struct dlm_ls *ls = r->res_ls;
+
+ purge_mstcpy_list(ls, r, &r->res_grantqueue);
+ purge_mstcpy_list(ls, r, &r->res_convertqueue);
+ purge_mstcpy_list(ls, r, &r->res_waitqueue);
+}
+
+static void purge_dead_list(struct dlm_ls *ls, struct dlm_rsb *r,
+ struct list_head *list,
+ int nodeid_gone, unsigned int *count)
+{
+ struct dlm_lkb *lkb, *safe;
+
+ list_for_each_entry_safe(lkb, safe, list, lkb_statequeue) {
+ if (!is_master_copy(lkb))
+ continue;
+
+ if ((lkb->lkb_nodeid == nodeid_gone) ||
+ dlm_is_removed(ls, lkb->lkb_nodeid)) {
+
+ /* tell recover_lvb to invalidate the lvb
+ because a node holding EX/PW failed */
+ if ((lkb->lkb_exflags & DLM_LKF_VALBLK) &&
+ (lkb->lkb_grmode >= DLM_LOCK_PW)) {
+ rsb_set_flag(r, RSB_RECOVER_LVB_INVAL);
+ }
+
+ del_lkb(r, lkb);
- /* user can change the params on its lock when it converts it, or
- add an lvb that didn't exist before */
+ /* this put should free the lkb */
+ if (!dlm_put_lkb(lkb))
+ log_error(ls, "purged dead lkb not released");
- ua = lkb->lkb_ua;
+ rsb_set_flag(r, RSB_RECOVER_GRANT);
- if (flags & DLM_LKF_VALBLK && !ua->lksb.sb_lvbptr) {
- ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_NOFS);
- if (!ua->lksb.sb_lvbptr) {
- error = -ENOMEM;
- goto out_put;
+ (*count)++;
}
}
- if (lvb_in && ua->lksb.sb_lvbptr)
- memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
+}
+
+/* Get rid of locks held by nodes that are gone. */
+
+void dlm_recover_purge(struct dlm_ls *ls, const struct list_head *root_list)
+{
+ struct dlm_rsb *r;
+ struct dlm_member *memb;
+ int nodes_count = 0;
+ int nodeid_gone = 0;
+ unsigned int lkb_count = 0;
+
+ /* cache one removed nodeid to optimize the common
+ case of a single node removed */
+
+ list_for_each_entry(memb, &ls->ls_nodes_gone, list) {
+ nodes_count++;
+ nodeid_gone = memb->nodeid;
+ }
- ua->xid = ua_tmp->xid;
- ua->castparam = ua_tmp->castparam;
- ua->castaddr = ua_tmp->castaddr;
- ua->bastparam = ua_tmp->bastparam;
- ua->bastaddr = ua_tmp->bastaddr;
- ua->user_lksb = ua_tmp->user_lksb;
+ if (!nodes_count)
+ return;
- error = set_lock_args(mode, &ua->lksb, flags, 0, fake_astfn, ua,
- fake_bastfn, &args);
- if (error)
- goto out_put;
+ list_for_each_entry(r, root_list, res_root_list) {
+ lock_rsb(r);
+ if (r->res_nodeid != -1 && is_master(r)) {
+ purge_dead_list(ls, r, &r->res_grantqueue,
+ nodeid_gone, &lkb_count);
+ purge_dead_list(ls, r, &r->res_convertqueue,
+ nodeid_gone, &lkb_count);
+ purge_dead_list(ls, r, &r->res_waitqueue,
+ nodeid_gone, &lkb_count);
+ }
+ unlock_rsb(r);
- error = convert_lock(ls, lkb, &args);
+ cond_resched();
+ }
- if (error == -EINPROGRESS || error == -EAGAIN || error == -EDEADLK)
- error = 0;
- out_put:
- trace_dlm_lock_end(ls, lkb, NULL, 0, mode, flags, error, false);
- dlm_put_lkb(lkb);
- out:
- dlm_unlock_recovery(ls);
- kfree(ua_tmp);
- return error;
+ if (lkb_count)
+ log_rinfo(ls, "dlm_recover_purge %u locks for %u nodes",
+ lkb_count, nodes_count);
}
-/*
- * The caller asks for an orphan lock on a given resource with a given mode.
- * If a matching lock exists, it's moved to the owner's list of locks and
- * the lkid is returned.
- */
-
-int dlm_user_adopt_orphan(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
- int mode, uint32_t flags, void *name, unsigned int namelen,
- uint32_t *lkid)
+static struct dlm_rsb *find_grant_rsb(struct dlm_ls *ls)
{
- struct dlm_lkb *lkb = NULL, *iter;
- struct dlm_user_args *ua;
- int found_other_mode = 0;
- int rv = 0;
+ struct dlm_rsb *r;
- spin_lock_bh(&ls->ls_orphans_lock);
- list_for_each_entry(iter, &ls->ls_orphans, lkb_ownqueue) {
- if (iter->lkb_resource->res_length != namelen)
- continue;
- if (memcmp(iter->lkb_resource->res_name, name, namelen))
+ read_lock_bh(&ls->ls_rsbtbl_lock);
+ list_for_each_entry(r, &ls->ls_slow_active, res_slow_list) {
+ if (!rsb_flag(r, RSB_RECOVER_GRANT))
continue;
- if (iter->lkb_grmode != mode) {
- found_other_mode = 1;
+ if (!is_master(r)) {
+ rsb_clear_flag(r, RSB_RECOVER_GRANT);
continue;
}
-
- lkb = iter;
- list_del_init(&iter->lkb_ownqueue);
- clear_bit(DLM_DFL_ORPHAN_BIT, &iter->lkb_dflags);
- *lkid = iter->lkb_id;
- break;
+ hold_rsb(r);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ return r;
}
- spin_unlock_bh(&ls->ls_orphans_lock);
+ read_unlock_bh(&ls->ls_rsbtbl_lock);
+ return NULL;
+}
- if (!lkb && found_other_mode) {
- rv = -EAGAIN;
- goto out;
- }
+/*
+ * Attempt to grant locks on resources that we are the master of.
+ * Locks may have become grantable during recovery because locks
+ * from departed nodes have been purged (or not rebuilt), allowing
+ * previously blocked locks to now be granted. The subset of rsb's
+ * we are interested in are those with lkb's on either the convert or
+ * waiting queues.
+ *
+ * Simplest would be to go through each master rsb and check for non-empty
+ * convert or waiting queues, and attempt to grant on those rsbs.
+ * Checking the queues requires lock_rsb, though, for which we'd need
+ * to release the rsbtbl lock. This would make iterating through all
+ * rsb's very inefficient. So, we rely on earlier recovery routines
+ * to set RECOVER_GRANT on any rsb's that we should attempt to grant
+ * locks for.
+ */
- if (!lkb) {
- rv = -ENOENT;
- goto out;
- }
+void dlm_recover_grant(struct dlm_ls *ls)
+{
+ struct dlm_rsb *r;
+ unsigned int count = 0;
+ unsigned int rsb_count = 0;
+ unsigned int lkb_count = 0;
- lkb->lkb_exflags = flags;
- lkb->lkb_ownpid = (int) current->pid;
+ while (1) {
+ r = find_grant_rsb(ls);
+ if (!r)
+ break;
- ua = lkb->lkb_ua;
+ rsb_count++;
+ count = 0;
+ lock_rsb(r);
+ /* the RECOVER_GRANT flag is checked in the grant path */
+ grant_pending_locks(r, &count);
+ rsb_clear_flag(r, RSB_RECOVER_GRANT);
+ lkb_count += count;
+ confirm_master(r, 0);
+ unlock_rsb(r);
+ put_rsb(r);
+ cond_resched();
+ }
- ua->proc = ua_tmp->proc;
- ua->xid = ua_tmp->xid;
- ua->castparam = ua_tmp->castparam;
- ua->castaddr = ua_tmp->castaddr;
- ua->bastparam = ua_tmp->bastparam;
- ua->bastaddr = ua_tmp->bastaddr;
- ua->user_lksb = ua_tmp->user_lksb;
+ if (lkb_count)
+ log_rinfo(ls, "dlm_recover_grant %u locks on %u resources",
+ lkb_count, rsb_count);
+}
- /*
- * The lkb reference from the ls_orphans list was not
- * removed above, and is now considered the reference
- * for the proc locks list.
- */
+static struct dlm_lkb *search_remid_list(struct list_head *head, int nodeid,
+ uint32_t remid)
+{
+ struct dlm_lkb *lkb;
- spin_lock_bh(&ua->proc->locks_spin);
- list_add_tail(&lkb->lkb_ownqueue, &ua->proc->locks);
- spin_unlock_bh(&ua->proc->locks_spin);
- out:
- kfree(ua_tmp);
- return rv;
+ list_for_each_entry(lkb, head, lkb_statequeue) {
+ if (lkb->lkb_nodeid == nodeid && lkb->lkb_remid == remid)
+ return lkb;
+ }
+ return NULL;
}
-int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
- uint32_t flags, uint32_t lkid, char *lvb_in)
+static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
+ uint32_t remid)
{
struct dlm_lkb *lkb;
- struct dlm_args args;
- struct dlm_user_args *ua;
- int error;
- dlm_lock_recovery(ls);
+ lkb = search_remid_list(&r->res_grantqueue, nodeid, remid);
+ if (lkb)
+ return lkb;
+ lkb = search_remid_list(&r->res_convertqueue, nodeid, remid);
+ if (lkb)
+ return lkb;
+ lkb = search_remid_list(&r->res_waitqueue, nodeid, remid);
+ if (lkb)
+ return lkb;
+ return NULL;
+}
- error = find_lkb(ls, lkid, &lkb);
- if (error)
- goto out;
+/* needs at least dlm_rcom + rcom_lock */
+static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ struct dlm_rsb *r, const struct dlm_rcom *rc)
+{
+ struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
- trace_dlm_unlock_start(ls, lkb, flags);
+ lkb->lkb_nodeid = le32_to_cpu(rc->rc_header.h_nodeid);
+ lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
+ lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
+ lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
+ dlm_set_dflags_val(lkb, le32_to_cpu(rl->rl_flags));
+ set_bit(DLM_IFL_MSTCPY_BIT, &lkb->lkb_iflags);
+ lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
+ lkb->lkb_rqmode = rl->rl_rqmode;
+ lkb->lkb_grmode = rl->rl_grmode;
+ /* don't set lkb_status because add_lkb wants to itself */
- ua = lkb->lkb_ua;
+ lkb->lkb_bastfn = (rl->rl_asts & DLM_CB_BAST) ? &fake_bastfn : NULL;
+ lkb->lkb_astfn = (rl->rl_asts & DLM_CB_CAST) ? &fake_astfn : NULL;
- if (lvb_in && ua->lksb.sb_lvbptr)
- memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
- if (ua_tmp->castparam)
- ua->castparam = ua_tmp->castparam;
- ua->user_lksb = ua_tmp->user_lksb;
+ if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
+ int lvblen = le16_to_cpu(rc->rc_header.h_length) -
+ sizeof(struct dlm_rcom) - sizeof(struct rcom_lock);
+ if (lvblen > ls->ls_lvblen)
+ return -EINVAL;
+ lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
+ if (!lkb->lkb_lvbptr)
+ return -ENOMEM;
+ memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
+ }
- error = set_unlock_args(flags, ua, &args);
- if (error)
- goto out_put;
+ /* Conversions between PR and CW (middle modes) need special handling.
+ The real granted mode of these converting locks cannot be determined
+ until all locks have been rebuilt on the rsb (recover_conversion) */
- error = unlock_lock(ls, lkb, &args);
+ if (rl->rl_status == DLM_LKSTS_CONVERT && middle_conversion(lkb)) {
+ /* We may need to adjust grmode depending on other granted locks. */
+ log_limit(ls, "%s %x middle convert in progress", __func__,
+ lkb->lkb_id);
- if (error == -DLM_EUNLOCK)
- error = 0;
- /* from validate_unlock_args() */
- if (error == -EBUSY && (flags & DLM_LKF_FORCEUNLOCK))
- error = 0;
- if (error)
- goto out_put;
+ /* We sent this lock to the new master. The new master will
+ * tell us when it's granted. We no longer need a reply, so
+ * use a fake reply to put the lkb into the right state.
+ */
+ hold_lkb(lkb);
+ memset(ms_local, 0, sizeof(struct dlm_message));
+ ms_local->m_type = cpu_to_le32(DLM_MSG_CONVERT_REPLY);
+ ms_local->m_result = cpu_to_le32(to_dlm_errno(-EINPROGRESS));
+ ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
+ _receive_convert_reply(lkb, ms_local, true);
+ unhold_lkb(lkb);
- spin_lock_bh(&ua->proc->locks_spin);
- /* dlm_user_add_cb() may have already taken lkb off the proc list */
- if (!list_empty(&lkb->lkb_ownqueue))
- list_move(&lkb->lkb_ownqueue, &ua->proc->unlocking);
- spin_unlock_bh(&ua->proc->locks_spin);
- out_put:
- trace_dlm_unlock_end(ls, lkb, flags, error);
- dlm_put_lkb(lkb);
- out:
- dlm_unlock_recovery(ls);
- kfree(ua_tmp);
- return error;
+ } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
+ set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
+ }
+
+ /* lkb->lkb_rqmode < lkb->lkb_grmode shouldn't happen since down
+ conversions are async; there's no reply from the remote master */
}
-int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
- uint32_t flags, uint32_t lkid)
-{
- struct dlm_lkb *lkb;
- struct dlm_args args;
- struct dlm_user_args *ua;
- int error;
+/* A waiting lkb needs recovery if the master node has failed, or
+ the master node is changing (only when no directory is used) */
- dlm_lock_recovery(ls);
+static int waiter_needs_recovery(struct dlm_ls *ls, struct dlm_lkb *lkb,
+ int dir_nodeid)
+{
+ if (dlm_no_directory(ls))
+ return 1;
- error = find_lkb(ls, lkid, &lkb);
- if (error)
- goto out;
+ if (dlm_is_removed(ls, lkb->lkb_wait_nodeid))
+ return 1;
- trace_dlm_unlock_start(ls, lkb, flags);
+ return 0;
+}
- ua = lkb->lkb_ua;
- if (ua_tmp->castparam)
- ua->castparam = ua_tmp->castparam;
- ua->user_lksb = ua_tmp->user_lksb;
+/* Recovery for locks that are waiting for replies from nodes that are now
+ gone. We can just complete unlocks and cancels by faking a reply from the
+ dead node. Requests and up-conversions we flag to be resent after
+ recovery. Down-conversions can just be completed with a fake reply like
+ unlocks. Conversions between PR and CW need special attention. */
- error = set_unlock_args(flags, ua, &args);
- if (error)
- goto out_put;
+void dlm_recover_waiters_pre(struct dlm_ls *ls)
+{
+ struct dlm_lkb *lkb, *safe;
+ struct dlm_message *ms_local;
+ int wait_type, local_unlock_result, local_cancel_result;
+ int dir_nodeid;
- error = cancel_lock(ls, lkb, &args);
+ ms_local = kmalloc(sizeof(*ms_local), GFP_KERNEL);
+ if (!ms_local)
+ return;
- if (error == -DLM_ECANCEL)
- error = 0;
- /* from validate_unlock_args() */
- if (error == -EBUSY)
- error = 0;
- out_put:
- trace_dlm_unlock_end(ls, lkb, flags, error);
- dlm_put_lkb(lkb);
- out:
- dlm_unlock_recovery(ls);
- kfree(ua_tmp);
- return error;
-}
+ list_for_each_entry_safe(lkb, safe, &ls->ls_waiters, lkb_wait_reply) {
-int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
-{
- struct dlm_lkb *lkb;
- struct dlm_args args;
- struct dlm_user_args *ua;
- struct dlm_rsb *r;
- int error;
+ dir_nodeid = dlm_dir_nodeid(lkb->lkb_resource);
- dlm_lock_recovery(ls);
+ /* exclude debug messages about unlocks because there can be so
+ many and they aren't very interesting */
- error = find_lkb(ls, lkid, &lkb);
- if (error)
- goto out;
+ if (lkb->lkb_wait_type != DLM_MSG_UNLOCK) {
+ log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
+ "lkb_nodeid %d wait_nodeid %d dir_nodeid %d",
+ lkb->lkb_id,
+ lkb->lkb_remid,
+ lkb->lkb_wait_type,
+ lkb->lkb_resource->res_nodeid,
+ lkb->lkb_nodeid,
+ lkb->lkb_wait_nodeid,
+ dir_nodeid);
+ }
- trace_dlm_unlock_start(ls, lkb, flags);
+ /* all outstanding lookups, regardless of destination will be
+ resent after recovery is done */
- ua = lkb->lkb_ua;
+ if (lkb->lkb_wait_type == DLM_MSG_LOOKUP) {
+ set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
+ continue;
+ }
- error = set_unlock_args(flags, ua, &args);
- if (error)
- goto out_put;
+ if (!waiter_needs_recovery(ls, lkb, dir_nodeid))
+ continue;
- /* same as cancel_lock(), but set DEADLOCK_CANCEL after lock_rsb */
+ wait_type = lkb->lkb_wait_type;
+ local_unlock_result = -DLM_EUNLOCK;
+ local_cancel_result = -DLM_ECANCEL;
- r = lkb->lkb_resource;
- hold_rsb(r);
- lock_rsb(r);
+ /* Main reply may have been received leaving a zero wait_type,
+ but a reply for the overlapping op may not have been
+ received. In that case we need to fake the appropriate
+ reply for the overlap op. */
- error = validate_unlock_args(lkb, &args);
- if (error)
- goto out_r;
- set_bit(DLM_IFL_DEADLOCK_CANCEL_BIT, &lkb->lkb_iflags);
+ if (!wait_type) {
+ if (is_overlap_cancel(lkb)) {
+ wait_type = DLM_MSG_CANCEL;
+ if (lkb->lkb_grmode == DLM_LOCK_IV)
+ local_cancel_result = 0;
+ }
+ if (is_overlap_unlock(lkb)) {
+ wait_type = DLM_MSG_UNLOCK;
+ if (lkb->lkb_grmode == DLM_LOCK_IV)
+ local_unlock_result = -ENOENT;
+ }
- error = _cancel_lock(r, lkb);
- out_r:
- unlock_rsb(r);
- put_rsb(r);
+ log_debug(ls, "rwpre overlap %x %x %d %d %d",
+ lkb->lkb_id, dlm_iflags_val(lkb), wait_type,
+ local_cancel_result, local_unlock_result);
+ }
- if (error == -DLM_ECANCEL)
- error = 0;
- /* from validate_unlock_args() */
- if (error == -EBUSY)
- error = 0;
- out_put:
- trace_dlm_unlock_end(ls, lkb, flags, error);
- dlm_put_lkb(lkb);
- out:
- dlm_unlock_recovery(ls);
- return error;
-}
+ switch (wait_type) {
-/* lkb's that are removed from the waiters list by revert are just left on the
- orphans list with the granted orphan locks, to be freed by purge */
+ case DLM_MSG_REQUEST:
+ set_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
+ break;
-static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
-{
- struct dlm_args args;
- int error;
+ case DLM_MSG_CONVERT:
+ recover_convert_waiter(ls, lkb, ms_local);
+ break;
- hold_lkb(lkb); /* reference for the ls_orphans list */
- spin_lock_bh(&ls->ls_orphans_lock);
- list_add_tail(&lkb->lkb_ownqueue, &ls->ls_orphans);
- spin_unlock_bh(&ls->ls_orphans_lock);
+ case DLM_MSG_UNLOCK:
+ hold_lkb(lkb);
+ memset(ms_local, 0, sizeof(struct dlm_message));
+ ms_local->m_type = cpu_to_le32(DLM_MSG_UNLOCK_REPLY);
+ ms_local->m_result = cpu_to_le32(to_dlm_errno(local_unlock_result));
+ ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
+ _receive_unlock_reply(lkb, ms_local, true);
+ dlm_put_lkb(lkb);
+ break;
- set_unlock_args(0, lkb->lkb_ua, &args);
+ case DLM_MSG_CANCEL:
+ hold_lkb(lkb);
+ memset(ms_local, 0, sizeof(struct dlm_message));
+ ms_local->m_type = cpu_to_le32(DLM_MSG_CANCEL_REPLY);
+ ms_local->m_result = cpu_to_le32(to_dlm_errno(local_cancel_result));
+ ms_local->m_header.h_nodeid = cpu_to_le32(lkb->lkb_nodeid);
+ _receive_cancel_reply(lkb, ms_local, true);
+ dlm_put_lkb(lkb);
+ break;
- error = cancel_lock(ls, lkb, &args);
- if (error == -DLM_ECANCEL)
- error = 0;
- return error;
+ default:
+ log_error(ls, "invalid lkb wait_type %d %d",
+ lkb->lkb_wait_type, wait_type);
+ }
+ schedule();
+ }
+ kfree(ms_local);
}
-/* The FORCEUNLOCK flag allows the unlock to go ahead even if the lkb isn't
- granted. Regardless of what rsb queue the lock is on, it's removed and
- freed. The IVVALBLK flag causes the lvb on the resource to be invalidated
- if our lock is PW/EX (it's ignored if our granted mode is smaller.) */
-
-static int unlock_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
+static struct dlm_lkb *find_resend_waiter(struct dlm_ls *ls)
{
- struct dlm_args args;
- int error;
+ struct dlm_lkb *lkb = NULL, *iter;
- set_unlock_args(DLM_LKF_FORCEUNLOCK | DLM_LKF_IVVALBLK,
- lkb->lkb_ua, &args);
+ spin_lock_bh(&ls->ls_waiters_lock);
+ list_for_each_entry(iter, &ls->ls_waiters, lkb_wait_reply) {
+ if (test_bit(DLM_IFL_RESEND_BIT, &iter->lkb_iflags)) {
+ hold_lkb(iter);
+ lkb = iter;
+ break;
+ }
+ }
+ spin_unlock_bh(&ls->ls_waiters_lock);
- error = unlock_lock(ls, lkb, &args);
- if (error == -DLM_EUNLOCK)
- error = 0;
- return error;
+ return lkb;
}
-/* We have to release clear_proc_locks mutex before calling unlock_proc_lock()
- (which does lock_rsb) due to deadlock with receiving a message that does
- lock_rsb followed by dlm_user_add_cb() */
+/*
+ * Forced state reset for locks that were in the middle of remote operations
+ * when recovery happened (i.e. lkbs that were on the waiters list, waiting
+ * for a reply from a remote operation.) The lkbs remaining on the waiters
+ * list need to be reevaluated; some may need resending to a different node
+ * than previously, and some may now need local handling rather than remote.
+ *
+ * First, the lkb state for the voided remote operation is forcibly reset,
+ * equivalent to what remove_from_waiters() would normally do:
+ * . lkb removed from ls_waiters list
+ * . lkb wait_type cleared
+ * . lkb waiters_count cleared
+ * . lkb ref count decremented for each waiters_count (almost always 1,
+ * but possibly 2 in case of cancel/unlock overlapping, which means
+ * two remote replies were being expected for the lkb.)
+ *
+ * Second, the lkb is reprocessed like an original operation would be,
+ * by passing it to _request_lock or _convert_lock, which will either
+ * process the lkb operation locally, or send it to a remote node again
+ * and put the lkb back onto the waiters list.
+ *
+ * When reprocessing the lkb, we may find that it's flagged for an overlapping
+ * force-unlock or cancel, either from before recovery began, or after recovery
+ * finished. If this is the case, the unlock/cancel is done directly, and the
+ * original operation is not initiated again (no _request_lock/_convert_lock.)
+ */
-static struct dlm_lkb *del_proc_lock(struct dlm_ls *ls,
- struct dlm_user_proc *proc)
+int dlm_recover_waiters_post(struct dlm_ls *ls)
{
- struct dlm_lkb *lkb = NULL;
+ struct dlm_lkb *lkb;
+ struct dlm_rsb *r;
+ int error = 0, mstype, err, oc, ou;
- spin_lock_bh(&ls->ls_clear_proc_locks);
- if (list_empty(&proc->locks))
- goto out;
+ while (1) {
+ if (dlm_locking_stopped(ls)) {
+ log_debug(ls, "recover_waiters_post aborted");
+ error = -EINTR;
+ break;
+ }
- lkb = list_entry(proc->locks.next, struct dlm_lkb, lkb_ownqueue);
- list_del_init(&lkb->lkb_ownqueue);
+ /*
+ * Find an lkb from the waiters list that's been affected by
+ * recovery node changes, and needs to be reprocessed. Does
+ * hold_lkb(), adding a refcount.
+ */
+ lkb = find_resend_waiter(ls);
+ if (!lkb)
+ break;
- if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
- set_bit(DLM_DFL_ORPHAN_BIT, &lkb->lkb_dflags);
- else
- set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
- out:
- spin_unlock_bh(&ls->ls_clear_proc_locks);
- return lkb;
-}
+ r = lkb->lkb_resource;
+ hold_rsb(r);
+ lock_rsb(r);
-/* The ls_clear_proc_locks mutex protects against dlm_user_add_cb() which
- 1) references lkb->ua which we free here and 2) adds lkbs to proc->asts,
- which we clear here. */
+ /*
+ * If the lkb has been flagged for a force unlock or cancel,
+ * then the reprocessing below will be replaced by just doing
+ * the unlock/cancel directly.
+ */
+ mstype = lkb->lkb_wait_type;
+ oc = test_and_clear_bit(DLM_IFL_OVERLAP_CANCEL_BIT,
+ &lkb->lkb_iflags);
+ ou = test_and_clear_bit(DLM_IFL_OVERLAP_UNLOCK_BIT,
+ &lkb->lkb_iflags);
+ err = 0;
-/* proc CLOSING flag is set so no more device_reads should look at proc->asts
- list, and no more device_writes should add lkb's to proc->locks list; so we
- shouldn't need to take asts_spin or locks_spin here. this assumes that
- device reads/writes/closes are serialized -- FIXME: we may need to serialize
- them ourself. */
+ log_debug(ls, "waiter %x remote %x msg %d r_nodeid %d "
+ "lkb_nodeid %d wait_nodeid %d dir_nodeid %d "
+ "overlap %d %d", lkb->lkb_id, lkb->lkb_remid, mstype,
+ r->res_nodeid, lkb->lkb_nodeid, lkb->lkb_wait_nodeid,
+ dlm_dir_nodeid(r), oc, ou);
-void dlm_clear_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
-{
- struct dlm_callback *cb, *cb_safe;
- struct dlm_lkb *lkb, *safe;
+ /*
+ * No reply to the pre-recovery operation will now be received,
+ * so a forced equivalent of remove_from_waiters() is needed to
+ * reset the waiters state that was in place before recovery.
+ */
- dlm_lock_recovery(ls);
+ clear_bit(DLM_IFL_RESEND_BIT, &lkb->lkb_iflags);
- while (1) {
- lkb = del_proc_lock(ls, proc);
- if (!lkb)
- break;
- if (lkb->lkb_exflags & DLM_LKF_PERSISTENT)
- orphan_proc_lock(ls, lkb);
- else
- unlock_proc_lock(ls, lkb);
+ /* Forcibly clear wait_type */
+ lkb->lkb_wait_type = 0;
- /* this removes the reference for the proc->locks list
- added by dlm_user_request, it may result in the lkb
- being freed */
+ /*
+ * Forcibly reset wait_count and associated refcount. The
+ * wait_count will almost always be 1, but in case of an
+ * overlapping unlock/cancel it could be 2: see where
+ * add_to_waiters() finds the lkb is already on the waiters
+ * list and does lkb_wait_count++; hold_lkb().
+ */
+ while (lkb->lkb_wait_count) {
+ lkb->lkb_wait_count--;
+ unhold_lkb(lkb);
+ }
- dlm_put_lkb(lkb);
- }
+ /* Forcibly remove from waiters list */
+ spin_lock_bh(&ls->ls_waiters_lock);
+ list_del_init(&lkb->lkb_wait_reply);
+ spin_unlock_bh(&ls->ls_waiters_lock);
- spin_lock_bh(&ls->ls_clear_proc_locks);
+ /*
+ * The lkb is now clear of all prior waiters state and can be
+ * processed locally, or sent to remote node again, or directly
+ * cancelled/unlocked.
+ */
- /* in-progress unlocks */
- list_for_each_entry_safe(lkb, safe, &proc->unlocking, lkb_ownqueue) {
- list_del_init(&lkb->lkb_ownqueue);
- set_bit(DLM_IFL_DEAD_BIT, &lkb->lkb_iflags);
- dlm_put_lkb(lkb);
- }
+ if (oc || ou) {
+ /* do an unlock or cancel instead of resending */
+ switch (mstype) {
+ case DLM_MSG_LOOKUP:
+ case DLM_MSG_REQUEST:
+ queue_cast(r, lkb, ou ? -DLM_EUNLOCK :
+ -DLM_ECANCEL);
+ unhold_lkb(lkb); /* undoes create_lkb() */
+ break;
+ case DLM_MSG_CONVERT:
+ if (oc) {
+ queue_cast(r, lkb, -DLM_ECANCEL);
+ } else {
+ lkb->lkb_exflags |= DLM_LKF_FORCEUNLOCK;
+ _unlock_lock(r, lkb);
+ }
+ break;
+ default:
+ err = 1;
+ }
+ } else {
+ switch (mstype) {
+ case DLM_MSG_LOOKUP:
+ case DLM_MSG_REQUEST:
+ _request_lock(r, lkb);
+ if (r->res_nodeid != -1 && is_master(r))
+ confirm_master(r, 0);
+ break;
+ case DLM_MSG_CONVERT:
+ _convert_lock(r, lkb);
+ break;
+ default:
+ err = 1;
+ }
+ }
- list_for_each_entry_safe(cb, cb_safe, &proc->asts, list) {
- list_del(&cb->list);
- dlm_free_cb(cb);
+ if (err) {
+ log_error(ls, "waiter %x msg %d r_nodeid %d "
+ "dir_nodeid %d overlap %d %d",
+ lkb->lkb_id, mstype, r->res_nodeid,
+ dlm_dir_nodeid(r), oc, ou);
+ }
+ unlock_rsb(r);
+ put_rsb(r);
+ dlm_put_lkb(lkb);
}
- spin_unlock_bh(&ls->ls_clear_proc_locks);
- dlm_unlock_recovery(ls);
+ return error;
}
static void purge_proc_locks(struct dlm_ls *ls, struct dlm_user_proc *proc)
--
2.48.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages
2025-08-29 11:07 [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages Alessio Attilio
@ 2025-08-29 13:53 ` Alexander Aring
[not found] ` <CACsb0NhQ8BBzcUtR0awMu6AbP-xwLvkUotDAAg-LbUV_LxwiNA@mail.gmail.com>
2025-08-29 18:05 ` David Teigland
1 sibling, 1 reply; 4+ messages in thread
From: Alexander Aring @ 2025-08-29 13:53 UTC (permalink / raw)
To: Alessio Attilio; +Cc: David Teigland, gfs2, linux-kernel, Alessio Attilio
Hi,
What is this patch supposed to do?
Your subject states something as a fix for unlock/cancel operation.
What is the problem you encountered there?
- Alex
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages
[not found] ` <CACsb0NhQ8BBzcUtR0awMu6AbP-xwLvkUotDAAg-LbUV_LxwiNA@mail.gmail.com>
@ 2025-08-29 16:01 ` Alexander Aring
0 siblings, 0 replies; 4+ messages in thread
From: Alexander Aring @ 2025-08-29 16:01 UTC (permalink / raw)
To: Alessio Attilio; +Cc: David Teigland, gfs2, linux-kernel, Alessio Attilio
Hi,
On Fri, Aug 29, 2025 at 10:35 AM Alessio Attilio
<alessio.attilio.dev@gmail.com> wrote:
>
>
> Hey there.
>
> This fix tackles a tricky race condition that can pop up when an unlock or cancel operation is triggered while a deferred lock message is still being processed. What this patch does is make sure these operations are handled safely, even if the lock is still being resolved through dlm_master_lookup.
>
> The problem I ran into was that, under certain timing scenarios, a lock could be canceled or unlocked while the deferred message was still pending.
depends on how your lock usage might be pretty normal. What exactly is
a "deferred lock message" here?
> This could lead to an inconsistent state or even accessing freed structures.
Do you have any reproducer or more information e.g. stacktrace for
that with a debug kernel?
- Alex
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages
2025-08-29 11:07 [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages Alessio Attilio
2025-08-29 13:53 ` Alexander Aring
@ 2025-08-29 18:05 ` David Teigland
1 sibling, 0 replies; 4+ messages in thread
From: David Teigland @ 2025-08-29 18:05 UTC (permalink / raw)
To: Alessio Attilio; +Cc: Alexander Aring, gfs2, linux-kernel
On Fri, Aug 29, 2025 at 01:07:49PM +0200, Alessio Attilio wrote:
> ---
> fs/dlm/lock.c | 8067 ++++++++++++++++++++++++-------------------------
> 1 file changed, 3944 insertions(+), 4123 deletions(-)
Thanks for working on this, lock cancel has always been sketchy, and I'd
be happy to see that improved. An 8000 line patch is going to be
difficult to review, though! It looks like diff may just be moving a lot
of lines around, and perhaps splitting this up could avoid some of that?
Also, I'm not seeing which upstream commit the patch is against.
Thanks,
Dave
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2025-08-29 18:05 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-08-29 11:07 [PATCH] fix(dlm): handle unlock/cancel during deferred lock messages Alessio Attilio
2025-08-29 13:53 ` Alexander Aring
[not found] ` <CACsb0NhQ8BBzcUtR0awMu6AbP-xwLvkUotDAAg-LbUV_LxwiNA@mail.gmail.com>
2025-08-29 16:01 ` Alexander Aring
2025-08-29 18:05 ` David Teigland
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).