1328970deSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2fa60ce2cSMasahiro Yamada /*
36714d8e8SKurt Hackel * dlmmod.c
46714d8e8SKurt Hackel *
56714d8e8SKurt Hackel * standalone DLM module
66714d8e8SKurt Hackel *
76714d8e8SKurt Hackel * Copyright (C) 2004 Oracle. All rights reserved.
86714d8e8SKurt Hackel */
96714d8e8SKurt Hackel
106714d8e8SKurt Hackel
116714d8e8SKurt Hackel #include <linux/module.h>
126714d8e8SKurt Hackel #include <linux/fs.h>
136714d8e8SKurt Hackel #include <linux/types.h>
146714d8e8SKurt Hackel #include <linux/slab.h>
156714d8e8SKurt Hackel #include <linux/highmem.h>
166714d8e8SKurt Hackel #include <linux/init.h>
176714d8e8SKurt Hackel #include <linux/sysctl.h>
186714d8e8SKurt Hackel #include <linux/random.h>
196714d8e8SKurt Hackel #include <linux/blkdev.h>
206714d8e8SKurt Hackel #include <linux/socket.h>
216714d8e8SKurt Hackel #include <linux/inet.h>
226714d8e8SKurt Hackel #include <linux/spinlock.h>
236714d8e8SKurt Hackel #include <linux/delay.h>
246714d8e8SKurt Hackel
256714d8e8SKurt Hackel
26ca322fb6SMasahiro Yamada #include "../cluster/heartbeat.h"
27ca322fb6SMasahiro Yamada #include "../cluster/nodemanager.h"
28ca322fb6SMasahiro Yamada #include "../cluster/tcp.h"
296714d8e8SKurt Hackel
306714d8e8SKurt Hackel #include "dlmapi.h"
316714d8e8SKurt Hackel #include "dlmcommon.h"
3282353b59SAdrian Bunk #include "dlmdomain.h"
33e5a0334cSSunil Mushran #include "dlmdebug.h"
346714d8e8SKurt Hackel
356714d8e8SKurt Hackel #define MLOG_MASK_PREFIX (ML_DLM|ML_DLM_MASTER)
36ca322fb6SMasahiro Yamada #include "../cluster/masklog.h"
376714d8e8SKurt Hackel
386714d8e8SKurt Hackel static void dlm_mle_node_down(struct dlm_ctxt *dlm,
396714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
406714d8e8SKurt Hackel struct o2nm_node *node,
416714d8e8SKurt Hackel int idx);
426714d8e8SKurt Hackel static void dlm_mle_node_up(struct dlm_ctxt *dlm,
436714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
446714d8e8SKurt Hackel struct o2nm_node *node,
456714d8e8SKurt Hackel int idx);
466714d8e8SKurt Hackel
476714d8e8SKurt Hackel static void dlm_assert_master_worker(struct dlm_work_item *item, void *data);
48ba2bf218SKurt Hackel static int dlm_do_assert_master(struct dlm_ctxt *dlm,
49ba2bf218SKurt Hackel struct dlm_lock_resource *res,
50ba2bf218SKurt Hackel void *nodemap, u32 flags);
51f3f85464SSunil Mushran static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data);
526714d8e8SKurt Hackel
dlm_mle_equal(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle,const char * name,unsigned int namelen)536714d8e8SKurt Hackel static inline int dlm_mle_equal(struct dlm_ctxt *dlm,
546714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
556714d8e8SKurt Hackel const char *name,
566714d8e8SKurt Hackel unsigned int namelen)
576714d8e8SKurt Hackel {
586714d8e8SKurt Hackel if (dlm != mle->dlm)
596714d8e8SKurt Hackel return 0;
606714d8e8SKurt Hackel
617141514bSSunil Mushran if (namelen != mle->mnamelen ||
627141514bSSunil Mushran memcmp(name, mle->mname, namelen) != 0)
636714d8e8SKurt Hackel return 0;
64f77a9a78SSunil Mushran
656714d8e8SKurt Hackel return 1;
666714d8e8SKurt Hackel }
676714d8e8SKurt Hackel
681a5c4e2aSFabian Frederick static struct kmem_cache *dlm_lockres_cache;
691a5c4e2aSFabian Frederick static struct kmem_cache *dlm_lockname_cache;
701a5c4e2aSFabian Frederick static struct kmem_cache *dlm_mle_cache;
716714d8e8SKurt Hackel
726714d8e8SKurt Hackel static void dlm_mle_release(struct kref *kref);
736714d8e8SKurt Hackel static void dlm_init_mle(struct dlm_master_list_entry *mle,
746714d8e8SKurt Hackel enum dlm_mle_type type,
756714d8e8SKurt Hackel struct dlm_ctxt *dlm,
766714d8e8SKurt Hackel struct dlm_lock_resource *res,
776714d8e8SKurt Hackel const char *name,
786714d8e8SKurt Hackel unsigned int namelen);
796714d8e8SKurt Hackel static void dlm_put_mle(struct dlm_master_list_entry *mle);
806714d8e8SKurt Hackel static void __dlm_put_mle(struct dlm_master_list_entry *mle);
816714d8e8SKurt Hackel static int dlm_find_mle(struct dlm_ctxt *dlm,
826714d8e8SKurt Hackel struct dlm_master_list_entry **mle,
836714d8e8SKurt Hackel char *name, unsigned int namelen);
846714d8e8SKurt Hackel
85ba2bf218SKurt Hackel static int dlm_do_master_request(struct dlm_lock_resource *res,
86ba2bf218SKurt Hackel struct dlm_master_list_entry *mle, int to);
876714d8e8SKurt Hackel
886714d8e8SKurt Hackel
896714d8e8SKurt Hackel static int dlm_wait_for_lock_mastery(struct dlm_ctxt *dlm,
906714d8e8SKurt Hackel struct dlm_lock_resource *res,
916714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
926714d8e8SKurt Hackel int *blocked);
936714d8e8SKurt Hackel static int dlm_restart_lock_mastery(struct dlm_ctxt *dlm,
946714d8e8SKurt Hackel struct dlm_lock_resource *res,
956714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
966714d8e8SKurt Hackel int blocked);
976714d8e8SKurt Hackel static int dlm_add_migration_mle(struct dlm_ctxt *dlm,
986714d8e8SKurt Hackel struct dlm_lock_resource *res,
996714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
1006714d8e8SKurt Hackel struct dlm_master_list_entry **oldmle,
1016714d8e8SKurt Hackel const char *name, unsigned int namelen,
1026714d8e8SKurt Hackel u8 new_master, u8 master);
1036714d8e8SKurt Hackel
1046714d8e8SKurt Hackel static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm,
1056714d8e8SKurt Hackel struct dlm_lock_resource *res);
1066714d8e8SKurt Hackel static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm,
1076714d8e8SKurt Hackel struct dlm_lock_resource *res);
1086714d8e8SKurt Hackel static int dlm_mark_lockres_migrating(struct dlm_ctxt *dlm,
1096714d8e8SKurt Hackel struct dlm_lock_resource *res,
1106714d8e8SKurt Hackel u8 target);
111c03872f5SKurt Hackel static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm,
112c03872f5SKurt Hackel struct dlm_lock_resource *res);
1136714d8e8SKurt Hackel
1146714d8e8SKurt Hackel
dlm_is_host_down(int errno)1156714d8e8SKurt Hackel int dlm_is_host_down(int errno)
1166714d8e8SKurt Hackel {
1176714d8e8SKurt Hackel switch (errno) {
1186714d8e8SKurt Hackel case -EBADF:
1196714d8e8SKurt Hackel case -ECONNREFUSED:
1206714d8e8SKurt Hackel case -ENOTCONN:
1216714d8e8SKurt Hackel case -ECONNRESET:
1226714d8e8SKurt Hackel case -EPIPE:
1236714d8e8SKurt Hackel case -EHOSTDOWN:
1246714d8e8SKurt Hackel case -EHOSTUNREACH:
1256714d8e8SKurt Hackel case -ETIMEDOUT:
1266714d8e8SKurt Hackel case -ECONNABORTED:
1276714d8e8SKurt Hackel case -ENETDOWN:
1286714d8e8SKurt Hackel case -ENETUNREACH:
1296714d8e8SKurt Hackel case -ENETRESET:
1306714d8e8SKurt Hackel case -ESHUTDOWN:
1316714d8e8SKurt Hackel case -ENOPROTOOPT:
1326714d8e8SKurt Hackel case -EINVAL: /* if returned from our tcp code,
1336714d8e8SKurt Hackel this means there is no socket */
1346714d8e8SKurt Hackel return 1;
1356714d8e8SKurt Hackel }
1366714d8e8SKurt Hackel return 0;
1376714d8e8SKurt Hackel }
1386714d8e8SKurt Hackel
1396714d8e8SKurt Hackel
1406714d8e8SKurt Hackel /*
1416714d8e8SKurt Hackel * MASTER LIST FUNCTIONS
1426714d8e8SKurt Hackel */
1436714d8e8SKurt Hackel
1446714d8e8SKurt Hackel
1456714d8e8SKurt Hackel /*
1466714d8e8SKurt Hackel * regarding master list entries and heartbeat callbacks:
1476714d8e8SKurt Hackel *
1486714d8e8SKurt Hackel * in order to avoid sleeping and allocation that occurs in
1496714d8e8SKurt Hackel * heartbeat, master list entries are simply attached to the
1506714d8e8SKurt Hackel * dlm's established heartbeat callbacks. the mle is attached
1516714d8e8SKurt Hackel * when it is created, and since the dlm->spinlock is held at
1526714d8e8SKurt Hackel * that time, any heartbeat event will be properly discovered
1536714d8e8SKurt Hackel * by the mle. the mle needs to be detached from the
1546714d8e8SKurt Hackel * dlm->mle_hb_events list as soon as heartbeat events are no
1556714d8e8SKurt Hackel * longer useful to the mle, and before the mle is freed.
1566714d8e8SKurt Hackel *
1576714d8e8SKurt Hackel * as a general rule, heartbeat events are no longer needed by
1586714d8e8SKurt Hackel * the mle once an "answer" regarding the lock master has been
1596714d8e8SKurt Hackel * received.
1606714d8e8SKurt Hackel */
__dlm_mle_attach_hb_events(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)1616714d8e8SKurt Hackel static inline void __dlm_mle_attach_hb_events(struct dlm_ctxt *dlm,
1626714d8e8SKurt Hackel struct dlm_master_list_entry *mle)
1636714d8e8SKurt Hackel {
1646714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
1656714d8e8SKurt Hackel
1666714d8e8SKurt Hackel list_add_tail(&mle->hb_events, &dlm->mle_hb_events);
1676714d8e8SKurt Hackel }
1686714d8e8SKurt Hackel
1696714d8e8SKurt Hackel
__dlm_mle_detach_hb_events(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)1706714d8e8SKurt Hackel static inline void __dlm_mle_detach_hb_events(struct dlm_ctxt *dlm,
1716714d8e8SKurt Hackel struct dlm_master_list_entry *mle)
1726714d8e8SKurt Hackel {
1736714d8e8SKurt Hackel if (!list_empty(&mle->hb_events))
1746714d8e8SKurt Hackel list_del_init(&mle->hb_events);
1756714d8e8SKurt Hackel }
1766714d8e8SKurt Hackel
1776714d8e8SKurt Hackel
dlm_mle_detach_hb_events(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)1786714d8e8SKurt Hackel static inline void dlm_mle_detach_hb_events(struct dlm_ctxt *dlm,
1796714d8e8SKurt Hackel struct dlm_master_list_entry *mle)
1806714d8e8SKurt Hackel {
1816714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
1826714d8e8SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle);
1836714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
1846714d8e8SKurt Hackel }
1856714d8e8SKurt Hackel
dlm_get_mle_inuse(struct dlm_master_list_entry * mle)186a2bf0477SKurt Hackel static void dlm_get_mle_inuse(struct dlm_master_list_entry *mle)
187a2bf0477SKurt Hackel {
188a2bf0477SKurt Hackel struct dlm_ctxt *dlm;
189a2bf0477SKurt Hackel dlm = mle->dlm;
190a2bf0477SKurt Hackel
191a2bf0477SKurt Hackel assert_spin_locked(&dlm->spinlock);
192a2bf0477SKurt Hackel assert_spin_locked(&dlm->master_lock);
193a2bf0477SKurt Hackel mle->inuse++;
194a2bf0477SKurt Hackel kref_get(&mle->mle_refs);
195a2bf0477SKurt Hackel }
196a2bf0477SKurt Hackel
dlm_put_mle_inuse(struct dlm_master_list_entry * mle)197a2bf0477SKurt Hackel static void dlm_put_mle_inuse(struct dlm_master_list_entry *mle)
198a2bf0477SKurt Hackel {
199a2bf0477SKurt Hackel struct dlm_ctxt *dlm;
200a2bf0477SKurt Hackel dlm = mle->dlm;
201a2bf0477SKurt Hackel
202a2bf0477SKurt Hackel spin_lock(&dlm->spinlock);
203a2bf0477SKurt Hackel spin_lock(&dlm->master_lock);
204a2bf0477SKurt Hackel mle->inuse--;
205a2bf0477SKurt Hackel __dlm_put_mle(mle);
206a2bf0477SKurt Hackel spin_unlock(&dlm->master_lock);
207a2bf0477SKurt Hackel spin_unlock(&dlm->spinlock);
208a2bf0477SKurt Hackel
209a2bf0477SKurt Hackel }
210a2bf0477SKurt Hackel
2116714d8e8SKurt Hackel /* remove from list and free */
__dlm_put_mle(struct dlm_master_list_entry * mle)2126714d8e8SKurt Hackel static void __dlm_put_mle(struct dlm_master_list_entry *mle)
2136714d8e8SKurt Hackel {
2146714d8e8SKurt Hackel struct dlm_ctxt *dlm;
2156714d8e8SKurt Hackel dlm = mle->dlm;
2166714d8e8SKurt Hackel
2176714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
2186714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock);
2192c935bc5SPeter Zijlstra if (!kref_read(&mle->mle_refs)) {
220aa852354SKurt Hackel /* this may or may not crash, but who cares.
221aa852354SKurt Hackel * it's a BUG. */
222aa852354SKurt Hackel mlog(ML_ERROR, "bad mle: %p\n", mle);
223aa852354SKurt Hackel dlm_print_one_mle(mle);
224aa852354SKurt Hackel BUG();
225aa852354SKurt Hackel } else
2266714d8e8SKurt Hackel kref_put(&mle->mle_refs, dlm_mle_release);
2276714d8e8SKurt Hackel }
2286714d8e8SKurt Hackel
2296714d8e8SKurt Hackel
2306714d8e8SKurt Hackel /* must not have any spinlocks coming in */
dlm_put_mle(struct dlm_master_list_entry * mle)2316714d8e8SKurt Hackel static void dlm_put_mle(struct dlm_master_list_entry *mle)
2326714d8e8SKurt Hackel {
2336714d8e8SKurt Hackel struct dlm_ctxt *dlm;
2346714d8e8SKurt Hackel dlm = mle->dlm;
2356714d8e8SKurt Hackel
2366714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
2376714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
2386714d8e8SKurt Hackel __dlm_put_mle(mle);
2396714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
2406714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
2416714d8e8SKurt Hackel }
2426714d8e8SKurt Hackel
dlm_get_mle(struct dlm_master_list_entry * mle)2436714d8e8SKurt Hackel static inline void dlm_get_mle(struct dlm_master_list_entry *mle)
2446714d8e8SKurt Hackel {
2456714d8e8SKurt Hackel kref_get(&mle->mle_refs);
2466714d8e8SKurt Hackel }
2476714d8e8SKurt Hackel
dlm_init_mle(struct dlm_master_list_entry * mle,enum dlm_mle_type type,struct dlm_ctxt * dlm,struct dlm_lock_resource * res,const char * name,unsigned int namelen)2486714d8e8SKurt Hackel static void dlm_init_mle(struct dlm_master_list_entry *mle,
2496714d8e8SKurt Hackel enum dlm_mle_type type,
2506714d8e8SKurt Hackel struct dlm_ctxt *dlm,
2516714d8e8SKurt Hackel struct dlm_lock_resource *res,
2526714d8e8SKurt Hackel const char *name,
2536714d8e8SKurt Hackel unsigned int namelen)
2546714d8e8SKurt Hackel {
2556714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
2566714d8e8SKurt Hackel
2576714d8e8SKurt Hackel mle->dlm = dlm;
2586714d8e8SKurt Hackel mle->type = type;
2592ed6c750SSunil Mushran INIT_HLIST_NODE(&mle->master_hash_node);
2606714d8e8SKurt Hackel INIT_LIST_HEAD(&mle->hb_events);
261*b270f492SJoseph Qi bitmap_zero(mle->maybe_map, O2NM_MAX_NODES);
2626714d8e8SKurt Hackel spin_lock_init(&mle->spinlock);
2636714d8e8SKurt Hackel init_waitqueue_head(&mle->wq);
2646714d8e8SKurt Hackel atomic_set(&mle->woken, 0);
2656714d8e8SKurt Hackel kref_init(&mle->mle_refs);
266*b270f492SJoseph Qi bitmap_zero(mle->response_map, O2NM_MAX_NODES);
2676714d8e8SKurt Hackel mle->master = O2NM_MAX_NODES;
2686714d8e8SKurt Hackel mle->new_master = O2NM_MAX_NODES;
269a2bf0477SKurt Hackel mle->inuse = 0;
2706714d8e8SKurt Hackel
271f77a9a78SSunil Mushran BUG_ON(mle->type != DLM_MLE_BLOCK &&
272f77a9a78SSunil Mushran mle->type != DLM_MLE_MASTER &&
273f77a9a78SSunil Mushran mle->type != DLM_MLE_MIGRATION);
274f77a9a78SSunil Mushran
2756714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) {
2766714d8e8SKurt Hackel BUG_ON(!res);
2777141514bSSunil Mushran mle->mleres = res;
2787141514bSSunil Mushran memcpy(mle->mname, res->lockname.name, res->lockname.len);
2797141514bSSunil Mushran mle->mnamelen = res->lockname.len;
2807141514bSSunil Mushran mle->mnamehash = res->lockname.hash;
281f77a9a78SSunil Mushran } else {
2826714d8e8SKurt Hackel BUG_ON(!name);
2837141514bSSunil Mushran mle->mleres = NULL;
2847141514bSSunil Mushran memcpy(mle->mname, name, namelen);
2857141514bSSunil Mushran mle->mnamelen = namelen;
2867141514bSSunil Mushran mle->mnamehash = dlm_lockid_hash(name, namelen);
2876714d8e8SKurt Hackel }
2886714d8e8SKurt Hackel
2892041d8fdSSunil Mushran atomic_inc(&dlm->mle_tot_count[mle->type]);
2902041d8fdSSunil Mushran atomic_inc(&dlm->mle_cur_count[mle->type]);
2912041d8fdSSunil Mushran
2926714d8e8SKurt Hackel /* copy off the node_map and register hb callbacks on our copy */
293*b270f492SJoseph Qi bitmap_copy(mle->node_map, dlm->domain_map, O2NM_MAX_NODES);
294*b270f492SJoseph Qi bitmap_copy(mle->vote_map, dlm->domain_map, O2NM_MAX_NODES);
2956714d8e8SKurt Hackel clear_bit(dlm->node_num, mle->vote_map);
2966714d8e8SKurt Hackel clear_bit(dlm->node_num, mle->node_map);
2976714d8e8SKurt Hackel
2986714d8e8SKurt Hackel /* attach the mle to the domain node up/down events */
2996714d8e8SKurt Hackel __dlm_mle_attach_hb_events(dlm, mle);
3006714d8e8SKurt Hackel }
3016714d8e8SKurt Hackel
__dlm_unlink_mle(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)3021c084577SSunil Mushran void __dlm_unlink_mle(struct dlm_ctxt *dlm, struct dlm_master_list_entry *mle)
3031c084577SSunil Mushran {
3041c084577SSunil Mushran assert_spin_locked(&dlm->spinlock);
3051c084577SSunil Mushran assert_spin_locked(&dlm->master_lock);
3061c084577SSunil Mushran
3072ed6c750SSunil Mushran if (!hlist_unhashed(&mle->master_hash_node))
3082ed6c750SSunil Mushran hlist_del_init(&mle->master_hash_node);
3091c084577SSunil Mushran }
3101c084577SSunil Mushran
__dlm_insert_mle(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)3111c084577SSunil Mushran void __dlm_insert_mle(struct dlm_ctxt *dlm, struct dlm_master_list_entry *mle)
3121c084577SSunil Mushran {
3132ed6c750SSunil Mushran struct hlist_head *bucket;
3142ed6c750SSunil Mushran
3151c084577SSunil Mushran assert_spin_locked(&dlm->master_lock);
3161c084577SSunil Mushran
3177141514bSSunil Mushran bucket = dlm_master_hash(dlm, mle->mnamehash);
3182ed6c750SSunil Mushran hlist_add_head(&mle->master_hash_node, bucket);
3191c084577SSunil Mushran }
3206714d8e8SKurt Hackel
3216714d8e8SKurt Hackel /* returns 1 if found, 0 if not */
dlm_find_mle(struct dlm_ctxt * dlm,struct dlm_master_list_entry ** mle,char * name,unsigned int namelen)3226714d8e8SKurt Hackel static int dlm_find_mle(struct dlm_ctxt *dlm,
3236714d8e8SKurt Hackel struct dlm_master_list_entry **mle,
3246714d8e8SKurt Hackel char *name, unsigned int namelen)
3256714d8e8SKurt Hackel {
3266714d8e8SKurt Hackel struct dlm_master_list_entry *tmpmle;
3272ed6c750SSunil Mushran struct hlist_head *bucket;
3282ed6c750SSunil Mushran unsigned int hash;
3296714d8e8SKurt Hackel
3306714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock);
3316714d8e8SKurt Hackel
3322ed6c750SSunil Mushran hash = dlm_lockid_hash(name, namelen);
3332ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, hash);
334df53cd3bSDong Fang hlist_for_each_entry(tmpmle, bucket, master_hash_node) {
3356714d8e8SKurt Hackel if (!dlm_mle_equal(dlm, tmpmle, name, namelen))
3366714d8e8SKurt Hackel continue;
3376714d8e8SKurt Hackel dlm_get_mle(tmpmle);
3386714d8e8SKurt Hackel *mle = tmpmle;
3396714d8e8SKurt Hackel return 1;
3406714d8e8SKurt Hackel }
3416714d8e8SKurt Hackel return 0;
3426714d8e8SKurt Hackel }
3436714d8e8SKurt Hackel
dlm_hb_event_notify_attached(struct dlm_ctxt * dlm,int idx,int node_up)3446714d8e8SKurt Hackel void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up)
3456714d8e8SKurt Hackel {
3466714d8e8SKurt Hackel struct dlm_master_list_entry *mle;
3476714d8e8SKurt Hackel
3486714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
3496714d8e8SKurt Hackel
350800deef3SChristoph Hellwig list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) {
3516714d8e8SKurt Hackel if (node_up)
3526714d8e8SKurt Hackel dlm_mle_node_up(dlm, mle, NULL, idx);
3536714d8e8SKurt Hackel else
3546714d8e8SKurt Hackel dlm_mle_node_down(dlm, mle, NULL, idx);
3556714d8e8SKurt Hackel }
3566714d8e8SKurt Hackel }
3576714d8e8SKurt Hackel
dlm_mle_node_down(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle,struct o2nm_node * node,int idx)3586714d8e8SKurt Hackel static void dlm_mle_node_down(struct dlm_ctxt *dlm,
3596714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
3606714d8e8SKurt Hackel struct o2nm_node *node, int idx)
3616714d8e8SKurt Hackel {
3626714d8e8SKurt Hackel spin_lock(&mle->spinlock);
3636714d8e8SKurt Hackel
3646714d8e8SKurt Hackel if (!test_bit(idx, mle->node_map))
3656714d8e8SKurt Hackel mlog(0, "node %u already removed from nodemap!\n", idx);
3666714d8e8SKurt Hackel else
3676714d8e8SKurt Hackel clear_bit(idx, mle->node_map);
3686714d8e8SKurt Hackel
3696714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
3706714d8e8SKurt Hackel }
3716714d8e8SKurt Hackel
dlm_mle_node_up(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle,struct o2nm_node * node,int idx)3726714d8e8SKurt Hackel static void dlm_mle_node_up(struct dlm_ctxt *dlm,
3736714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
3746714d8e8SKurt Hackel struct o2nm_node *node, int idx)
3756714d8e8SKurt Hackel {
3766714d8e8SKurt Hackel spin_lock(&mle->spinlock);
3776714d8e8SKurt Hackel
3786714d8e8SKurt Hackel if (test_bit(idx, mle->node_map))
3796714d8e8SKurt Hackel mlog(0, "node %u already in node map!\n", idx);
3806714d8e8SKurt Hackel else
3816714d8e8SKurt Hackel set_bit(idx, mle->node_map);
3826714d8e8SKurt Hackel
3836714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
3846714d8e8SKurt Hackel }
3856714d8e8SKurt Hackel
3866714d8e8SKurt Hackel
dlm_init_mle_cache(void)3876714d8e8SKurt Hackel int dlm_init_mle_cache(void)
3886714d8e8SKurt Hackel {
38912eb0035SSunil Mushran dlm_mle_cache = kmem_cache_create("o2dlm_mle",
3906714d8e8SKurt Hackel sizeof(struct dlm_master_list_entry),
3916714d8e8SKurt Hackel 0, SLAB_HWCACHE_ALIGN,
39220c2df83SPaul Mundt NULL);
3936714d8e8SKurt Hackel if (dlm_mle_cache == NULL)
3946714d8e8SKurt Hackel return -ENOMEM;
3956714d8e8SKurt Hackel return 0;
3966714d8e8SKurt Hackel }
3976714d8e8SKurt Hackel
dlm_destroy_mle_cache(void)3986714d8e8SKurt Hackel void dlm_destroy_mle_cache(void)
3996714d8e8SKurt Hackel {
4006714d8e8SKurt Hackel kmem_cache_destroy(dlm_mle_cache);
4016714d8e8SKurt Hackel }
4026714d8e8SKurt Hackel
dlm_mle_release(struct kref * kref)4036714d8e8SKurt Hackel static void dlm_mle_release(struct kref *kref)
4046714d8e8SKurt Hackel {
4056714d8e8SKurt Hackel struct dlm_master_list_entry *mle;
4066714d8e8SKurt Hackel struct dlm_ctxt *dlm;
4076714d8e8SKurt Hackel
4086714d8e8SKurt Hackel mle = container_of(kref, struct dlm_master_list_entry, mle_refs);
4096714d8e8SKurt Hackel dlm = mle->dlm;
4106714d8e8SKurt Hackel
4116714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
4126714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock);
4136714d8e8SKurt Hackel
4147141514bSSunil Mushran mlog(0, "Releasing mle for %.*s, type %d\n", mle->mnamelen, mle->mname,
4157141514bSSunil Mushran mle->type);
4162ed6c750SSunil Mushran
4176714d8e8SKurt Hackel /* remove from list if not already */
4181c084577SSunil Mushran __dlm_unlink_mle(dlm, mle);
4196714d8e8SKurt Hackel
4206714d8e8SKurt Hackel /* detach the mle from the domain node up/down events */
4216714d8e8SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle);
4226714d8e8SKurt Hackel
4232041d8fdSSunil Mushran atomic_dec(&dlm->mle_cur_count[mle->type]);
4242041d8fdSSunil Mushran
4256714d8e8SKurt Hackel /* NOTE: kfree under spinlock here.
4266714d8e8SKurt Hackel * if this is bad, we can move this to a freelist. */
4276714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
4286714d8e8SKurt Hackel }
4296714d8e8SKurt Hackel
4306714d8e8SKurt Hackel
4316714d8e8SKurt Hackel /*
4326714d8e8SKurt Hackel * LOCK RESOURCE FUNCTIONS
4336714d8e8SKurt Hackel */
4346714d8e8SKurt Hackel
dlm_init_master_caches(void)435724bdca9SSunil Mushran int dlm_init_master_caches(void)
436724bdca9SSunil Mushran {
437724bdca9SSunil Mushran dlm_lockres_cache = kmem_cache_create("o2dlm_lockres",
438724bdca9SSunil Mushran sizeof(struct dlm_lock_resource),
439724bdca9SSunil Mushran 0, SLAB_HWCACHE_ALIGN, NULL);
440724bdca9SSunil Mushran if (!dlm_lockres_cache)
441724bdca9SSunil Mushran goto bail;
442724bdca9SSunil Mushran
443724bdca9SSunil Mushran dlm_lockname_cache = kmem_cache_create("o2dlm_lockname",
444724bdca9SSunil Mushran DLM_LOCKID_NAME_MAX, 0,
445724bdca9SSunil Mushran SLAB_HWCACHE_ALIGN, NULL);
446724bdca9SSunil Mushran if (!dlm_lockname_cache)
447724bdca9SSunil Mushran goto bail;
448724bdca9SSunil Mushran
449724bdca9SSunil Mushran return 0;
450724bdca9SSunil Mushran bail:
451724bdca9SSunil Mushran dlm_destroy_master_caches();
452724bdca9SSunil Mushran return -ENOMEM;
453724bdca9SSunil Mushran }
454724bdca9SSunil Mushran
dlm_destroy_master_caches(void)455724bdca9SSunil Mushran void dlm_destroy_master_caches(void)
456724bdca9SSunil Mushran {
457724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockname_cache);
45866db6cfdSJoseph Qi dlm_lockname_cache = NULL;
459724bdca9SSunil Mushran
460724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockres_cache);
46166db6cfdSJoseph Qi dlm_lockres_cache = NULL;
46266db6cfdSJoseph Qi }
463724bdca9SSunil Mushran
dlm_lockres_release(struct kref * kref)4646714d8e8SKurt Hackel static void dlm_lockres_release(struct kref *kref)
4656714d8e8SKurt Hackel {
4666714d8e8SKurt Hackel struct dlm_lock_resource *res;
467b0d4f817SSunil Mushran struct dlm_ctxt *dlm;
4686714d8e8SKurt Hackel
4696714d8e8SKurt Hackel res = container_of(kref, struct dlm_lock_resource, refs);
470b0d4f817SSunil Mushran dlm = res->dlm;
4716714d8e8SKurt Hackel
4726714d8e8SKurt Hackel /* This should not happen -- all lockres' have a name
4736714d8e8SKurt Hackel * associated with them at init time. */
4746714d8e8SKurt Hackel BUG_ON(!res->lockname.name);
4756714d8e8SKurt Hackel
4766714d8e8SKurt Hackel mlog(0, "destroying lockres %.*s\n", res->lockname.len,
4776714d8e8SKurt Hackel res->lockname.name);
4786714d8e8SKurt Hackel
4796800791aSSunil Mushran atomic_dec(&dlm->res_cur_count);
4806800791aSSunil Mushran
481a7f90d83SKurt Hackel if (!hlist_unhashed(&res->hash_node) ||
482a7f90d83SKurt Hackel !list_empty(&res->granted) ||
483a7f90d83SKurt Hackel !list_empty(&res->converting) ||
484a7f90d83SKurt Hackel !list_empty(&res->blocked) ||
485a7f90d83SKurt Hackel !list_empty(&res->dirty) ||
486a7f90d83SKurt Hackel !list_empty(&res->recovering) ||
487a7f90d83SKurt Hackel !list_empty(&res->purge)) {
488a7f90d83SKurt Hackel mlog(ML_ERROR,
489a7f90d83SKurt Hackel "Going to BUG for resource %.*s."
490a7f90d83SKurt Hackel " We're on a list! [%c%c%c%c%c%c%c]\n",
491a7f90d83SKurt Hackel res->lockname.len, res->lockname.name,
492a7f90d83SKurt Hackel !hlist_unhashed(&res->hash_node) ? 'H' : ' ',
493a7f90d83SKurt Hackel !list_empty(&res->granted) ? 'G' : ' ',
494a7f90d83SKurt Hackel !list_empty(&res->converting) ? 'C' : ' ',
495a7f90d83SKurt Hackel !list_empty(&res->blocked) ? 'B' : ' ',
496a7f90d83SKurt Hackel !list_empty(&res->dirty) ? 'D' : ' ',
497a7f90d83SKurt Hackel !list_empty(&res->recovering) ? 'R' : ' ',
498a7f90d83SKurt Hackel !list_empty(&res->purge) ? 'P' : ' ');
499a7f90d83SKurt Hackel
500a7f90d83SKurt Hackel dlm_print_one_lock_resource(res);
501a7f90d83SKurt Hackel }
502a7f90d83SKurt Hackel
5036714d8e8SKurt Hackel /* By the time we're ready to blow this guy away, we shouldn't
5046714d8e8SKurt Hackel * be on any lists. */
50581f2094aSMark Fasheh BUG_ON(!hlist_unhashed(&res->hash_node));
5066714d8e8SKurt Hackel BUG_ON(!list_empty(&res->granted));
5076714d8e8SKurt Hackel BUG_ON(!list_empty(&res->converting));
5086714d8e8SKurt Hackel BUG_ON(!list_empty(&res->blocked));
5096714d8e8SKurt Hackel BUG_ON(!list_empty(&res->dirty));
5106714d8e8SKurt Hackel BUG_ON(!list_empty(&res->recovering));
5116714d8e8SKurt Hackel BUG_ON(!list_empty(&res->purge));
5126714d8e8SKurt Hackel
513724bdca9SSunil Mushran kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name);
5146714d8e8SKurt Hackel
515724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res);
5166714d8e8SKurt Hackel }
5176714d8e8SKurt Hackel
dlm_lockres_put(struct dlm_lock_resource * res)5186714d8e8SKurt Hackel void dlm_lockres_put(struct dlm_lock_resource *res)
5196714d8e8SKurt Hackel {
5206714d8e8SKurt Hackel kref_put(&res->refs, dlm_lockres_release);
5216714d8e8SKurt Hackel }
5226714d8e8SKurt Hackel
dlm_init_lockres(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,const char * name,unsigned int namelen)5236714d8e8SKurt Hackel static void dlm_init_lockres(struct dlm_ctxt *dlm,
5246714d8e8SKurt Hackel struct dlm_lock_resource *res,
5256714d8e8SKurt Hackel const char *name, unsigned int namelen)
5266714d8e8SKurt Hackel {
5276714d8e8SKurt Hackel char *qname;
5286714d8e8SKurt Hackel
5296714d8e8SKurt Hackel /* If we memset here, we lose our reference to the kmalloc'd
5306714d8e8SKurt Hackel * res->lockname.name, so be sure to init every field
5316714d8e8SKurt Hackel * correctly! */
5326714d8e8SKurt Hackel
5336714d8e8SKurt Hackel qname = (char *) res->lockname.name;
5346714d8e8SKurt Hackel memcpy(qname, name, namelen);
5356714d8e8SKurt Hackel
5366714d8e8SKurt Hackel res->lockname.len = namelen;
537a3d33291SMark Fasheh res->lockname.hash = dlm_lockid_hash(name, namelen);
5386714d8e8SKurt Hackel
5396714d8e8SKurt Hackel init_waitqueue_head(&res->wq);
5406714d8e8SKurt Hackel spin_lock_init(&res->spinlock);
54181f2094aSMark Fasheh INIT_HLIST_NODE(&res->hash_node);
5426714d8e8SKurt Hackel INIT_LIST_HEAD(&res->granted);
5436714d8e8SKurt Hackel INIT_LIST_HEAD(&res->converting);
5446714d8e8SKurt Hackel INIT_LIST_HEAD(&res->blocked);
5456714d8e8SKurt Hackel INIT_LIST_HEAD(&res->dirty);
5466714d8e8SKurt Hackel INIT_LIST_HEAD(&res->recovering);
5476714d8e8SKurt Hackel INIT_LIST_HEAD(&res->purge);
54829576f8bSSunil Mushran INIT_LIST_HEAD(&res->tracking);
5496714d8e8SKurt Hackel atomic_set(&res->asts_reserved, 0);
5506714d8e8SKurt Hackel res->migration_pending = 0;
551ba2bf218SKurt Hackel res->inflight_locks = 0;
552ac4fef4dSXue jiufei res->inflight_assert_workers = 0;
5536714d8e8SKurt Hackel
554b0d4f817SSunil Mushran res->dlm = dlm;
555b0d4f817SSunil Mushran
5566714d8e8SKurt Hackel kref_init(&res->refs);
5576714d8e8SKurt Hackel
5586800791aSSunil Mushran atomic_inc(&dlm->res_tot_count);
5596800791aSSunil Mushran atomic_inc(&dlm->res_cur_count);
5606800791aSSunil Mushran
5616714d8e8SKurt Hackel /* just for consistency */
5626714d8e8SKurt Hackel spin_lock(&res->spinlock);
5636714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN);
5646714d8e8SKurt Hackel spin_unlock(&res->spinlock);
5656714d8e8SKurt Hackel
5666714d8e8SKurt Hackel res->state = DLM_LOCK_RES_IN_PROGRESS;
5676714d8e8SKurt Hackel
5686714d8e8SKurt Hackel res->last_used = 0;
5696714d8e8SKurt Hackel
570cbe355f5SAshish Samant spin_lock(&dlm->track_lock);
57129576f8bSSunil Mushran list_add_tail(&res->tracking, &dlm->tracking_list);
572cbe355f5SAshish Samant spin_unlock(&dlm->track_lock);
57329576f8bSSunil Mushran
5746714d8e8SKurt Hackel memset(res->lvb, 0, DLM_LVB_LEN);
575*b270f492SJoseph Qi bitmap_zero(res->refmap, O2NM_MAX_NODES);
5766714d8e8SKurt Hackel }
5776714d8e8SKurt Hackel
dlm_new_lockres(struct dlm_ctxt * dlm,const char * name,unsigned int namelen)5786714d8e8SKurt Hackel struct dlm_lock_resource *dlm_new_lockres(struct dlm_ctxt *dlm,
5796714d8e8SKurt Hackel const char *name,
5806714d8e8SKurt Hackel unsigned int namelen)
5816714d8e8SKurt Hackel {
582724bdca9SSunil Mushran struct dlm_lock_resource *res = NULL;
5836714d8e8SKurt Hackel
5843914ed0cSJulia Lawall res = kmem_cache_zalloc(dlm_lockres_cache, GFP_NOFS);
5856714d8e8SKurt Hackel if (!res)
586724bdca9SSunil Mushran goto error;
5876714d8e8SKurt Hackel
5883914ed0cSJulia Lawall res->lockname.name = kmem_cache_zalloc(dlm_lockname_cache, GFP_NOFS);
589724bdca9SSunil Mushran if (!res->lockname.name)
590724bdca9SSunil Mushran goto error;
5916714d8e8SKurt Hackel
5926714d8e8SKurt Hackel dlm_init_lockres(dlm, res, name, namelen);
5936714d8e8SKurt Hackel return res;
594724bdca9SSunil Mushran
595724bdca9SSunil Mushran error:
596724bdca9SSunil Mushran if (res)
597724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res);
598724bdca9SSunil Mushran return NULL;
5996714d8e8SKurt Hackel }
6006714d8e8SKurt Hackel
dlm_lockres_set_refmap_bit(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,int bit)6018d400b81SSunil Mushran void dlm_lockres_set_refmap_bit(struct dlm_ctxt *dlm,
6028d400b81SSunil Mushran struct dlm_lock_resource *res, int bit)
603ba2bf218SKurt Hackel {
6048d400b81SSunil Mushran assert_spin_locked(&res->spinlock);
6058d400b81SSunil Mushran
6068d400b81SSunil Mushran mlog(0, "res %.*s, set node %u, %ps()\n", res->lockname.len,
6078d400b81SSunil Mushran res->lockname.name, bit, __builtin_return_address(0));
6088d400b81SSunil Mushran
6098d400b81SSunil Mushran set_bit(bit, res->refmap);
6108d400b81SSunil Mushran }
6118d400b81SSunil Mushran
dlm_lockres_clear_refmap_bit(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,int bit)6128d400b81SSunil Mushran void dlm_lockres_clear_refmap_bit(struct dlm_ctxt *dlm,
6138d400b81SSunil Mushran struct dlm_lock_resource *res, int bit)
6148d400b81SSunil Mushran {
6158d400b81SSunil Mushran assert_spin_locked(&res->spinlock);
6168d400b81SSunil Mushran
6178d400b81SSunil Mushran mlog(0, "res %.*s, clr node %u, %ps()\n", res->lockname.len,
6188d400b81SSunil Mushran res->lockname.name, bit, __builtin_return_address(0));
6198d400b81SSunil Mushran
6208d400b81SSunil Mushran clear_bit(bit, res->refmap);
6218d400b81SSunil Mushran }
6228d400b81SSunil Mushran
__dlm_lockres_grab_inflight_ref(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)6235760a97cSJoseph Qi static void __dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm,
6248d400b81SSunil Mushran struct dlm_lock_resource *res)
6258d400b81SSunil Mushran {
626ba2bf218SKurt Hackel res->inflight_locks++;
627ff0a522eSSunil Mushran
6288d400b81SSunil Mushran mlog(0, "%s: res %.*s, inflight++: now %u, %ps()\n", dlm->name,
6298d400b81SSunil Mushran res->lockname.len, res->lockname.name, res->inflight_locks,
6308d400b81SSunil Mushran __builtin_return_address(0));
631ba2bf218SKurt Hackel }
632ba2bf218SKurt Hackel
dlm_lockres_grab_inflight_ref(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)6335760a97cSJoseph Qi void dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm,
6345760a97cSJoseph Qi struct dlm_lock_resource *res)
6355760a97cSJoseph Qi {
6365760a97cSJoseph Qi assert_spin_locked(&res->spinlock);
6375760a97cSJoseph Qi __dlm_lockres_grab_inflight_ref(dlm, res);
6385760a97cSJoseph Qi }
6395760a97cSJoseph Qi
dlm_lockres_drop_inflight_ref(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)6408d400b81SSunil Mushran void dlm_lockres_drop_inflight_ref(struct dlm_ctxt *dlm,
6418d400b81SSunil Mushran struct dlm_lock_resource *res)
642ba2bf218SKurt Hackel {
643ba2bf218SKurt Hackel assert_spin_locked(&res->spinlock);
644ba2bf218SKurt Hackel
645ba2bf218SKurt Hackel BUG_ON(res->inflight_locks == 0);
6468d400b81SSunil Mushran
647ba2bf218SKurt Hackel res->inflight_locks--;
648ff0a522eSSunil Mushran
6498d400b81SSunil Mushran mlog(0, "%s: res %.*s, inflight--: now %u, %ps()\n", dlm->name,
6508d400b81SSunil Mushran res->lockname.len, res->lockname.name, res->inflight_locks,
6518d400b81SSunil Mushran __builtin_return_address(0));
6528d400b81SSunil Mushran
653ba2bf218SKurt Hackel wake_up(&res->wq);
654ba2bf218SKurt Hackel }
655ba2bf218SKurt Hackel
__dlm_lockres_grab_inflight_worker(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)656ac4fef4dSXue jiufei void __dlm_lockres_grab_inflight_worker(struct dlm_ctxt *dlm,
657ac4fef4dSXue jiufei struct dlm_lock_resource *res)
658ac4fef4dSXue jiufei {
659ac4fef4dSXue jiufei assert_spin_locked(&res->spinlock);
660ac4fef4dSXue jiufei res->inflight_assert_workers++;
661ac4fef4dSXue jiufei mlog(0, "%s:%.*s: inflight assert worker++: now %u\n",
662ac4fef4dSXue jiufei dlm->name, res->lockname.len, res->lockname.name,
663ac4fef4dSXue jiufei res->inflight_assert_workers);
664ac4fef4dSXue jiufei }
665ac4fef4dSXue jiufei
__dlm_lockres_drop_inflight_worker(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)666ac4fef4dSXue jiufei static void __dlm_lockres_drop_inflight_worker(struct dlm_ctxt *dlm,
667ac4fef4dSXue jiufei struct dlm_lock_resource *res)
668ac4fef4dSXue jiufei {
669ac4fef4dSXue jiufei assert_spin_locked(&res->spinlock);
670ac4fef4dSXue jiufei BUG_ON(res->inflight_assert_workers == 0);
671ac4fef4dSXue jiufei res->inflight_assert_workers--;
672ac4fef4dSXue jiufei mlog(0, "%s:%.*s: inflight assert worker--: now %u\n",
673ac4fef4dSXue jiufei dlm->name, res->lockname.len, res->lockname.name,
674ac4fef4dSXue jiufei res->inflight_assert_workers);
675ac4fef4dSXue jiufei }
676ac4fef4dSXue jiufei
dlm_lockres_drop_inflight_worker(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)677ac4fef4dSXue jiufei static void dlm_lockres_drop_inflight_worker(struct dlm_ctxt *dlm,
678ac4fef4dSXue jiufei struct dlm_lock_resource *res)
679ac4fef4dSXue jiufei {
680ac4fef4dSXue jiufei spin_lock(&res->spinlock);
681ac4fef4dSXue jiufei __dlm_lockres_drop_inflight_worker(dlm, res);
682ac4fef4dSXue jiufei spin_unlock(&res->spinlock);
683ac4fef4dSXue jiufei }
684ac4fef4dSXue jiufei
6856714d8e8SKurt Hackel /*
6866714d8e8SKurt Hackel * lookup a lock resource by name.
6876714d8e8SKurt Hackel * may already exist in the hashtable.
6886714d8e8SKurt Hackel * lockid is null terminated
6896714d8e8SKurt Hackel *
6906714d8e8SKurt Hackel * if not, allocate enough for the lockres and for
6916714d8e8SKurt Hackel * the temporary structure used in doing the mastering.
6926714d8e8SKurt Hackel *
6936714d8e8SKurt Hackel * also, do a lookup in the dlm->master_list to see
6946714d8e8SKurt Hackel * if another node has begun mastering the same lock.
6956714d8e8SKurt Hackel * if so, there should be a block entry in there
6966714d8e8SKurt Hackel * for this name, and we should *not* attempt to master
6976714d8e8SKurt Hackel * the lock here. need to wait around for that node
6986714d8e8SKurt Hackel * to assert_master (or die).
6996714d8e8SKurt Hackel *
7006714d8e8SKurt Hackel */
dlm_get_lock_resource(struct dlm_ctxt * dlm,const char * lockid,int namelen,int flags)7016714d8e8SKurt Hackel struct dlm_lock_resource * dlm_get_lock_resource(struct dlm_ctxt *dlm,
7026714d8e8SKurt Hackel const char *lockid,
7033384f3dfSMark Fasheh int namelen,
7046714d8e8SKurt Hackel int flags)
7056714d8e8SKurt Hackel {
7066714d8e8SKurt Hackel struct dlm_lock_resource *tmpres=NULL, *res=NULL;
7076714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL;
7086714d8e8SKurt Hackel struct dlm_master_list_entry *alloc_mle = NULL;
7096714d8e8SKurt Hackel int blocked = 0;
7106714d8e8SKurt Hackel int ret, nodenum;
7116714d8e8SKurt Hackel struct dlm_node_iter iter;
7123384f3dfSMark Fasheh unsigned int hash;
7136714d8e8SKurt Hackel int tries = 0;
714c03872f5SKurt Hackel int bit, wait_on_recovery = 0;
7156714d8e8SKurt Hackel
7166714d8e8SKurt Hackel BUG_ON(!lockid);
7176714d8e8SKurt Hackel
718a3d33291SMark Fasheh hash = dlm_lockid_hash(lockid, namelen);
7196714d8e8SKurt Hackel
7206714d8e8SKurt Hackel mlog(0, "get lockres %s (len %d)\n", lockid, namelen);
7216714d8e8SKurt Hackel
7226714d8e8SKurt Hackel lookup:
7236714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
724ba2bf218SKurt Hackel tmpres = __dlm_lookup_lockres_full(dlm, lockid, namelen, hash);
7256714d8e8SKurt Hackel if (tmpres) {
7267b791d68SSunil Mushran spin_unlock(&dlm->spinlock);
727ba2bf218SKurt Hackel spin_lock(&tmpres->spinlock);
728b1432a2aSJunxiao Bi
729b1432a2aSJunxiao Bi /*
730b1432a2aSJunxiao Bi * Right after dlm spinlock was released, dlm_thread could have
731b1432a2aSJunxiao Bi * purged the lockres. Check if lockres got unhashed. If so
732b1432a2aSJunxiao Bi * start over.
733b1432a2aSJunxiao Bi */
734b1432a2aSJunxiao Bi if (hlist_unhashed(&tmpres->hash_node)) {
735b1432a2aSJunxiao Bi spin_unlock(&tmpres->spinlock);
736b1432a2aSJunxiao Bi dlm_lockres_put(tmpres);
737b1432a2aSJunxiao Bi tmpres = NULL;
738b1432a2aSJunxiao Bi goto lookup;
739b1432a2aSJunxiao Bi }
740b1432a2aSJunxiao Bi
741ff0a522eSSunil Mushran /* Wait on the thread that is mastering the resource */
7427b791d68SSunil Mushran if (tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN) {
7437b791d68SSunil Mushran __dlm_wait_on_lockres(tmpres);
7447b791d68SSunil Mushran BUG_ON(tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN);
745ba2bf218SKurt Hackel spin_unlock(&tmpres->spinlock);
746ba2bf218SKurt Hackel dlm_lockres_put(tmpres);
747ba2bf218SKurt Hackel tmpres = NULL;
748ba2bf218SKurt Hackel goto lookup;
749ba2bf218SKurt Hackel }
750ba2bf218SKurt Hackel
751ff0a522eSSunil Mushran /* Wait on the resource purge to complete before continuing */
752ff0a522eSSunil Mushran if (tmpres->state & DLM_LOCK_RES_DROPPING_REF) {
753ff0a522eSSunil Mushran BUG_ON(tmpres->owner == dlm->node_num);
754ff0a522eSSunil Mushran __dlm_wait_on_lockres_flags(tmpres,
755ff0a522eSSunil Mushran DLM_LOCK_RES_DROPPING_REF);
756ff0a522eSSunil Mushran spin_unlock(&tmpres->spinlock);
757ff0a522eSSunil Mushran dlm_lockres_put(tmpres);
758ff0a522eSSunil Mushran tmpres = NULL;
759ff0a522eSSunil Mushran goto lookup;
760ff0a522eSSunil Mushran }
761ff0a522eSSunil Mushran
762ff0a522eSSunil Mushran /* Grab inflight ref to pin the resource */
763ff0a522eSSunil Mushran dlm_lockres_grab_inflight_ref(dlm, tmpres);
764ff0a522eSSunil Mushran
765ff0a522eSSunil Mushran spin_unlock(&tmpres->spinlock);
766f57a22ddSYiwen Jiang if (res) {
767f57a22ddSYiwen Jiang spin_lock(&dlm->track_lock);
768f57a22ddSYiwen Jiang if (!list_empty(&res->tracking))
769f57a22ddSYiwen Jiang list_del_init(&res->tracking);
770f57a22ddSYiwen Jiang else
771f57a22ddSYiwen Jiang mlog(ML_ERROR, "Resource %.*s not "
772f57a22ddSYiwen Jiang "on the Tracking list\n",
773f57a22ddSYiwen Jiang res->lockname.len,
774f57a22ddSYiwen Jiang res->lockname.name);
775f57a22ddSYiwen Jiang spin_unlock(&dlm->track_lock);
7766714d8e8SKurt Hackel dlm_lockres_put(res);
777f57a22ddSYiwen Jiang }
7786714d8e8SKurt Hackel res = tmpres;
7796714d8e8SKurt Hackel goto leave;
7806714d8e8SKurt Hackel }
7816714d8e8SKurt Hackel
7826714d8e8SKurt Hackel if (!res) {
7836714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
7846714d8e8SKurt Hackel mlog(0, "allocating a new resource\n");
7856714d8e8SKurt Hackel /* nothing found and we need to allocate one. */
7863914ed0cSJulia Lawall alloc_mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS);
7876714d8e8SKurt Hackel if (!alloc_mle)
7886714d8e8SKurt Hackel goto leave;
7896714d8e8SKurt Hackel res = dlm_new_lockres(dlm, lockid, namelen);
7906714d8e8SKurt Hackel if (!res)
7916714d8e8SKurt Hackel goto leave;
7926714d8e8SKurt Hackel goto lookup;
7936714d8e8SKurt Hackel }
7946714d8e8SKurt Hackel
7956714d8e8SKurt Hackel mlog(0, "no lockres found, allocated our own: %p\n", res);
7966714d8e8SKurt Hackel
7976714d8e8SKurt Hackel if (flags & LKM_LOCAL) {
7986714d8e8SKurt Hackel /* caller knows it's safe to assume it's not mastered elsewhere
7996714d8e8SKurt Hackel * DONE! return right away */
8006714d8e8SKurt Hackel spin_lock(&res->spinlock);
8016714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, dlm->node_num);
8026714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res);
803ba2bf218SKurt Hackel dlm_lockres_grab_inflight_ref(dlm, res);
8046714d8e8SKurt Hackel spin_unlock(&res->spinlock);
8056714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
8066714d8e8SKurt Hackel /* lockres still marked IN_PROGRESS */
8076714d8e8SKurt Hackel goto wake_waiters;
8086714d8e8SKurt Hackel }
8096714d8e8SKurt Hackel
8106714d8e8SKurt Hackel /* check master list to see if another node has started mastering it */
8116714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
8126714d8e8SKurt Hackel
8136714d8e8SKurt Hackel /* if we found a block, wait for lock to be mastered by another node */
8146714d8e8SKurt Hackel blocked = dlm_find_mle(dlm, &mle, (char *)lockid, namelen);
8156714d8e8SKurt Hackel if (blocked) {
816ba2bf218SKurt Hackel int mig;
8176714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) {
8186714d8e8SKurt Hackel mlog(ML_ERROR, "master entry for nonexistent lock!\n");
8196714d8e8SKurt Hackel BUG();
820ba2bf218SKurt Hackel }
821ba2bf218SKurt Hackel mig = (mle->type == DLM_MLE_MIGRATION);
822ba2bf218SKurt Hackel /* if there is a migration in progress, let the migration
823ba2bf218SKurt Hackel * finish before continuing. we can wait for the absence
824ba2bf218SKurt Hackel * of the MIGRATION mle: either the migrate finished or
825ba2bf218SKurt Hackel * one of the nodes died and the mle was cleaned up.
826ba2bf218SKurt Hackel * if there is a BLOCK here, but it already has a master
827ba2bf218SKurt Hackel * set, we are too late. the master does not have a ref
828ba2bf218SKurt Hackel * for us in the refmap. detach the mle and drop it.
829ba2bf218SKurt Hackel * either way, go back to the top and start over. */
830ba2bf218SKurt Hackel if (mig || mle->master != O2NM_MAX_NODES) {
831ba2bf218SKurt Hackel BUG_ON(mig && mle->master == dlm->node_num);
832ba2bf218SKurt Hackel /* we arrived too late. the master does not
833ba2bf218SKurt Hackel * have a ref for us. retry. */
834ba2bf218SKurt Hackel mlog(0, "%s:%.*s: late on %s\n",
835ba2bf218SKurt Hackel dlm->name, namelen, lockid,
836ba2bf218SKurt Hackel mig ? "MIGRATION" : "BLOCK");
8376714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
8386714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
8396714d8e8SKurt Hackel
8406714d8e8SKurt Hackel /* master is known, detach */
841ba2bf218SKurt Hackel if (!mig)
8426714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
8436714d8e8SKurt Hackel dlm_put_mle(mle);
8446714d8e8SKurt Hackel mle = NULL;
84525985edcSLucas De Marchi /* this is lame, but we can't wait on either
846ba2bf218SKurt Hackel * the mle or lockres waitqueue here */
847ba2bf218SKurt Hackel if (mig)
848ba2bf218SKurt Hackel msleep(100);
849ba2bf218SKurt Hackel goto lookup;
8506714d8e8SKurt Hackel }
8516714d8e8SKurt Hackel } else {
8526714d8e8SKurt Hackel /* go ahead and try to master lock on this node */
8536714d8e8SKurt Hackel mle = alloc_mle;
8546714d8e8SKurt Hackel /* make sure this does not get freed below */
8556714d8e8SKurt Hackel alloc_mle = NULL;
8566714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MASTER, dlm, res, NULL, 0);
8576714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map);
8581c084577SSunil Mushran __dlm_insert_mle(dlm, mle);
859c03872f5SKurt Hackel
860c03872f5SKurt Hackel /* still holding the dlm spinlock, check the recovery map
861c03872f5SKurt Hackel * to see if there are any nodes that still need to be
862c03872f5SKurt Hackel * considered. these will not appear in the mle nodemap
863c03872f5SKurt Hackel * but they might own this lockres. wait on them. */
864b5c7e7ecSYury Norov bit = find_first_bit(dlm->recovery_map, O2NM_MAX_NODES);
865c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) {
8668decab3cSSunil Mushran mlog(0, "%s: res %.*s, At least one node (%d) "
8678decab3cSSunil Mushran "to recover before lock mastery can begin\n",
868c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit);
869c03872f5SKurt Hackel wait_on_recovery = 1;
870c03872f5SKurt Hackel }
8716714d8e8SKurt Hackel }
8726714d8e8SKurt Hackel
8736714d8e8SKurt Hackel /* at this point there is either a DLM_MLE_BLOCK or a
8746714d8e8SKurt Hackel * DLM_MLE_MASTER on the master list, so it's safe to add the
8756714d8e8SKurt Hackel * lockres to the hashtable. anyone who finds the lock will
8766714d8e8SKurt Hackel * still have to wait on the IN_PROGRESS. */
8776714d8e8SKurt Hackel
8786714d8e8SKurt Hackel /* finally add the lockres to its hash bucket */
8796714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res);
8808d400b81SSunil Mushran
8815760a97cSJoseph Qi /* since this lockres is new it doesn't not require the spinlock */
8825760a97cSJoseph Qi __dlm_lockres_grab_inflight_ref(dlm, res);
883ba2bf218SKurt Hackel
8846714d8e8SKurt Hackel /* get an extra ref on the mle in case this is a BLOCK
8856714d8e8SKurt Hackel * if so, the creator of the BLOCK may try to put the last
8866714d8e8SKurt Hackel * ref at this time in the assert master handler, so we
8876714d8e8SKurt Hackel * need an extra one to keep from a bad ptr deref. */
888a2bf0477SKurt Hackel dlm_get_mle_inuse(mle);
8896714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
8906714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
8916714d8e8SKurt Hackel
892e7e69eb3SKurt Hackel redo_request:
893c03872f5SKurt Hackel while (wait_on_recovery) {
894c03872f5SKurt Hackel /* any cluster changes that occurred after dropping the
895c03872f5SKurt Hackel * dlm spinlock would be detectable be a change on the mle,
896c03872f5SKurt Hackel * so we only need to clear out the recovery map once. */
897c03872f5SKurt Hackel if (dlm_is_recovery_lock(lockid, namelen)) {
8988decab3cSSunil Mushran mlog(0, "%s: Recovery map is not empty, but must "
8998decab3cSSunil Mushran "master $RECOVERY lock now\n", dlm->name);
900c03872f5SKurt Hackel if (!dlm_pre_master_reco_lockres(dlm, res))
901c03872f5SKurt Hackel wait_on_recovery = 0;
902c03872f5SKurt Hackel else {
903c03872f5SKurt Hackel mlog(0, "%s: waiting 500ms for heartbeat state "
904c03872f5SKurt Hackel "change\n", dlm->name);
905c03872f5SKurt Hackel msleep(500);
906c03872f5SKurt Hackel }
907c03872f5SKurt Hackel continue;
908c03872f5SKurt Hackel }
909c03872f5SKurt Hackel
910c03872f5SKurt Hackel dlm_kick_recovery_thread(dlm);
911aa087b84SKurt Hackel msleep(1000);
912c03872f5SKurt Hackel dlm_wait_for_recovery(dlm);
913c03872f5SKurt Hackel
914c03872f5SKurt Hackel spin_lock(&dlm->spinlock);
915b5c7e7ecSYury Norov bit = find_first_bit(dlm->recovery_map, O2NM_MAX_NODES);
916c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) {
9178decab3cSSunil Mushran mlog(0, "%s: res %.*s, At least one node (%d) "
9188decab3cSSunil Mushran "to recover before lock mastery can begin\n",
919c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit);
920c03872f5SKurt Hackel wait_on_recovery = 1;
921c03872f5SKurt Hackel } else
922c03872f5SKurt Hackel wait_on_recovery = 0;
923c03872f5SKurt Hackel spin_unlock(&dlm->spinlock);
924b7084ab5SKurt Hackel
925b7084ab5SKurt Hackel if (wait_on_recovery)
926b7084ab5SKurt Hackel dlm_wait_for_node_recovery(dlm, bit, 10000);
927c03872f5SKurt Hackel }
928c03872f5SKurt Hackel
9296714d8e8SKurt Hackel /* must wait for lock to be mastered elsewhere */
9306714d8e8SKurt Hackel if (blocked)
9316714d8e8SKurt Hackel goto wait;
9326714d8e8SKurt Hackel
9336714d8e8SKurt Hackel ret = -EINVAL;
9346714d8e8SKurt Hackel dlm_node_iter_init(mle->vote_map, &iter);
9356714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {
936ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, nodenum);
9376714d8e8SKurt Hackel if (ret < 0)
9386714d8e8SKurt Hackel mlog_errno(ret);
9396714d8e8SKurt Hackel if (mle->master != O2NM_MAX_NODES) {
9406714d8e8SKurt Hackel /* found a master ! */
9419c6510a5SKurt Hackel if (mle->master <= nodenum)
9426714d8e8SKurt Hackel break;
9439c6510a5SKurt Hackel /* if our master request has not reached the master
9449c6510a5SKurt Hackel * yet, keep going until it does. this is how the
9459c6510a5SKurt Hackel * master will know that asserts are needed back to
9469c6510a5SKurt Hackel * the lower nodes. */
9478decab3cSSunil Mushran mlog(0, "%s: res %.*s, Requests only up to %u but "
9488decab3cSSunil Mushran "master is %u, keep going\n", dlm->name, namelen,
9499c6510a5SKurt Hackel lockid, nodenum, mle->master);
9506714d8e8SKurt Hackel }
9516714d8e8SKurt Hackel }
9526714d8e8SKurt Hackel
9536714d8e8SKurt Hackel wait:
9546714d8e8SKurt Hackel /* keep going until the response map includes all nodes */
9556714d8e8SKurt Hackel ret = dlm_wait_for_lock_mastery(dlm, res, mle, &blocked);
9566714d8e8SKurt Hackel if (ret < 0) {
957e7e69eb3SKurt Hackel wait_on_recovery = 1;
9588decab3cSSunil Mushran mlog(0, "%s: res %.*s, Node map changed, redo the master "
9598decab3cSSunil Mushran "request now, blocked=%d\n", dlm->name, res->lockname.len,
9606714d8e8SKurt Hackel res->lockname.name, blocked);
9616714d8e8SKurt Hackel if (++tries > 20) {
9628decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, Spinning on "
9636714d8e8SKurt Hackel "dlm_wait_for_lock_mastery, blocked = %d\n",
9646714d8e8SKurt Hackel dlm->name, res->lockname.len,
9656714d8e8SKurt Hackel res->lockname.name, blocked);
9666714d8e8SKurt Hackel dlm_print_one_lock_resource(res);
9678a9343faSMark Fasheh dlm_print_one_mle(mle);
9686714d8e8SKurt Hackel tries = 0;
9696714d8e8SKurt Hackel }
9706714d8e8SKurt Hackel goto redo_request;
9716714d8e8SKurt Hackel }
9726714d8e8SKurt Hackel
9738decab3cSSunil Mushran mlog(0, "%s: res %.*s, Mastered by %u\n", dlm->name, res->lockname.len,
9748decab3cSSunil Mushran res->lockname.name, res->owner);
9756714d8e8SKurt Hackel /* make sure we never continue without this */
9766714d8e8SKurt Hackel BUG_ON(res->owner == O2NM_MAX_NODES);
9776714d8e8SKurt Hackel
9786714d8e8SKurt Hackel /* master is known, detach if not already detached */
9796714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
9806714d8e8SKurt Hackel dlm_put_mle(mle);
9816714d8e8SKurt Hackel /* put the extra ref */
982a2bf0477SKurt Hackel dlm_put_mle_inuse(mle);
9836714d8e8SKurt Hackel
9846714d8e8SKurt Hackel wake_waiters:
9856714d8e8SKurt Hackel spin_lock(&res->spinlock);
9866714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_IN_PROGRESS;
9876714d8e8SKurt Hackel spin_unlock(&res->spinlock);
9886714d8e8SKurt Hackel wake_up(&res->wq);
9896714d8e8SKurt Hackel
9906714d8e8SKurt Hackel leave:
9916714d8e8SKurt Hackel /* need to free the unused mle */
9926714d8e8SKurt Hackel if (alloc_mle)
9936714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, alloc_mle);
9946714d8e8SKurt Hackel
9956714d8e8SKurt Hackel return res;
9966714d8e8SKurt Hackel }
9976714d8e8SKurt Hackel
9986714d8e8SKurt Hackel
9996714d8e8SKurt Hackel #define DLM_MASTERY_TIMEOUT_MS 5000
10006714d8e8SKurt Hackel
dlm_wait_for_lock_mastery(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,struct dlm_master_list_entry * mle,int * blocked)10016714d8e8SKurt Hackel static int dlm_wait_for_lock_mastery(struct dlm_ctxt *dlm,
10026714d8e8SKurt Hackel struct dlm_lock_resource *res,
10036714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
10046714d8e8SKurt Hackel int *blocked)
10056714d8e8SKurt Hackel {
10066714d8e8SKurt Hackel u8 m;
10076714d8e8SKurt Hackel int ret, bit;
10086714d8e8SKurt Hackel int map_changed, voting_done;
10096714d8e8SKurt Hackel int assert, sleep;
10106714d8e8SKurt Hackel
10116714d8e8SKurt Hackel recheck:
10126714d8e8SKurt Hackel ret = 0;
10136714d8e8SKurt Hackel assert = 0;
10146714d8e8SKurt Hackel
10156714d8e8SKurt Hackel /* check if another node has already become the owner */
10166714d8e8SKurt Hackel spin_lock(&res->spinlock);
10176714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
10189c6510a5SKurt Hackel mlog(0, "%s:%.*s: owner is suddenly %u\n", dlm->name,
10199c6510a5SKurt Hackel res->lockname.len, res->lockname.name, res->owner);
10206714d8e8SKurt Hackel spin_unlock(&res->spinlock);
10219c6510a5SKurt Hackel /* this will cause the master to re-assert across
10229c6510a5SKurt Hackel * the whole cluster, freeing up mles */
1023588e0090SKurt Hackel if (res->owner != dlm->node_num) {
1024ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, res->owner);
10259c6510a5SKurt Hackel if (ret < 0) {
10269c6510a5SKurt Hackel /* give recovery a chance to run */
10279c6510a5SKurt Hackel mlog(ML_ERROR, "link to %u went down?: %d\n", res->owner, ret);
10289c6510a5SKurt Hackel msleep(500);
10299c6510a5SKurt Hackel goto recheck;
10309c6510a5SKurt Hackel }
1031588e0090SKurt Hackel }
10329c6510a5SKurt Hackel ret = 0;
10336714d8e8SKurt Hackel goto leave;
10346714d8e8SKurt Hackel }
10356714d8e8SKurt Hackel spin_unlock(&res->spinlock);
10366714d8e8SKurt Hackel
10376714d8e8SKurt Hackel spin_lock(&mle->spinlock);
10386714d8e8SKurt Hackel m = mle->master;
1039*b270f492SJoseph Qi map_changed = !bitmap_equal(mle->vote_map, mle->node_map,
1040*b270f492SJoseph Qi O2NM_MAX_NODES);
1041*b270f492SJoseph Qi voting_done = bitmap_equal(mle->vote_map, mle->response_map,
1042*b270f492SJoseph Qi O2NM_MAX_NODES);
10436714d8e8SKurt Hackel
10446714d8e8SKurt Hackel /* restart if we hit any errors */
10456714d8e8SKurt Hackel if (map_changed) {
10466714d8e8SKurt Hackel int b;
10476714d8e8SKurt Hackel mlog(0, "%s: %.*s: node map changed, restarting\n",
10486714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name);
10496714d8e8SKurt Hackel ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked);
10506714d8e8SKurt Hackel b = (mle->type == DLM_MLE_BLOCK);
10516714d8e8SKurt Hackel if ((*blocked && !b) || (!*blocked && b)) {
10526714d8e8SKurt Hackel mlog(0, "%s:%.*s: status change: old=%d new=%d\n",
10536714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name,
10546714d8e8SKurt Hackel *blocked, b);
10556714d8e8SKurt Hackel *blocked = b;
10566714d8e8SKurt Hackel }
10576714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
10586714d8e8SKurt Hackel if (ret < 0) {
10596714d8e8SKurt Hackel mlog_errno(ret);
10606714d8e8SKurt Hackel goto leave;
10616714d8e8SKurt Hackel }
10626714d8e8SKurt Hackel mlog(0, "%s:%.*s: restart lock mastery succeeded, "
10636714d8e8SKurt Hackel "rechecking now\n", dlm->name, res->lockname.len,
10646714d8e8SKurt Hackel res->lockname.name);
10656714d8e8SKurt Hackel goto recheck;
1066aa852354SKurt Hackel } else {
1067aa852354SKurt Hackel if (!voting_done) {
1068aa852354SKurt Hackel mlog(0, "map not changed and voting not done "
1069aa852354SKurt Hackel "for %s:%.*s\n", dlm->name, res->lockname.len,
1070aa852354SKurt Hackel res->lockname.name);
1071aa852354SKurt Hackel }
10726714d8e8SKurt Hackel }
10736714d8e8SKurt Hackel
10746714d8e8SKurt Hackel if (m != O2NM_MAX_NODES) {
10756714d8e8SKurt Hackel /* another node has done an assert!
10766714d8e8SKurt Hackel * all done! */
10776714d8e8SKurt Hackel sleep = 0;
10786714d8e8SKurt Hackel } else {
10796714d8e8SKurt Hackel sleep = 1;
10806714d8e8SKurt Hackel /* have all nodes responded? */
10816714d8e8SKurt Hackel if (voting_done && !*blocked) {
1082b5c7e7ecSYury Norov bit = find_first_bit(mle->maybe_map, O2NM_MAX_NODES);
10836714d8e8SKurt Hackel if (dlm->node_num <= bit) {
10846714d8e8SKurt Hackel /* my node number is lowest.
10856714d8e8SKurt Hackel * now tell other nodes that I am
10866714d8e8SKurt Hackel * mastering this. */
10876714d8e8SKurt Hackel mle->master = dlm->node_num;
1088ba2bf218SKurt Hackel /* ref was grabbed in get_lock_resource
1089ba2bf218SKurt Hackel * will be dropped in dlmlock_master */
10906714d8e8SKurt Hackel assert = 1;
10916714d8e8SKurt Hackel sleep = 0;
10926714d8e8SKurt Hackel }
10936714d8e8SKurt Hackel /* if voting is done, but we have not received
10946714d8e8SKurt Hackel * an assert master yet, we must sleep */
10956714d8e8SKurt Hackel }
10966714d8e8SKurt Hackel }
10976714d8e8SKurt Hackel
10986714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
10996714d8e8SKurt Hackel
11006714d8e8SKurt Hackel /* sleep if we haven't finished voting yet */
11016714d8e8SKurt Hackel if (sleep) {
11026714d8e8SKurt Hackel unsigned long timeo = msecs_to_jiffies(DLM_MASTERY_TIMEOUT_MS);
11036714d8e8SKurt Hackel atomic_set(&mle->woken, 0);
11046714d8e8SKurt Hackel (void)wait_event_timeout(mle->wq,
11056714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1),
11066714d8e8SKurt Hackel timeo);
11076714d8e8SKurt Hackel if (res->owner == O2NM_MAX_NODES) {
1108ba2bf218SKurt Hackel mlog(0, "%s:%.*s: waiting again\n", dlm->name,
1109ba2bf218SKurt Hackel res->lockname.len, res->lockname.name);
11106714d8e8SKurt Hackel goto recheck;
11116714d8e8SKurt Hackel }
11126714d8e8SKurt Hackel mlog(0, "done waiting, master is %u\n", res->owner);
11136714d8e8SKurt Hackel ret = 0;
11146714d8e8SKurt Hackel goto leave;
11156714d8e8SKurt Hackel }
11166714d8e8SKurt Hackel
11176714d8e8SKurt Hackel ret = 0; /* done */
11186714d8e8SKurt Hackel if (assert) {
11196714d8e8SKurt Hackel m = dlm->node_num;
11206714d8e8SKurt Hackel mlog(0, "about to master %.*s here, this=%u\n",
11216714d8e8SKurt Hackel res->lockname.len, res->lockname.name, m);
1122ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, mle->vote_map, 0);
11236714d8e8SKurt Hackel if (ret) {
11246714d8e8SKurt Hackel /* This is a failure in the network path,
11256714d8e8SKurt Hackel * not in the response to the assert_master
11266714d8e8SKurt Hackel * (any nonzero response is a BUG on this node).
11276714d8e8SKurt Hackel * Most likely a socket just got disconnected
11286714d8e8SKurt Hackel * due to node death. */
11296714d8e8SKurt Hackel mlog_errno(ret);
11306714d8e8SKurt Hackel }
11316714d8e8SKurt Hackel /* no longer need to restart lock mastery.
11326714d8e8SKurt Hackel * all living nodes have been contacted. */
11336714d8e8SKurt Hackel ret = 0;
11346714d8e8SKurt Hackel }
11356714d8e8SKurt Hackel
11366714d8e8SKurt Hackel /* set the lockres owner */
11376714d8e8SKurt Hackel spin_lock(&res->spinlock);
1138ba2bf218SKurt Hackel /* mastery reference obtained either during
1139ba2bf218SKurt Hackel * assert_master_handler or in get_lock_resource */
11406714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, m);
11416714d8e8SKurt Hackel spin_unlock(&res->spinlock);
11426714d8e8SKurt Hackel
11436714d8e8SKurt Hackel leave:
11446714d8e8SKurt Hackel return ret;
11456714d8e8SKurt Hackel }
11466714d8e8SKurt Hackel
11476714d8e8SKurt Hackel struct dlm_bitmap_diff_iter
11486714d8e8SKurt Hackel {
11496714d8e8SKurt Hackel int curnode;
11506714d8e8SKurt Hackel unsigned long *orig_bm;
11516714d8e8SKurt Hackel unsigned long *cur_bm;
11526714d8e8SKurt Hackel unsigned long diff_bm[BITS_TO_LONGS(O2NM_MAX_NODES)];
11536714d8e8SKurt Hackel };
11546714d8e8SKurt Hackel
11556714d8e8SKurt Hackel enum dlm_node_state_change
11566714d8e8SKurt Hackel {
11576714d8e8SKurt Hackel NODE_DOWN = -1,
11586714d8e8SKurt Hackel NODE_NO_CHANGE = 0,
11596714d8e8SKurt Hackel NODE_UP
11606714d8e8SKurt Hackel };
11616714d8e8SKurt Hackel
dlm_bitmap_diff_iter_init(struct dlm_bitmap_diff_iter * iter,unsigned long * orig_bm,unsigned long * cur_bm)11626714d8e8SKurt Hackel static void dlm_bitmap_diff_iter_init(struct dlm_bitmap_diff_iter *iter,
11636714d8e8SKurt Hackel unsigned long *orig_bm,
11646714d8e8SKurt Hackel unsigned long *cur_bm)
11656714d8e8SKurt Hackel {
11666714d8e8SKurt Hackel unsigned long p1, p2;
11676714d8e8SKurt Hackel int i;
11686714d8e8SKurt Hackel
11696714d8e8SKurt Hackel iter->curnode = -1;
11706714d8e8SKurt Hackel iter->orig_bm = orig_bm;
11716714d8e8SKurt Hackel iter->cur_bm = cur_bm;
11726714d8e8SKurt Hackel
11736714d8e8SKurt Hackel for (i = 0; i < BITS_TO_LONGS(O2NM_MAX_NODES); i++) {
11746714d8e8SKurt Hackel p1 = *(iter->orig_bm + i);
11756714d8e8SKurt Hackel p2 = *(iter->cur_bm + i);
11766714d8e8SKurt Hackel iter->diff_bm[i] = (p1 & ~p2) | (p2 & ~p1);
11776714d8e8SKurt Hackel }
11786714d8e8SKurt Hackel }
11796714d8e8SKurt Hackel
dlm_bitmap_diff_iter_next(struct dlm_bitmap_diff_iter * iter,enum dlm_node_state_change * state)11806714d8e8SKurt Hackel static int dlm_bitmap_diff_iter_next(struct dlm_bitmap_diff_iter *iter,
11816714d8e8SKurt Hackel enum dlm_node_state_change *state)
11826714d8e8SKurt Hackel {
11836714d8e8SKurt Hackel int bit;
11846714d8e8SKurt Hackel
11856714d8e8SKurt Hackel if (iter->curnode >= O2NM_MAX_NODES)
11866714d8e8SKurt Hackel return -ENOENT;
11876714d8e8SKurt Hackel
11886714d8e8SKurt Hackel bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES,
11896714d8e8SKurt Hackel iter->curnode+1);
11906714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) {
11916714d8e8SKurt Hackel iter->curnode = O2NM_MAX_NODES;
11926714d8e8SKurt Hackel return -ENOENT;
11936714d8e8SKurt Hackel }
11946714d8e8SKurt Hackel
11956714d8e8SKurt Hackel /* if it was there in the original then this node died */
11966714d8e8SKurt Hackel if (test_bit(bit, iter->orig_bm))
11976714d8e8SKurt Hackel *state = NODE_DOWN;
11986714d8e8SKurt Hackel else
11996714d8e8SKurt Hackel *state = NODE_UP;
12006714d8e8SKurt Hackel
12016714d8e8SKurt Hackel iter->curnode = bit;
12026714d8e8SKurt Hackel return bit;
12036714d8e8SKurt Hackel }
12046714d8e8SKurt Hackel
12056714d8e8SKurt Hackel
dlm_restart_lock_mastery(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,struct dlm_master_list_entry * mle,int blocked)12066714d8e8SKurt Hackel static int dlm_restart_lock_mastery(struct dlm_ctxt *dlm,
12076714d8e8SKurt Hackel struct dlm_lock_resource *res,
12086714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
12096714d8e8SKurt Hackel int blocked)
12106714d8e8SKurt Hackel {
12116714d8e8SKurt Hackel struct dlm_bitmap_diff_iter bdi;
12126714d8e8SKurt Hackel enum dlm_node_state_change sc;
12136714d8e8SKurt Hackel int node;
12146714d8e8SKurt Hackel int ret = 0;
12156714d8e8SKurt Hackel
12166714d8e8SKurt Hackel mlog(0, "something happened such that the "
12176714d8e8SKurt Hackel "master process may need to be restarted!\n");
12186714d8e8SKurt Hackel
12196714d8e8SKurt Hackel assert_spin_locked(&mle->spinlock);
12206714d8e8SKurt Hackel
12216714d8e8SKurt Hackel dlm_bitmap_diff_iter_init(&bdi, mle->vote_map, mle->node_map);
12226714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc);
12236714d8e8SKurt Hackel while (node >= 0) {
12246714d8e8SKurt Hackel if (sc == NODE_UP) {
1225e2faea4cSKurt Hackel /* a node came up. clear any old vote from
1226e2faea4cSKurt Hackel * the response map and set it in the vote map
1227e2faea4cSKurt Hackel * then restart the mastery. */
1228e2faea4cSKurt Hackel mlog(ML_NOTICE, "node %d up while restarting\n", node);
12296714d8e8SKurt Hackel
12306714d8e8SKurt Hackel /* redo the master request, but only for the new node */
12316714d8e8SKurt Hackel mlog(0, "sending request to new node\n");
12326714d8e8SKurt Hackel clear_bit(node, mle->response_map);
12336714d8e8SKurt Hackel set_bit(node, mle->vote_map);
12346714d8e8SKurt Hackel } else {
12356714d8e8SKurt Hackel mlog(ML_ERROR, "node down! %d\n", node);
12366714d8e8SKurt Hackel if (blocked) {
1237b5c7e7ecSYury Norov int lowest = find_first_bit(mle->maybe_map,
1238b5c7e7ecSYury Norov O2NM_MAX_NODES);
12396714d8e8SKurt Hackel
12406714d8e8SKurt Hackel /* act like it was never there */
12416714d8e8SKurt Hackel clear_bit(node, mle->maybe_map);
12426714d8e8SKurt Hackel
1243e7e69eb3SKurt Hackel if (node == lowest) {
1244e7e69eb3SKurt Hackel mlog(0, "expected master %u died"
1245e7e69eb3SKurt Hackel " while this node was blocked "
1246e7e69eb3SKurt Hackel "waiting on it!\n", node);
12476714d8e8SKurt Hackel lowest = find_next_bit(mle->maybe_map,
12486714d8e8SKurt Hackel O2NM_MAX_NODES,
12496714d8e8SKurt Hackel lowest+1);
12506714d8e8SKurt Hackel if (lowest < O2NM_MAX_NODES) {
1251e7e69eb3SKurt Hackel mlog(0, "%s:%.*s:still "
1252e7e69eb3SKurt Hackel "blocked. waiting on %u "
1253e7e69eb3SKurt Hackel "now\n", dlm->name,
1254e7e69eb3SKurt Hackel res->lockname.len,
1255e7e69eb3SKurt Hackel res->lockname.name,
1256e7e69eb3SKurt Hackel lowest);
1257e7e69eb3SKurt Hackel } else {
1258e7e69eb3SKurt Hackel /* mle is an MLE_BLOCK, but
1259e7e69eb3SKurt Hackel * there is now nothing left to
1260e7e69eb3SKurt Hackel * block on. we need to return
1261e7e69eb3SKurt Hackel * all the way back out and try
1262e7e69eb3SKurt Hackel * again with an MLE_MASTER.
1263e7e69eb3SKurt Hackel * dlm_do_local_recovery_cleanup
1264e7e69eb3SKurt Hackel * has already run, so the mle
1265e7e69eb3SKurt Hackel * refcount is ok */
1266e7e69eb3SKurt Hackel mlog(0, "%s:%.*s: no "
1267e7e69eb3SKurt Hackel "longer blocking. try to "
1268e7e69eb3SKurt Hackel "master this here\n",
1269e7e69eb3SKurt Hackel dlm->name,
1270e7e69eb3SKurt Hackel res->lockname.len,
1271e7e69eb3SKurt Hackel res->lockname.name);
1272e7e69eb3SKurt Hackel mle->type = DLM_MLE_MASTER;
12737141514bSSunil Mushran mle->mleres = res;
1274e7e69eb3SKurt Hackel }
1275e7e69eb3SKurt Hackel }
12766714d8e8SKurt Hackel }
12776714d8e8SKurt Hackel
1278e7e69eb3SKurt Hackel /* now blank out everything, as if we had never
1279e7e69eb3SKurt Hackel * contacted anyone */
1280*b270f492SJoseph Qi bitmap_zero(mle->maybe_map, O2NM_MAX_NODES);
1281*b270f492SJoseph Qi bitmap_zero(mle->response_map, O2NM_MAX_NODES);
1282e7e69eb3SKurt Hackel /* reset the vote_map to the current node_map */
1283*b270f492SJoseph Qi bitmap_copy(mle->vote_map, mle->node_map,
1284*b270f492SJoseph Qi O2NM_MAX_NODES);
1285e7e69eb3SKurt Hackel /* put myself into the maybe map */
1286e7e69eb3SKurt Hackel if (mle->type != DLM_MLE_BLOCK)
12876714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map);
12886714d8e8SKurt Hackel }
12896714d8e8SKurt Hackel ret = -EAGAIN;
12906714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc);
12916714d8e8SKurt Hackel }
12926714d8e8SKurt Hackel return ret;
12936714d8e8SKurt Hackel }
12946714d8e8SKurt Hackel
12956714d8e8SKurt Hackel
12966714d8e8SKurt Hackel /*
12976714d8e8SKurt Hackel * DLM_MASTER_REQUEST_MSG
12986714d8e8SKurt Hackel *
12996714d8e8SKurt Hackel * returns: 0 on success,
13006714d8e8SKurt Hackel * -errno on a network error
13016714d8e8SKurt Hackel *
13026714d8e8SKurt Hackel * on error, the caller should assume the target node is "dead"
13036714d8e8SKurt Hackel *
13046714d8e8SKurt Hackel */
13056714d8e8SKurt Hackel
dlm_do_master_request(struct dlm_lock_resource * res,struct dlm_master_list_entry * mle,int to)1306ba2bf218SKurt Hackel static int dlm_do_master_request(struct dlm_lock_resource *res,
1307ba2bf218SKurt Hackel struct dlm_master_list_entry *mle, int to)
13086714d8e8SKurt Hackel {
13096714d8e8SKurt Hackel struct dlm_ctxt *dlm = mle->dlm;
13106714d8e8SKurt Hackel struct dlm_master_request request;
13116714d8e8SKurt Hackel int ret, response=0, resend;
13126714d8e8SKurt Hackel
13136714d8e8SKurt Hackel memset(&request, 0, sizeof(request));
13146714d8e8SKurt Hackel request.node_idx = dlm->node_num;
13156714d8e8SKurt Hackel
13166714d8e8SKurt Hackel BUG_ON(mle->type == DLM_MLE_MIGRATION);
13176714d8e8SKurt Hackel
13187141514bSSunil Mushran request.namelen = (u8)mle->mnamelen;
13197141514bSSunil Mushran memcpy(request.name, mle->mname, request.namelen);
13206714d8e8SKurt Hackel
13216714d8e8SKurt Hackel again:
13226714d8e8SKurt Hackel ret = o2net_send_message(DLM_MASTER_REQUEST_MSG, dlm->key, &request,
13236714d8e8SKurt Hackel sizeof(request), to, &response);
13246714d8e8SKurt Hackel if (ret < 0) {
13256714d8e8SKurt Hackel if (ret == -ESRCH) {
13266714d8e8SKurt Hackel /* should never happen */
13276714d8e8SKurt Hackel mlog(ML_ERROR, "TCP stack not ready!\n");
13286714d8e8SKurt Hackel BUG();
13296714d8e8SKurt Hackel } else if (ret == -EINVAL) {
13306714d8e8SKurt Hackel mlog(ML_ERROR, "bad args passed to o2net!\n");
13316714d8e8SKurt Hackel BUG();
13326714d8e8SKurt Hackel } else if (ret == -ENOMEM) {
13336714d8e8SKurt Hackel mlog(ML_ERROR, "out of memory while trying to send "
13346714d8e8SKurt Hackel "network message! retrying\n");
13356714d8e8SKurt Hackel /* this is totally crude */
13366714d8e8SKurt Hackel msleep(50);
13376714d8e8SKurt Hackel goto again;
13386714d8e8SKurt Hackel } else if (!dlm_is_host_down(ret)) {
13396714d8e8SKurt Hackel /* not a network error. bad. */
13406714d8e8SKurt Hackel mlog_errno(ret);
13416714d8e8SKurt Hackel mlog(ML_ERROR, "unhandled error!");
13426714d8e8SKurt Hackel BUG();
13436714d8e8SKurt Hackel }
13446714d8e8SKurt Hackel /* all other errors should be network errors,
13456714d8e8SKurt Hackel * and likely indicate node death */
13466714d8e8SKurt Hackel mlog(ML_ERROR, "link to %d went down!\n", to);
13476714d8e8SKurt Hackel goto out;
13486714d8e8SKurt Hackel }
13496714d8e8SKurt Hackel
13506714d8e8SKurt Hackel ret = 0;
13516714d8e8SKurt Hackel resend = 0;
13526714d8e8SKurt Hackel spin_lock(&mle->spinlock);
13536714d8e8SKurt Hackel switch (response) {
13546714d8e8SKurt Hackel case DLM_MASTER_RESP_YES:
13556714d8e8SKurt Hackel set_bit(to, mle->response_map);
13566714d8e8SKurt Hackel mlog(0, "node %u is the master, response=YES\n", to);
1357ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master node %u now knows I have a "
1358ba2bf218SKurt Hackel "reference\n", dlm->name, res->lockname.len,
1359ba2bf218SKurt Hackel res->lockname.name, to);
13606714d8e8SKurt Hackel mle->master = to;
13616714d8e8SKurt Hackel break;
13626714d8e8SKurt Hackel case DLM_MASTER_RESP_NO:
13636714d8e8SKurt Hackel mlog(0, "node %u not master, response=NO\n", to);
13646714d8e8SKurt Hackel set_bit(to, mle->response_map);
13656714d8e8SKurt Hackel break;
13666714d8e8SKurt Hackel case DLM_MASTER_RESP_MAYBE:
13676714d8e8SKurt Hackel mlog(0, "node %u not master, response=MAYBE\n", to);
13686714d8e8SKurt Hackel set_bit(to, mle->response_map);
13696714d8e8SKurt Hackel set_bit(to, mle->maybe_map);
13706714d8e8SKurt Hackel break;
13716714d8e8SKurt Hackel case DLM_MASTER_RESP_ERROR:
13726714d8e8SKurt Hackel mlog(0, "node %u hit an error, resending\n", to);
13736714d8e8SKurt Hackel resend = 1;
13746714d8e8SKurt Hackel response = 0;
13756714d8e8SKurt Hackel break;
13766714d8e8SKurt Hackel default:
13776714d8e8SKurt Hackel mlog(ML_ERROR, "bad response! %u\n", response);
13786714d8e8SKurt Hackel BUG();
13796714d8e8SKurt Hackel }
13806714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
13816714d8e8SKurt Hackel if (resend) {
13826714d8e8SKurt Hackel /* this is also totally crude */
13836714d8e8SKurt Hackel msleep(50);
13846714d8e8SKurt Hackel goto again;
13856714d8e8SKurt Hackel }
13866714d8e8SKurt Hackel
13876714d8e8SKurt Hackel out:
13886714d8e8SKurt Hackel return ret;
13896714d8e8SKurt Hackel }
13906714d8e8SKurt Hackel
13916714d8e8SKurt Hackel /*
13926714d8e8SKurt Hackel * locks that can be taken here:
13936714d8e8SKurt Hackel * dlm->spinlock
13946714d8e8SKurt Hackel * res->spinlock
13956714d8e8SKurt Hackel * mle->spinlock
13966714d8e8SKurt Hackel * dlm->master_list
13976714d8e8SKurt Hackel *
13986714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!!
13996714d8e8SKurt Hackel */
dlm_master_request_handler(struct o2net_msg * msg,u32 len,void * data,void ** ret_data)1400d74c9803SKurt Hackel int dlm_master_request_handler(struct o2net_msg *msg, u32 len, void *data,
1401d74c9803SKurt Hackel void **ret_data)
14026714d8e8SKurt Hackel {
14036714d8e8SKurt Hackel u8 response = DLM_MASTER_RESP_MAYBE;
14046714d8e8SKurt Hackel struct dlm_ctxt *dlm = data;
14059c6510a5SKurt Hackel struct dlm_lock_resource *res = NULL;
14066714d8e8SKurt Hackel struct dlm_master_request *request = (struct dlm_master_request *) msg->buf;
14076714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *tmpmle = NULL;
14086714d8e8SKurt Hackel char *name;
1409a3d33291SMark Fasheh unsigned int namelen, hash;
14106714d8e8SKurt Hackel int found, ret;
14116714d8e8SKurt Hackel int set_maybe;
14129c6510a5SKurt Hackel int dispatch_assert = 0;
1413012572d4SJoseph Qi int dispatched = 0;
14146714d8e8SKurt Hackel
14156714d8e8SKurt Hackel if (!dlm_grab(dlm))
14166714d8e8SKurt Hackel return DLM_MASTER_RESP_NO;
14176714d8e8SKurt Hackel
14186714d8e8SKurt Hackel if (!dlm_domain_fully_joined(dlm)) {
14196714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
14206714d8e8SKurt Hackel goto send_response;
14216714d8e8SKurt Hackel }
14226714d8e8SKurt Hackel
14236714d8e8SKurt Hackel name = request->name;
14246714d8e8SKurt Hackel namelen = request->namelen;
1425a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen);
14266714d8e8SKurt Hackel
14276714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) {
14286714d8e8SKurt Hackel response = DLM_IVBUFLEN;
14296714d8e8SKurt Hackel goto send_response;
14306714d8e8SKurt Hackel }
14316714d8e8SKurt Hackel
14326714d8e8SKurt Hackel way_up_top:
14336714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
1434a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash);
14356714d8e8SKurt Hackel if (res) {
14366714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
14376714d8e8SKurt Hackel
14386714d8e8SKurt Hackel /* take care of the easy cases up front */
14396714d8e8SKurt Hackel spin_lock(&res->spinlock);
1440cb79662bSSrinivas Eeda
1441cb79662bSSrinivas Eeda /*
1442cb79662bSSrinivas Eeda * Right after dlm spinlock was released, dlm_thread could have
1443cb79662bSSrinivas Eeda * purged the lockres. Check if lockres got unhashed. If so
1444cb79662bSSrinivas Eeda * start over.
1445cb79662bSSrinivas Eeda */
1446cb79662bSSrinivas Eeda if (hlist_unhashed(&res->hash_node)) {
1447cb79662bSSrinivas Eeda spin_unlock(&res->spinlock);
1448cb79662bSSrinivas Eeda dlm_lockres_put(res);
1449cb79662bSSrinivas Eeda goto way_up_top;
1450cb79662bSSrinivas Eeda }
1451cb79662bSSrinivas Eeda
14521cd04dbeSKurt Hackel if (res->state & (DLM_LOCK_RES_RECOVERING|
14531cd04dbeSKurt Hackel DLM_LOCK_RES_MIGRATING)) {
14546714d8e8SKurt Hackel spin_unlock(&res->spinlock);
14556714d8e8SKurt Hackel mlog(0, "returning DLM_MASTER_RESP_ERROR since res is "
14561cd04dbeSKurt Hackel "being recovered/migrated\n");
14576714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR;
14586714d8e8SKurt Hackel if (mle)
14596714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
14606714d8e8SKurt Hackel goto send_response;
14616714d8e8SKurt Hackel }
14626714d8e8SKurt Hackel
14636714d8e8SKurt Hackel if (res->owner == dlm->node_num) {
14648d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, request->node_idx);
14656714d8e8SKurt Hackel spin_unlock(&res->spinlock);
14666714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES;
14676714d8e8SKurt Hackel if (mle)
14686714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
14696714d8e8SKurt Hackel
14706714d8e8SKurt Hackel /* this node is the owner.
14716714d8e8SKurt Hackel * there is some extra work that needs to
14726714d8e8SKurt Hackel * happen now. the requesting node has
14736714d8e8SKurt Hackel * caused all nodes up to this one to
14746714d8e8SKurt Hackel * create mles. this node now needs to
14756714d8e8SKurt Hackel * go back and clean those up. */
14769c6510a5SKurt Hackel dispatch_assert = 1;
14776714d8e8SKurt Hackel goto send_response;
14786714d8e8SKurt Hackel } else if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
14796714d8e8SKurt Hackel spin_unlock(&res->spinlock);
14806714d8e8SKurt Hackel // mlog(0, "node %u is the master\n", res->owner);
14816714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
14826714d8e8SKurt Hackel if (mle)
14836714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
14846714d8e8SKurt Hackel goto send_response;
14856714d8e8SKurt Hackel }
14866714d8e8SKurt Hackel
14876714d8e8SKurt Hackel /* ok, there is no owner. either this node is
14886714d8e8SKurt Hackel * being blocked, or it is actively trying to
14896714d8e8SKurt Hackel * master this lock. */
14906714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) {
14916714d8e8SKurt Hackel mlog(ML_ERROR, "lock with no owner should be "
14926714d8e8SKurt Hackel "in-progress!\n");
14936714d8e8SKurt Hackel BUG();
14946714d8e8SKurt Hackel }
14956714d8e8SKurt Hackel
14966714d8e8SKurt Hackel // mlog(0, "lockres is in progress...\n");
14976714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
14986714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen);
14996714d8e8SKurt Hackel if (!found) {
15006714d8e8SKurt Hackel mlog(ML_ERROR, "no mle found for this lock!\n");
15016714d8e8SKurt Hackel BUG();
15026714d8e8SKurt Hackel }
15036714d8e8SKurt Hackel set_maybe = 1;
15046714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock);
15056714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK) {
15066714d8e8SKurt Hackel // mlog(0, "this node is waiting for "
15076714d8e8SKurt Hackel // "lockres to be mastered\n");
15086714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15096714d8e8SKurt Hackel } else if (tmpmle->type == DLM_MLE_MIGRATION) {
15106714d8e8SKurt Hackel mlog(0, "node %u is master, but trying to migrate to "
15116714d8e8SKurt Hackel "node %u.\n", tmpmle->master, tmpmle->new_master);
15126714d8e8SKurt Hackel if (tmpmle->master == dlm->node_num) {
15136714d8e8SKurt Hackel mlog(ML_ERROR, "no owner on lockres, but this "
15146714d8e8SKurt Hackel "node is trying to migrate it to %u?!\n",
15156714d8e8SKurt Hackel tmpmle->new_master);
15166714d8e8SKurt Hackel BUG();
15176714d8e8SKurt Hackel } else {
15186714d8e8SKurt Hackel /* the real master can respond on its own */
15196714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15206714d8e8SKurt Hackel }
15216714d8e8SKurt Hackel } else if (tmpmle->master != DLM_LOCK_RES_OWNER_UNKNOWN) {
15226714d8e8SKurt Hackel set_maybe = 0;
15239c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) {
15246714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES;
15259c6510a5SKurt Hackel /* this node will be the owner.
15269c6510a5SKurt Hackel * go back and clean the mles on any
15279c6510a5SKurt Hackel * other nodes */
15289c6510a5SKurt Hackel dispatch_assert = 1;
15298d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res,
1530ba2bf218SKurt Hackel request->node_idx);
15319c6510a5SKurt Hackel } else
15326714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15336714d8e8SKurt Hackel } else {
15346714d8e8SKurt Hackel // mlog(0, "this node is attempting to "
15356714d8e8SKurt Hackel // "master lockres\n");
15366714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE;
15376714d8e8SKurt Hackel }
15386714d8e8SKurt Hackel if (set_maybe)
15396714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map);
15406714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock);
15416714d8e8SKurt Hackel
15426714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
15436714d8e8SKurt Hackel spin_unlock(&res->spinlock);
15446714d8e8SKurt Hackel
15456714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */
15466714d8e8SKurt Hackel dlm_put_mle(tmpmle);
15476714d8e8SKurt Hackel if (mle)
15486714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
15496714d8e8SKurt Hackel goto send_response;
15506714d8e8SKurt Hackel }
15516714d8e8SKurt Hackel
15526714d8e8SKurt Hackel /*
15536714d8e8SKurt Hackel * lockres doesn't exist on this node
15546714d8e8SKurt Hackel * if there is an MLE_BLOCK, return NO
15556714d8e8SKurt Hackel * if there is an MLE_MASTER, return MAYBE
15566714d8e8SKurt Hackel * otherwise, add an MLE_BLOCK, return NO
15576714d8e8SKurt Hackel */
15586714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
15596714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen);
15606714d8e8SKurt Hackel if (!found) {
15616714d8e8SKurt Hackel /* this lockid has never been seen on this node yet */
15626714d8e8SKurt Hackel // mlog(0, "no mle found\n");
15636714d8e8SKurt Hackel if (!mle) {
15646714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
15656714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
15666714d8e8SKurt Hackel
15673914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS);
15686714d8e8SKurt Hackel if (!mle) {
15696714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR;
15709c6510a5SKurt Hackel mlog_errno(-ENOMEM);
15716714d8e8SKurt Hackel goto send_response;
15726714d8e8SKurt Hackel }
15736714d8e8SKurt Hackel goto way_up_top;
15746714d8e8SKurt Hackel }
15756714d8e8SKurt Hackel
15766714d8e8SKurt Hackel // mlog(0, "this is second time thru, already allocated, "
15776714d8e8SKurt Hackel // "add the block.\n");
157841b8c8a1SKurt Hackel dlm_init_mle(mle, DLM_MLE_BLOCK, dlm, NULL, name, namelen);
15796714d8e8SKurt Hackel set_bit(request->node_idx, mle->maybe_map);
15801c084577SSunil Mushran __dlm_insert_mle(dlm, mle);
15816714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15826714d8e8SKurt Hackel } else {
15836714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock);
15849c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) {
15859c6510a5SKurt Hackel mlog(ML_ERROR, "no lockres, but an mle with this node as master!\n");
15869c6510a5SKurt Hackel BUG();
15879c6510a5SKurt Hackel }
15886714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK)
15896714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15906714d8e8SKurt Hackel else if (tmpmle->type == DLM_MLE_MIGRATION) {
15916714d8e8SKurt Hackel mlog(0, "migration mle was found (%u->%u)\n",
15926714d8e8SKurt Hackel tmpmle->master, tmpmle->new_master);
15936714d8e8SKurt Hackel /* real master can respond on its own */
15946714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO;
15956714d8e8SKurt Hackel } else
15966714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE;
15976714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map);
15986714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock);
15996714d8e8SKurt Hackel }
16006714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
16016714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
16026714d8e8SKurt Hackel
16036714d8e8SKurt Hackel if (found) {
16046714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */
16056714d8e8SKurt Hackel dlm_put_mle(tmpmle);
16066714d8e8SKurt Hackel }
16076714d8e8SKurt Hackel send_response:
1608b31cfc02SSunil Mushran /*
1609b31cfc02SSunil Mushran * __dlm_lookup_lockres() grabbed a reference to this lockres.
1610b31cfc02SSunil Mushran * The reference is released by dlm_assert_master_worker() under
1611b31cfc02SSunil Mushran * the call to dlm_dispatch_assert_master(). If
1612b31cfc02SSunil Mushran * dlm_assert_master_worker() isn't called, we drop it here.
1613b31cfc02SSunil Mushran */
16149c6510a5SKurt Hackel if (dispatch_assert) {
16159c6510a5SKurt Hackel mlog(0, "%u is the owner of %.*s, cleaning everyone else\n",
16169c6510a5SKurt Hackel dlm->node_num, res->lockname.len, res->lockname.name);
16171e589581SJoseph Qi spin_lock(&res->spinlock);
16189c6510a5SKurt Hackel ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx,
16199c6510a5SKurt Hackel DLM_ASSERT_MASTER_MLE_CLEANUP);
16209c6510a5SKurt Hackel if (ret < 0) {
16219c6510a5SKurt Hackel mlog(ML_ERROR, "failed to dispatch assert master work\n");
16229c6510a5SKurt Hackel response = DLM_MASTER_RESP_ERROR;
1623b67de018SJoseph Qi spin_unlock(&res->spinlock);
1624b31cfc02SSunil Mushran dlm_lockres_put(res);
1625012572d4SJoseph Qi } else {
1626012572d4SJoseph Qi dispatched = 1;
16271e589581SJoseph Qi __dlm_lockres_grab_inflight_worker(dlm, res);
16281e589581SJoseph Qi spin_unlock(&res->spinlock);
1629b67de018SJoseph Qi }
1630b31cfc02SSunil Mushran } else {
1631b31cfc02SSunil Mushran if (res)
1632b31cfc02SSunil Mushran dlm_lockres_put(res);
16339c6510a5SKurt Hackel }
16349c6510a5SKurt Hackel
1635012572d4SJoseph Qi if (!dispatched)
16366714d8e8SKurt Hackel dlm_put(dlm);
16376714d8e8SKurt Hackel return response;
16386714d8e8SKurt Hackel }
16396714d8e8SKurt Hackel
16406714d8e8SKurt Hackel /*
16416714d8e8SKurt Hackel * DLM_ASSERT_MASTER_MSG
16426714d8e8SKurt Hackel */
16436714d8e8SKurt Hackel
16446714d8e8SKurt Hackel
16456714d8e8SKurt Hackel /*
16466714d8e8SKurt Hackel * NOTE: this can be used for debugging
16476714d8e8SKurt Hackel * can periodically run all locks owned by this node
16486714d8e8SKurt Hackel * and re-assert across the cluster...
16496714d8e8SKurt Hackel */
dlm_do_assert_master(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,void * nodemap,u32 flags)165005488bbeSAdrian Bunk static int dlm_do_assert_master(struct dlm_ctxt *dlm,
1651ba2bf218SKurt Hackel struct dlm_lock_resource *res,
1652ba2bf218SKurt Hackel void *nodemap, u32 flags)
16536714d8e8SKurt Hackel {
16546714d8e8SKurt Hackel struct dlm_assert_master assert;
16556714d8e8SKurt Hackel int to, tmpret;
16566714d8e8SKurt Hackel struct dlm_node_iter iter;
16576714d8e8SKurt Hackel int ret = 0;
16589c6510a5SKurt Hackel int reassert;
1659ba2bf218SKurt Hackel const char *lockname = res->lockname.name;
1660ba2bf218SKurt Hackel unsigned int namelen = res->lockname.len;
16616714d8e8SKurt Hackel
16626714d8e8SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN);
1663f3f85464SSunil Mushran
1664f3f85464SSunil Mushran spin_lock(&res->spinlock);
1665f3f85464SSunil Mushran res->state |= DLM_LOCK_RES_SETREF_INPROG;
1666f3f85464SSunil Mushran spin_unlock(&res->spinlock);
1667f3f85464SSunil Mushran
16689c6510a5SKurt Hackel again:
16699c6510a5SKurt Hackel reassert = 0;
16706714d8e8SKurt Hackel
16716714d8e8SKurt Hackel /* note that if this nodemap is empty, it returns 0 */
16726714d8e8SKurt Hackel dlm_node_iter_init(nodemap, &iter);
16736714d8e8SKurt Hackel while ((to = dlm_node_iter_next(&iter)) >= 0) {
16746714d8e8SKurt Hackel int r = 0;
1675a9ee4c8aSKurt Hackel struct dlm_master_list_entry *mle = NULL;
1676a9ee4c8aSKurt Hackel
16776714d8e8SKurt Hackel mlog(0, "sending assert master to %d (%.*s)\n", to,
16786714d8e8SKurt Hackel namelen, lockname);
16796714d8e8SKurt Hackel memset(&assert, 0, sizeof(assert));
16806714d8e8SKurt Hackel assert.node_idx = dlm->node_num;
16816714d8e8SKurt Hackel assert.namelen = namelen;
16826714d8e8SKurt Hackel memcpy(assert.name, lockname, namelen);
16836714d8e8SKurt Hackel assert.flags = cpu_to_be32(flags);
16846714d8e8SKurt Hackel
16856714d8e8SKurt Hackel tmpret = o2net_send_message(DLM_ASSERT_MASTER_MSG, dlm->key,
16866714d8e8SKurt Hackel &assert, sizeof(assert), to, &r);
16876714d8e8SKurt Hackel if (tmpret < 0) {
1688a5196ec5SWengang Wang mlog(ML_ERROR, "Error %d when sending message %u (key "
1689a5196ec5SWengang Wang "0x%x) to node %u\n", tmpret,
1690a5196ec5SWengang Wang DLM_ASSERT_MASTER_MSG, dlm->key, to);
16916714d8e8SKurt Hackel if (!dlm_is_host_down(tmpret)) {
16923b3b84a8SKurt Hackel mlog(ML_ERROR, "unhandled error=%d!\n", tmpret);
16936714d8e8SKurt Hackel BUG();
16946714d8e8SKurt Hackel }
16956714d8e8SKurt Hackel /* a node died. finish out the rest of the nodes. */
16963b3b84a8SKurt Hackel mlog(0, "link to %d went down!\n", to);
16976714d8e8SKurt Hackel /* any nonzero status return will do */
16986714d8e8SKurt Hackel ret = tmpret;
1699ba2bf218SKurt Hackel r = 0;
17006714d8e8SKurt Hackel } else if (r < 0) {
17016714d8e8SKurt Hackel /* ok, something horribly messed. kill thyself. */
17026714d8e8SKurt Hackel mlog(ML_ERROR,"during assert master of %.*s to %u, "
17036714d8e8SKurt Hackel "got %d.\n", namelen, lockname, to, r);
1704a9ee4c8aSKurt Hackel spin_lock(&dlm->spinlock);
1705a9ee4c8aSKurt Hackel spin_lock(&dlm->master_lock);
1706a9ee4c8aSKurt Hackel if (dlm_find_mle(dlm, &mle, (char *)lockname,
1707a9ee4c8aSKurt Hackel namelen)) {
1708a9ee4c8aSKurt Hackel dlm_print_one_mle(mle);
1709a9ee4c8aSKurt Hackel __dlm_put_mle(mle);
1710a9ee4c8aSKurt Hackel }
1711a9ee4c8aSKurt Hackel spin_unlock(&dlm->master_lock);
1712a9ee4c8aSKurt Hackel spin_unlock(&dlm->spinlock);
17136714d8e8SKurt Hackel BUG();
1714ba2bf218SKurt Hackel }
1715ba2bf218SKurt Hackel
1716ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT &&
1717ba2bf218SKurt Hackel !(r & DLM_ASSERT_RESPONSE_MASTERY_REF)) {
1718ba2bf218SKurt Hackel mlog(ML_ERROR, "%.*s: very strange, "
1719ba2bf218SKurt Hackel "master MLE but no lockres on %u\n",
1720ba2bf218SKurt Hackel namelen, lockname, to);
1721ba2bf218SKurt Hackel }
1722ba2bf218SKurt Hackel
1723ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT) {
17249c6510a5SKurt Hackel mlog(0, "%.*s: node %u create mles on other "
17259c6510a5SKurt Hackel "nodes and requests a re-assert\n",
17269c6510a5SKurt Hackel namelen, lockname, to);
17279c6510a5SKurt Hackel reassert = 1;
17286714d8e8SKurt Hackel }
1729ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_MASTERY_REF) {
1730ba2bf218SKurt Hackel mlog(0, "%.*s: node %u has a reference to this "
1731ba2bf218SKurt Hackel "lockres, set the bit in the refmap\n",
1732ba2bf218SKurt Hackel namelen, lockname, to);
1733ba2bf218SKurt Hackel spin_lock(&res->spinlock);
17348d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, to);
1735ba2bf218SKurt Hackel spin_unlock(&res->spinlock);
1736ba2bf218SKurt Hackel }
17376714d8e8SKurt Hackel }
17386714d8e8SKurt Hackel
17399c6510a5SKurt Hackel if (reassert)
17409c6510a5SKurt Hackel goto again;
17419c6510a5SKurt Hackel
1742f3f85464SSunil Mushran spin_lock(&res->spinlock);
1743f3f85464SSunil Mushran res->state &= ~DLM_LOCK_RES_SETREF_INPROG;
1744f3f85464SSunil Mushran spin_unlock(&res->spinlock);
1745f3f85464SSunil Mushran wake_up(&res->wq);
1746f3f85464SSunil Mushran
17476714d8e8SKurt Hackel return ret;
17486714d8e8SKurt Hackel }
17496714d8e8SKurt Hackel
17506714d8e8SKurt Hackel /*
17516714d8e8SKurt Hackel * locks that can be taken here:
17526714d8e8SKurt Hackel * dlm->spinlock
17536714d8e8SKurt Hackel * res->spinlock
17546714d8e8SKurt Hackel * mle->spinlock
17556714d8e8SKurt Hackel * dlm->master_list
17566714d8e8SKurt Hackel *
17576714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!!
17586714d8e8SKurt Hackel */
dlm_assert_master_handler(struct o2net_msg * msg,u32 len,void * data,void ** ret_data)1759d74c9803SKurt Hackel int dlm_assert_master_handler(struct o2net_msg *msg, u32 len, void *data,
1760d74c9803SKurt Hackel void **ret_data)
17616714d8e8SKurt Hackel {
17626714d8e8SKurt Hackel struct dlm_ctxt *dlm = data;
17636714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL;
17646714d8e8SKurt Hackel struct dlm_assert_master *assert = (struct dlm_assert_master *)msg->buf;
17656714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL;
17666714d8e8SKurt Hackel char *name;
1767a3d33291SMark Fasheh unsigned int namelen, hash;
17686714d8e8SKurt Hackel u32 flags;
1769ba2bf218SKurt Hackel int master_request = 0, have_lockres_ref = 0;
17709c6510a5SKurt Hackel int ret = 0;
17716714d8e8SKurt Hackel
17726714d8e8SKurt Hackel if (!dlm_grab(dlm))
17736714d8e8SKurt Hackel return 0;
17746714d8e8SKurt Hackel
17756714d8e8SKurt Hackel name = assert->name;
17766714d8e8SKurt Hackel namelen = assert->namelen;
1777a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen);
17786714d8e8SKurt Hackel flags = be32_to_cpu(assert->flags);
17796714d8e8SKurt Hackel
17806714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) {
17816714d8e8SKurt Hackel mlog(ML_ERROR, "Invalid name length!");
17826714d8e8SKurt Hackel goto done;
17836714d8e8SKurt Hackel }
17846714d8e8SKurt Hackel
17856714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
17866714d8e8SKurt Hackel
17876714d8e8SKurt Hackel if (flags)
17886714d8e8SKurt Hackel mlog(0, "assert_master with flags: %u\n", flags);
17896714d8e8SKurt Hackel
17906714d8e8SKurt Hackel /* find the MLE */
17916714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
17926714d8e8SKurt Hackel if (!dlm_find_mle(dlm, &mle, name, namelen)) {
17936714d8e8SKurt Hackel /* not an error, could be master just re-asserting */
17946714d8e8SKurt Hackel mlog(0, "just got an assert_master from %u, but no "
17956714d8e8SKurt Hackel "MLE for it! (%.*s)\n", assert->node_idx,
17966714d8e8SKurt Hackel namelen, name);
17976714d8e8SKurt Hackel } else {
1798b5c7e7ecSYury Norov int bit = find_first_bit(mle->maybe_map, O2NM_MAX_NODES);
17996714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) {
18006714d8e8SKurt Hackel /* not necessarily an error, though less likely.
18016714d8e8SKurt Hackel * could be master just re-asserting. */
1802aa852354SKurt Hackel mlog(0, "no bits set in the maybe_map, but %u "
18036714d8e8SKurt Hackel "is asserting! (%.*s)\n", assert->node_idx,
18046714d8e8SKurt Hackel namelen, name);
18056714d8e8SKurt Hackel } else if (bit != assert->node_idx) {
18066714d8e8SKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) {
18076714d8e8SKurt Hackel mlog(0, "master %u was found, %u should "
18086714d8e8SKurt Hackel "back off\n", assert->node_idx, bit);
18096714d8e8SKurt Hackel } else {
18106714d8e8SKurt Hackel /* with the fix for bug 569, a higher node
18116714d8e8SKurt Hackel * number winning the mastery will respond
18126714d8e8SKurt Hackel * YES to mastery requests, but this node
18136714d8e8SKurt Hackel * had no way of knowing. let it pass. */
1814aa852354SKurt Hackel mlog(0, "%u is the lowest node, "
18156714d8e8SKurt Hackel "%u is asserting. (%.*s) %u must "
18166714d8e8SKurt Hackel "have begun after %u won.\n", bit,
18176714d8e8SKurt Hackel assert->node_idx, namelen, name, bit,
18186714d8e8SKurt Hackel assert->node_idx);
18196714d8e8SKurt Hackel }
18206714d8e8SKurt Hackel }
18212d1a868cSKurt Hackel if (mle->type == DLM_MLE_MIGRATION) {
18222d1a868cSKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) {
18232d1a868cSKurt Hackel mlog(0, "%s:%.*s: got cleanup assert"
18242d1a868cSKurt Hackel " from %u for migration\n",
18252d1a868cSKurt Hackel dlm->name, namelen, name,
18262d1a868cSKurt Hackel assert->node_idx);
18272d1a868cSKurt Hackel } else if (!(flags & DLM_ASSERT_MASTER_FINISH_MIGRATION)) {
18282d1a868cSKurt Hackel mlog(0, "%s:%.*s: got unrelated assert"
18292d1a868cSKurt Hackel " from %u for migration, ignoring\n",
18302d1a868cSKurt Hackel dlm->name, namelen, name,
18312d1a868cSKurt Hackel assert->node_idx);
18322d1a868cSKurt Hackel __dlm_put_mle(mle);
18332d1a868cSKurt Hackel spin_unlock(&dlm->master_lock);
18342d1a868cSKurt Hackel spin_unlock(&dlm->spinlock);
18352d1a868cSKurt Hackel goto done;
18362d1a868cSKurt Hackel }
18372d1a868cSKurt Hackel }
18386714d8e8SKurt Hackel }
18396714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
18406714d8e8SKurt Hackel
18416714d8e8SKurt Hackel /* ok everything checks out with the MLE
18426714d8e8SKurt Hackel * now check to see if there is a lockres */
1843a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash);
18446714d8e8SKurt Hackel if (res) {
18456714d8e8SKurt Hackel spin_lock(&res->spinlock);
18466714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) {
18476714d8e8SKurt Hackel mlog(ML_ERROR, "%u asserting but %.*s is "
18486714d8e8SKurt Hackel "RECOVERING!\n", assert->node_idx, namelen, name);
18496714d8e8SKurt Hackel goto kill;
18506714d8e8SKurt Hackel }
18516714d8e8SKurt Hackel if (!mle) {
1852dc2ed195SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN &&
1853dc2ed195SKurt Hackel res->owner != assert->node_idx) {
185453ecd25eSSunil Mushran mlog(ML_ERROR, "DIE! Mastery assert from %u, "
185553ecd25eSSunil Mushran "but current owner is %u! (%.*s)\n",
185653ecd25eSSunil Mushran assert->node_idx, res->owner, namelen,
185753ecd25eSSunil Mushran name);
185853ecd25eSSunil Mushran __dlm_print_one_lock_resource(res);
185953ecd25eSSunil Mushran BUG();
18606714d8e8SKurt Hackel }
18616714d8e8SKurt Hackel } else if (mle->type != DLM_MLE_MIGRATION) {
18626714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
18636714d8e8SKurt Hackel /* owner is just re-asserting */
18646714d8e8SKurt Hackel if (res->owner == assert->node_idx) {
18656714d8e8SKurt Hackel mlog(0, "owner %u re-asserting on "
18666714d8e8SKurt Hackel "lock %.*s\n", assert->node_idx,
18676714d8e8SKurt Hackel namelen, name);
18686714d8e8SKurt Hackel goto ok;
18696714d8e8SKurt Hackel }
18706714d8e8SKurt Hackel mlog(ML_ERROR, "got assert_master from "
18716714d8e8SKurt Hackel "node %u, but %u is the owner! "
18726714d8e8SKurt Hackel "(%.*s)\n", assert->node_idx,
18736714d8e8SKurt Hackel res->owner, namelen, name);
18746714d8e8SKurt Hackel goto kill;
18756714d8e8SKurt Hackel }
18766714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) {
18776714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but lock "
18786714d8e8SKurt Hackel "with no owner should be "
18796714d8e8SKurt Hackel "in-progress! (%.*s)\n",
18806714d8e8SKurt Hackel assert->node_idx,
18816714d8e8SKurt Hackel namelen, name);
18826714d8e8SKurt Hackel goto kill;
18836714d8e8SKurt Hackel }
18846714d8e8SKurt Hackel } else /* mle->type == DLM_MLE_MIGRATION */ {
18856714d8e8SKurt Hackel /* should only be getting an assert from new master */
18866714d8e8SKurt Hackel if (assert->node_idx != mle->new_master) {
18876714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but "
18886714d8e8SKurt Hackel "new master is %u, and old master "
18896714d8e8SKurt Hackel "was %u (%.*s)\n",
18906714d8e8SKurt Hackel assert->node_idx, mle->new_master,
18916714d8e8SKurt Hackel mle->master, namelen, name);
18926714d8e8SKurt Hackel goto kill;
18936714d8e8SKurt Hackel }
18946714d8e8SKurt Hackel
18956714d8e8SKurt Hackel }
18966714d8e8SKurt Hackel ok:
18976714d8e8SKurt Hackel spin_unlock(&res->spinlock);
18986714d8e8SKurt Hackel }
18996714d8e8SKurt Hackel
19006714d8e8SKurt Hackel // mlog(0, "woo! got an assert_master from node %u!\n",
19016714d8e8SKurt Hackel // assert->node_idx);
19026714d8e8SKurt Hackel if (mle) {
19039c6510a5SKurt Hackel int extra_ref = 0;
19049c6510a5SKurt Hackel int nn = -1;
1905a2bf0477SKurt Hackel int rr, err = 0;
19066714d8e8SKurt Hackel
19076714d8e8SKurt Hackel spin_lock(&mle->spinlock);
19089c6510a5SKurt Hackel if (mle->type == DLM_MLE_BLOCK || mle->type == DLM_MLE_MIGRATION)
19099c6510a5SKurt Hackel extra_ref = 1;
19109c6510a5SKurt Hackel else {
19119c6510a5SKurt Hackel /* MASTER mle: if any bits set in the response map
19129c6510a5SKurt Hackel * then the calling node needs to re-assert to clear
19139c6510a5SKurt Hackel * up nodes that this node contacted */
19149c6510a5SKurt Hackel while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES,
19159c6510a5SKurt Hackel nn+1)) < O2NM_MAX_NODES) {
1916728b9805SJunxiao Bi if (nn != dlm->node_num && nn != assert->node_idx) {
19179c6510a5SKurt Hackel master_request = 1;
1918728b9805SJunxiao Bi break;
1919728b9805SJunxiao Bi }
19209c6510a5SKurt Hackel }
19219c6510a5SKurt Hackel }
19226714d8e8SKurt Hackel mle->master = assert->node_idx;
19236714d8e8SKurt Hackel atomic_set(&mle->woken, 1);
19246714d8e8SKurt Hackel wake_up(&mle->wq);
19256714d8e8SKurt Hackel spin_unlock(&mle->spinlock);
19266714d8e8SKurt Hackel
1927a2bf0477SKurt Hackel if (res) {
1928a6fa3640SKurt Hackel int wake = 0;
1929a2bf0477SKurt Hackel spin_lock(&res->spinlock);
1930a2bf0477SKurt Hackel if (mle->type == DLM_MLE_MIGRATION) {
19316714d8e8SKurt Hackel mlog(0, "finishing off migration of lockres %.*s, "
19326714d8e8SKurt Hackel "from %u to %u\n",
19336714d8e8SKurt Hackel res->lockname.len, res->lockname.name,
19346714d8e8SKurt Hackel dlm->node_num, mle->new_master);
19356714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
1936a6fa3640SKurt Hackel wake = 1;
19376714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->new_master);
19386714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DIRTY);
1939a2bf0477SKurt Hackel } else {
1940a2bf0477SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->master);
1941a2bf0477SKurt Hackel }
19426714d8e8SKurt Hackel spin_unlock(&res->spinlock);
1943ba2bf218SKurt Hackel have_lockres_ref = 1;
1944a6fa3640SKurt Hackel if (wake)
1945a6fa3640SKurt Hackel wake_up(&res->wq);
19466714d8e8SKurt Hackel }
19476714d8e8SKurt Hackel
1948a2bf0477SKurt Hackel /* master is known, detach if not already detached.
1949a2bf0477SKurt Hackel * ensures that only one assert_master call will happen
1950a2bf0477SKurt Hackel * on this mle. */
1951a2bf0477SKurt Hackel spin_lock(&dlm->master_lock);
1952a2bf0477SKurt Hackel
19532c935bc5SPeter Zijlstra rr = kref_read(&mle->mle_refs);
1954a2bf0477SKurt Hackel if (mle->inuse > 0) {
1955a2bf0477SKurt Hackel if (extra_ref && rr < 3)
1956a2bf0477SKurt Hackel err = 1;
1957a2bf0477SKurt Hackel else if (!extra_ref && rr < 2)
1958a2bf0477SKurt Hackel err = 1;
1959a2bf0477SKurt Hackel } else {
1960a2bf0477SKurt Hackel if (extra_ref && rr < 2)
1961a2bf0477SKurt Hackel err = 1;
1962a2bf0477SKurt Hackel else if (!extra_ref && rr < 1)
1963a2bf0477SKurt Hackel err = 1;
1964a2bf0477SKurt Hackel }
1965a2bf0477SKurt Hackel if (err) {
1966a2bf0477SKurt Hackel mlog(ML_ERROR, "%s:%.*s: got assert master from %u "
1967a2bf0477SKurt Hackel "that will mess up this node, refs=%d, extra=%d, "
1968a2bf0477SKurt Hackel "inuse=%d\n", dlm->name, namelen, name,
1969a2bf0477SKurt Hackel assert->node_idx, rr, extra_ref, mle->inuse);
1970a2bf0477SKurt Hackel dlm_print_one_mle(mle);
1971a2bf0477SKurt Hackel }
19721c084577SSunil Mushran __dlm_unlink_mle(dlm, mle);
1973a2bf0477SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle);
1974a2bf0477SKurt Hackel __dlm_put_mle(mle);
19756714d8e8SKurt Hackel if (extra_ref) {
19766714d8e8SKurt Hackel /* the assert master message now balances the extra
19776714d8e8SKurt Hackel * ref given by the master / migration request message.
19786714d8e8SKurt Hackel * if this is the last put, it will be removed
19796714d8e8SKurt Hackel * from the list. */
1980a2bf0477SKurt Hackel __dlm_put_mle(mle);
1981a2bf0477SKurt Hackel }
1982a2bf0477SKurt Hackel spin_unlock(&dlm->master_lock);
1983a2bf0477SKurt Hackel } else if (res) {
1984a2bf0477SKurt Hackel if (res->owner != assert->node_idx) {
1985a2bf0477SKurt Hackel mlog(0, "assert_master from %u, but current "
1986a2bf0477SKurt Hackel "owner is %u (%.*s), no mle\n", assert->node_idx,
1987a2bf0477SKurt Hackel res->owner, namelen, name);
19886714d8e8SKurt Hackel }
19896714d8e8SKurt Hackel }
199014741472SSrinivas Eeda spin_unlock(&dlm->spinlock);
19916714d8e8SKurt Hackel
19926714d8e8SKurt Hackel done:
19939c6510a5SKurt Hackel ret = 0;
19943b8118cfSKurt Hackel if (res) {
19953b8118cfSKurt Hackel spin_lock(&res->spinlock);
19963b8118cfSKurt Hackel res->state |= DLM_LOCK_RES_SETREF_INPROG;
19973b8118cfSKurt Hackel spin_unlock(&res->spinlock);
19983b8118cfSKurt Hackel *ret_data = (void *)res;
19993b8118cfSKurt Hackel }
20006714d8e8SKurt Hackel dlm_put(dlm);
20019c6510a5SKurt Hackel if (master_request) {
20029c6510a5SKurt Hackel mlog(0, "need to tell master to reassert\n");
2003ba2bf218SKurt Hackel /* positive. negative would shoot down the node. */
2004ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_REASSERT;
2005ba2bf218SKurt Hackel if (!have_lockres_ref) {
2006ba2bf218SKurt Hackel mlog(ML_ERROR, "strange, got assert from %u, MASTER "
2007ba2bf218SKurt Hackel "mle present here for %s:%.*s, but no lockres!\n",
2008ba2bf218SKurt Hackel assert->node_idx, dlm->name, namelen, name);
2009ba2bf218SKurt Hackel }
2010ba2bf218SKurt Hackel }
2011ba2bf218SKurt Hackel if (have_lockres_ref) {
2012ba2bf218SKurt Hackel /* let the master know we have a reference to the lockres */
2013ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_MASTERY_REF;
2014ba2bf218SKurt Hackel mlog(0, "%s:%.*s: got assert from %u, need a ref\n",
2015ba2bf218SKurt Hackel dlm->name, namelen, name, assert->node_idx);
20169c6510a5SKurt Hackel }
20179c6510a5SKurt Hackel return ret;
20186714d8e8SKurt Hackel
20196714d8e8SKurt Hackel kill:
20206714d8e8SKurt Hackel /* kill the caller! */
2021a9ee4c8aSKurt Hackel mlog(ML_ERROR, "Bad message received from another node. Dumping state "
2022a9ee4c8aSKurt Hackel "and killing the other node now! This node is OK and can continue.\n");
2023a9ee4c8aSKurt Hackel __dlm_print_one_lock_resource(res);
20246714d8e8SKurt Hackel spin_unlock(&res->spinlock);
202555dacd22Salex chen spin_lock(&dlm->master_lock);
202655dacd22Salex chen if (mle)
202755dacd22Salex chen __dlm_put_mle(mle);
202855dacd22Salex chen spin_unlock(&dlm->master_lock);
20296714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
20303b8118cfSKurt Hackel *ret_data = (void *)res;
20316714d8e8SKurt Hackel dlm_put(dlm);
20326714d8e8SKurt Hackel return -EINVAL;
20336714d8e8SKurt Hackel }
20346714d8e8SKurt Hackel
dlm_assert_master_post_handler(int status,void * data,void * ret_data)20353b8118cfSKurt Hackel void dlm_assert_master_post_handler(int status, void *data, void *ret_data)
20363b8118cfSKurt Hackel {
20373b8118cfSKurt Hackel struct dlm_lock_resource *res = (struct dlm_lock_resource *)ret_data;
20383b8118cfSKurt Hackel
20393b8118cfSKurt Hackel if (ret_data) {
20403b8118cfSKurt Hackel spin_lock(&res->spinlock);
20413b8118cfSKurt Hackel res->state &= ~DLM_LOCK_RES_SETREF_INPROG;
20423b8118cfSKurt Hackel spin_unlock(&res->spinlock);
20433b8118cfSKurt Hackel wake_up(&res->wq);
20443b8118cfSKurt Hackel dlm_lockres_put(res);
20453b8118cfSKurt Hackel }
20463b8118cfSKurt Hackel return;
20473b8118cfSKurt Hackel }
20483b8118cfSKurt Hackel
dlm_dispatch_assert_master(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,int ignore_higher,u8 request_from,u32 flags)20496714d8e8SKurt Hackel int dlm_dispatch_assert_master(struct dlm_ctxt *dlm,
20506714d8e8SKurt Hackel struct dlm_lock_resource *res,
20516714d8e8SKurt Hackel int ignore_higher, u8 request_from, u32 flags)
20526714d8e8SKurt Hackel {
20536714d8e8SKurt Hackel struct dlm_work_item *item;
2054b24ae0b5SDan Carpenter item = kzalloc(sizeof(*item), GFP_ATOMIC);
20556714d8e8SKurt Hackel if (!item)
20566714d8e8SKurt Hackel return -ENOMEM;
20576714d8e8SKurt Hackel
20586714d8e8SKurt Hackel
20596714d8e8SKurt Hackel /* queue up work for dlm_assert_master_worker */
20606714d8e8SKurt Hackel dlm_init_work_item(dlm, item, dlm_assert_master_worker, NULL);
20616714d8e8SKurt Hackel item->u.am.lockres = res; /* already have a ref */
20626714d8e8SKurt Hackel /* can optionally ignore node numbers higher than this node */
20636714d8e8SKurt Hackel item->u.am.ignore_higher = ignore_higher;
20646714d8e8SKurt Hackel item->u.am.request_from = request_from;
20656714d8e8SKurt Hackel item->u.am.flags = flags;
20666714d8e8SKurt Hackel
20679c6510a5SKurt Hackel if (ignore_higher)
20689c6510a5SKurt Hackel mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len,
20699c6510a5SKurt Hackel res->lockname.name);
20709c6510a5SKurt Hackel
20716714d8e8SKurt Hackel spin_lock(&dlm->work_lock);
20726714d8e8SKurt Hackel list_add_tail(&item->list, &dlm->work_list);
20736714d8e8SKurt Hackel spin_unlock(&dlm->work_lock);
20746714d8e8SKurt Hackel
20753156d267SKurt Hackel queue_work(dlm->dlm_worker, &dlm->dispatched_work);
20766714d8e8SKurt Hackel return 0;
20776714d8e8SKurt Hackel }
20786714d8e8SKurt Hackel
dlm_assert_master_worker(struct dlm_work_item * item,void * data)20796714d8e8SKurt Hackel static void dlm_assert_master_worker(struct dlm_work_item *item, void *data)
20806714d8e8SKurt Hackel {
20816714d8e8SKurt Hackel struct dlm_ctxt *dlm = data;
20826714d8e8SKurt Hackel int ret = 0;
20836714d8e8SKurt Hackel struct dlm_lock_resource *res;
20846714d8e8SKurt Hackel unsigned long nodemap[BITS_TO_LONGS(O2NM_MAX_NODES)];
20856714d8e8SKurt Hackel int ignore_higher;
20866714d8e8SKurt Hackel int bit;
20876714d8e8SKurt Hackel u8 request_from;
20886714d8e8SKurt Hackel u32 flags;
20896714d8e8SKurt Hackel
20906714d8e8SKurt Hackel dlm = item->dlm;
20916714d8e8SKurt Hackel res = item->u.am.lockres;
20926714d8e8SKurt Hackel ignore_higher = item->u.am.ignore_higher;
20936714d8e8SKurt Hackel request_from = item->u.am.request_from;
20946714d8e8SKurt Hackel flags = item->u.am.flags;
20956714d8e8SKurt Hackel
20966714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
2097*b270f492SJoseph Qi bitmap_copy(nodemap, dlm->domain_map, O2NM_MAX_NODES);
20986714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
20996714d8e8SKurt Hackel
21006714d8e8SKurt Hackel clear_bit(dlm->node_num, nodemap);
21016714d8e8SKurt Hackel if (ignore_higher) {
21026714d8e8SKurt Hackel /* if is this just to clear up mles for nodes below
21036714d8e8SKurt Hackel * this node, do not send the message to the original
21046714d8e8SKurt Hackel * caller or any node number higher than this */
21056714d8e8SKurt Hackel clear_bit(request_from, nodemap);
21066714d8e8SKurt Hackel bit = dlm->node_num;
21076714d8e8SKurt Hackel while (1) {
21086714d8e8SKurt Hackel bit = find_next_bit(nodemap, O2NM_MAX_NODES,
21096714d8e8SKurt Hackel bit+1);
21106714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES)
21116714d8e8SKurt Hackel break;
21126714d8e8SKurt Hackel clear_bit(bit, nodemap);
21136714d8e8SKurt Hackel }
21146714d8e8SKurt Hackel }
21156714d8e8SKurt Hackel
211636407488SKurt Hackel /*
211736407488SKurt Hackel * If we're migrating this lock to someone else, we are no
211836407488SKurt Hackel * longer allowed to assert out own mastery. OTOH, we need to
211936407488SKurt Hackel * prevent migration from starting while we're still asserting
212036407488SKurt Hackel * our dominance. The reserved ast delays migration.
212136407488SKurt Hackel */
212236407488SKurt Hackel spin_lock(&res->spinlock);
212336407488SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) {
212436407488SKurt Hackel mlog(0, "Someone asked us to assert mastery, but we're "
212536407488SKurt Hackel "in the middle of migration. Skipping assert, "
212636407488SKurt Hackel "the new master will handle that.\n");
212736407488SKurt Hackel spin_unlock(&res->spinlock);
212836407488SKurt Hackel goto put;
212936407488SKurt Hackel } else
213036407488SKurt Hackel __dlm_lockres_reserve_ast(res);
213136407488SKurt Hackel spin_unlock(&res->spinlock);
213236407488SKurt Hackel
21336714d8e8SKurt Hackel /* this call now finishes out the nodemap
21346714d8e8SKurt Hackel * even if one or more nodes die */
21356714d8e8SKurt Hackel mlog(0, "worker about to master %.*s here, this=%u\n",
21366714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num);
2137ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, nodemap, flags);
21386714d8e8SKurt Hackel if (ret < 0) {
21396714d8e8SKurt Hackel /* no need to restart, we are done */
21403b3b84a8SKurt Hackel if (!dlm_is_host_down(ret))
21416714d8e8SKurt Hackel mlog_errno(ret);
21426714d8e8SKurt Hackel }
21436714d8e8SKurt Hackel
214436407488SKurt Hackel /* Ok, we've asserted ourselves. Let's let migration start. */
214536407488SKurt Hackel dlm_lockres_release_ast(dlm, res);
214636407488SKurt Hackel
214736407488SKurt Hackel put:
2148ac4fef4dSXue jiufei dlm_lockres_drop_inflight_worker(dlm, res);
2149ac4fef4dSXue jiufei
21506714d8e8SKurt Hackel dlm_lockres_put(res);
21516714d8e8SKurt Hackel
21526714d8e8SKurt Hackel mlog(0, "finished with dlm_assert_master_worker\n");
21536714d8e8SKurt Hackel }
21546714d8e8SKurt Hackel
2155c03872f5SKurt Hackel /* SPECIAL CASE for the $RECOVERY lock used by the recovery thread.
2156c03872f5SKurt Hackel * We cannot wait for node recovery to complete to begin mastering this
2157c03872f5SKurt Hackel * lockres because this lockres is used to kick off recovery! ;-)
2158c03872f5SKurt Hackel * So, do a pre-check on all living nodes to see if any of those nodes
2159c03872f5SKurt Hackel * think that $RECOVERY is currently mastered by a dead node. If so,
2160c03872f5SKurt Hackel * we wait a short time to allow that node to get notified by its own
2161c03872f5SKurt Hackel * heartbeat stack, then check again. All $RECOVERY lock resources
2162e926d8a1SChenGang * mastered by dead nodes are purged when the heartbeat callback is
2163c03872f5SKurt Hackel * fired, so we can know for sure that it is safe to continue once
2164c03872f5SKurt Hackel * the node returns a live node or no node. */
dlm_pre_master_reco_lockres(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)2165c03872f5SKurt Hackel static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm,
2166c03872f5SKurt Hackel struct dlm_lock_resource *res)
2167c03872f5SKurt Hackel {
2168c03872f5SKurt Hackel struct dlm_node_iter iter;
2169c03872f5SKurt Hackel int nodenum;
2170c03872f5SKurt Hackel int ret = 0;
2171c03872f5SKurt Hackel u8 master = DLM_LOCK_RES_OWNER_UNKNOWN;
2172c03872f5SKurt Hackel
2173c03872f5SKurt Hackel spin_lock(&dlm->spinlock);
2174c03872f5SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter);
2175c03872f5SKurt Hackel spin_unlock(&dlm->spinlock);
2176c03872f5SKurt Hackel
2177c03872f5SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) {
2178c03872f5SKurt Hackel /* do not send to self */
2179c03872f5SKurt Hackel if (nodenum == dlm->node_num)
2180c03872f5SKurt Hackel continue;
2181c03872f5SKurt Hackel ret = dlm_do_master_requery(dlm, res, nodenum, &master);
2182c03872f5SKurt Hackel if (ret < 0) {
2183c03872f5SKurt Hackel mlog_errno(ret);
2184c03872f5SKurt Hackel if (!dlm_is_host_down(ret))
2185c03872f5SKurt Hackel BUG();
2186c03872f5SKurt Hackel /* host is down, so answer for that node would be
2187c03872f5SKurt Hackel * DLM_LOCK_RES_OWNER_UNKNOWN. continue. */
2188f42a100bSKurt Hackel ret = 0;
2189c03872f5SKurt Hackel }
2190c03872f5SKurt Hackel
2191c03872f5SKurt Hackel if (master != DLM_LOCK_RES_OWNER_UNKNOWN) {
2192c03872f5SKurt Hackel /* check to see if this master is in the recovery map */
2193c03872f5SKurt Hackel spin_lock(&dlm->spinlock);
2194c03872f5SKurt Hackel if (test_bit(master, dlm->recovery_map)) {
2195c03872f5SKurt Hackel mlog(ML_NOTICE, "%s: node %u has not seen "
2196c03872f5SKurt Hackel "node %u go down yet, and thinks the "
2197c03872f5SKurt Hackel "dead node is mastering the recovery "
2198c03872f5SKurt Hackel "lock. must wait.\n", dlm->name,
2199c03872f5SKurt Hackel nodenum, master);
2200c03872f5SKurt Hackel ret = -EAGAIN;
2201c03872f5SKurt Hackel }
2202c03872f5SKurt Hackel spin_unlock(&dlm->spinlock);
2203c03872f5SKurt Hackel mlog(0, "%s: reco lock master is %u\n", dlm->name,
2204c03872f5SKurt Hackel master);
2205c03872f5SKurt Hackel break;
2206c03872f5SKurt Hackel }
2207c03872f5SKurt Hackel }
2208c03872f5SKurt Hackel return ret;
2209c03872f5SKurt Hackel }
2210c03872f5SKurt Hackel
2211ba2bf218SKurt Hackel /*
2212ba2bf218SKurt Hackel * DLM_DEREF_LOCKRES_MSG
2213ba2bf218SKurt Hackel */
2214ba2bf218SKurt Hackel
dlm_drop_lockres_ref(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)2215ba2bf218SKurt Hackel int dlm_drop_lockres_ref(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
2216ba2bf218SKurt Hackel {
2217ba2bf218SKurt Hackel struct dlm_deref_lockres deref;
2218ba2bf218SKurt Hackel int ret = 0, r;
2219ba2bf218SKurt Hackel const char *lockname;
2220ba2bf218SKurt Hackel unsigned int namelen;
2221ba2bf218SKurt Hackel
2222ba2bf218SKurt Hackel lockname = res->lockname.name;
2223ba2bf218SKurt Hackel namelen = res->lockname.len;
2224ba2bf218SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN);
2225ba2bf218SKurt Hackel
2226ba2bf218SKurt Hackel memset(&deref, 0, sizeof(deref));
2227ba2bf218SKurt Hackel deref.node_idx = dlm->node_num;
2228ba2bf218SKurt Hackel deref.namelen = namelen;
2229ba2bf218SKurt Hackel memcpy(deref.name, lockname, namelen);
2230ba2bf218SKurt Hackel
2231ba2bf218SKurt Hackel ret = o2net_send_message(DLM_DEREF_LOCKRES_MSG, dlm->key,
2232ba2bf218SKurt Hackel &deref, sizeof(deref), res->owner, &r);
2233ba2bf218SKurt Hackel if (ret < 0)
22348decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, error %d send DEREF to node %u\n",
22358decab3cSSunil Mushran dlm->name, namelen, lockname, ret, res->owner);
2236ba2bf218SKurt Hackel else if (r < 0) {
2237ba2bf218SKurt Hackel /* BAD. other node says I did not have a ref. */
22388decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, DEREF to node %u got %d\n",
22398decab3cSSunil Mushran dlm->name, namelen, lockname, res->owner, r);
2240ba2bf218SKurt Hackel dlm_print_one_lock_resource(res);
2241309e9191Spiaojun if (r == -ENOMEM)
2242ba2bf218SKurt Hackel BUG();
2243309e9191Spiaojun } else
2244309e9191Spiaojun ret = r;
2245309e9191Spiaojun
2246309e9191Spiaojun return ret;
2247ba2bf218SKurt Hackel }
2248ba2bf218SKurt Hackel
dlm_deref_lockres_handler(struct o2net_msg * msg,u32 len,void * data,void ** ret_data)2249d74c9803SKurt Hackel int dlm_deref_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
2250d74c9803SKurt Hackel void **ret_data)
2251ba2bf218SKurt Hackel {
2252ba2bf218SKurt Hackel struct dlm_ctxt *dlm = data;
2253ba2bf218SKurt Hackel struct dlm_deref_lockres *deref = (struct dlm_deref_lockres *)msg->buf;
2254ba2bf218SKurt Hackel struct dlm_lock_resource *res = NULL;
2255ba2bf218SKurt Hackel char *name;
2256ba2bf218SKurt Hackel unsigned int namelen;
2257ba2bf218SKurt Hackel int ret = -EINVAL;
2258ba2bf218SKurt Hackel u8 node;
2259ba2bf218SKurt Hackel unsigned int hash;
2260f3f85464SSunil Mushran struct dlm_work_item *item;
2261f3f85464SSunil Mushran int cleared = 0;
2262f3f85464SSunil Mushran int dispatch = 0;
2263ba2bf218SKurt Hackel
2264ba2bf218SKurt Hackel if (!dlm_grab(dlm))
2265ba2bf218SKurt Hackel return 0;
2266ba2bf218SKurt Hackel
2267ba2bf218SKurt Hackel name = deref->name;
2268ba2bf218SKurt Hackel namelen = deref->namelen;
2269ba2bf218SKurt Hackel node = deref->node_idx;
2270ba2bf218SKurt Hackel
2271ba2bf218SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) {
2272ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid name length!");
2273ba2bf218SKurt Hackel goto done;
2274ba2bf218SKurt Hackel }
2275ba2bf218SKurt Hackel if (deref->node_idx >= O2NM_MAX_NODES) {
2276ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid node number: %u\n", node);
2277ba2bf218SKurt Hackel goto done;
2278ba2bf218SKurt Hackel }
2279ba2bf218SKurt Hackel
2280ba2bf218SKurt Hackel hash = dlm_lockid_hash(name, namelen);
2281ba2bf218SKurt Hackel
2282ba2bf218SKurt Hackel spin_lock(&dlm->spinlock);
2283ba2bf218SKurt Hackel res = __dlm_lookup_lockres_full(dlm, name, namelen, hash);
2284ba2bf218SKurt Hackel if (!res) {
2285ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock);
2286ba2bf218SKurt Hackel mlog(ML_ERROR, "%s:%.*s: bad lockres name\n",
2287ba2bf218SKurt Hackel dlm->name, namelen, name);
2288ba2bf218SKurt Hackel goto done;
2289ba2bf218SKurt Hackel }
2290ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock);
2291ba2bf218SKurt Hackel
2292ba2bf218SKurt Hackel spin_lock(&res->spinlock);
2293f3f85464SSunil Mushran if (res->state & DLM_LOCK_RES_SETREF_INPROG)
2294f3f85464SSunil Mushran dispatch = 1;
2295f3f85464SSunil Mushran else {
2296ba2bf218SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF);
2297ba2bf218SKurt Hackel if (test_bit(node, res->refmap)) {
22988d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, node);
2299f3f85464SSunil Mushran cleared = 1;
2300f3f85464SSunil Mushran }
2301ba2bf218SKurt Hackel }
2302ba2bf218SKurt Hackel spin_unlock(&res->spinlock);
2303ba2bf218SKurt Hackel
2304f3f85464SSunil Mushran if (!dispatch) {
2305f3f85464SSunil Mushran if (cleared)
2306ba2bf218SKurt Hackel dlm_lockres_calc_usage(dlm, res);
2307f3f85464SSunil Mushran else {
2308f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref "
2309f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name,
2310f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node);
23112af37ce8STao Ma dlm_print_one_lock_resource(res);
2312f3f85464SSunil Mushran }
2313842b90b6Sxuejiufei ret = DLM_DEREF_RESPONSE_DONE;
2314f3f85464SSunil Mushran goto done;
2315f3f85464SSunil Mushran }
2316f3f85464SSunil Mushran
2317f3f85464SSunil Mushran item = kzalloc(sizeof(*item), GFP_NOFS);
2318f3f85464SSunil Mushran if (!item) {
2319f3f85464SSunil Mushran ret = -ENOMEM;
2320f3f85464SSunil Mushran mlog_errno(ret);
2321f3f85464SSunil Mushran goto done;
2322f3f85464SSunil Mushran }
2323f3f85464SSunil Mushran
2324f3f85464SSunil Mushran dlm_init_work_item(dlm, item, dlm_deref_lockres_worker, NULL);
2325f3f85464SSunil Mushran item->u.dl.deref_res = res;
2326f3f85464SSunil Mushran item->u.dl.deref_node = node;
2327f3f85464SSunil Mushran
2328f3f85464SSunil Mushran spin_lock(&dlm->work_lock);
2329f3f85464SSunil Mushran list_add_tail(&item->list, &dlm->work_list);
2330f3f85464SSunil Mushran spin_unlock(&dlm->work_lock);
2331f3f85464SSunil Mushran
2332f3f85464SSunil Mushran queue_work(dlm->dlm_worker, &dlm->dispatched_work);
2333842b90b6Sxuejiufei return DLM_DEREF_RESPONSE_INPROG;
2334f3f85464SSunil Mushran
2335ba2bf218SKurt Hackel done:
2336ba2bf218SKurt Hackel if (res)
2337ba2bf218SKurt Hackel dlm_lockres_put(res);
2338ba2bf218SKurt Hackel dlm_put(dlm);
2339f3f85464SSunil Mushran
2340ba2bf218SKurt Hackel return ret;
2341ba2bf218SKurt Hackel }
2342ba2bf218SKurt Hackel
dlm_deref_lockres_done_handler(struct o2net_msg * msg,u32 len,void * data,void ** ret_data)234360d663cbSxuejiufei int dlm_deref_lockres_done_handler(struct o2net_msg *msg, u32 len, void *data,
234460d663cbSxuejiufei void **ret_data)
234560d663cbSxuejiufei {
234660d663cbSxuejiufei struct dlm_ctxt *dlm = data;
234760d663cbSxuejiufei struct dlm_deref_lockres_done *deref
234860d663cbSxuejiufei = (struct dlm_deref_lockres_done *)msg->buf;
234960d663cbSxuejiufei struct dlm_lock_resource *res = NULL;
235060d663cbSxuejiufei char *name;
235160d663cbSxuejiufei unsigned int namelen;
235260d663cbSxuejiufei int ret = -EINVAL;
235360d663cbSxuejiufei u8 node;
235460d663cbSxuejiufei unsigned int hash;
235560d663cbSxuejiufei
235660d663cbSxuejiufei if (!dlm_grab(dlm))
235760d663cbSxuejiufei return 0;
235860d663cbSxuejiufei
235960d663cbSxuejiufei name = deref->name;
236060d663cbSxuejiufei namelen = deref->namelen;
236160d663cbSxuejiufei node = deref->node_idx;
236260d663cbSxuejiufei
236360d663cbSxuejiufei if (namelen > DLM_LOCKID_NAME_MAX) {
236460d663cbSxuejiufei mlog(ML_ERROR, "Invalid name length!");
236560d663cbSxuejiufei goto done;
236660d663cbSxuejiufei }
236760d663cbSxuejiufei if (deref->node_idx >= O2NM_MAX_NODES) {
236860d663cbSxuejiufei mlog(ML_ERROR, "Invalid node number: %u\n", node);
236960d663cbSxuejiufei goto done;
237060d663cbSxuejiufei }
237160d663cbSxuejiufei
237260d663cbSxuejiufei hash = dlm_lockid_hash(name, namelen);
237360d663cbSxuejiufei
237460d663cbSxuejiufei spin_lock(&dlm->spinlock);
237560d663cbSxuejiufei res = __dlm_lookup_lockres_full(dlm, name, namelen, hash);
237660d663cbSxuejiufei if (!res) {
237760d663cbSxuejiufei spin_unlock(&dlm->spinlock);
237860d663cbSxuejiufei mlog(ML_ERROR, "%s:%.*s: bad lockres name\n",
237960d663cbSxuejiufei dlm->name, namelen, name);
238060d663cbSxuejiufei goto done;
238160d663cbSxuejiufei }
238260d663cbSxuejiufei
238360d663cbSxuejiufei spin_lock(&res->spinlock);
238486b652b9Spiaojun if (!(res->state & DLM_LOCK_RES_DROPPING_REF)) {
238586b652b9Spiaojun spin_unlock(&res->spinlock);
238686b652b9Spiaojun spin_unlock(&dlm->spinlock);
238786b652b9Spiaojun mlog(ML_NOTICE, "%s:%.*s: node %u sends deref done "
238886b652b9Spiaojun "but it is already derefed!\n", dlm->name,
238986b652b9Spiaojun res->lockname.len, res->lockname.name, node);
239086b652b9Spiaojun ret = 0;
239186b652b9Spiaojun goto done;
239286b652b9Spiaojun }
239386b652b9Spiaojun
2394ee8f7fcbSpiaojun __dlm_do_purge_lockres(dlm, res);
239560d663cbSxuejiufei spin_unlock(&res->spinlock);
239660d663cbSxuejiufei wake_up(&res->wq);
239760d663cbSxuejiufei
239860d663cbSxuejiufei spin_unlock(&dlm->spinlock);
239960d663cbSxuejiufei
2400b7341364Sxuejiufei ret = 0;
240160d663cbSxuejiufei done:
2402ee8f7fcbSpiaojun if (res)
2403ee8f7fcbSpiaojun dlm_lockres_put(res);
240460d663cbSxuejiufei dlm_put(dlm);
240560d663cbSxuejiufei return ret;
240660d663cbSxuejiufei }
240760d663cbSxuejiufei
dlm_drop_lockres_ref_done(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 node)240860d663cbSxuejiufei static void dlm_drop_lockres_ref_done(struct dlm_ctxt *dlm,
240960d663cbSxuejiufei struct dlm_lock_resource *res, u8 node)
241060d663cbSxuejiufei {
241160d663cbSxuejiufei struct dlm_deref_lockres_done deref;
241260d663cbSxuejiufei int ret = 0, r;
241360d663cbSxuejiufei const char *lockname;
241460d663cbSxuejiufei unsigned int namelen;
241560d663cbSxuejiufei
241660d663cbSxuejiufei lockname = res->lockname.name;
241760d663cbSxuejiufei namelen = res->lockname.len;
241860d663cbSxuejiufei BUG_ON(namelen > O2NM_MAX_NAME_LEN);
241960d663cbSxuejiufei
242060d663cbSxuejiufei memset(&deref, 0, sizeof(deref));
242160d663cbSxuejiufei deref.node_idx = dlm->node_num;
242260d663cbSxuejiufei deref.namelen = namelen;
242360d663cbSxuejiufei memcpy(deref.name, lockname, namelen);
242460d663cbSxuejiufei
242560d663cbSxuejiufei ret = o2net_send_message(DLM_DEREF_LOCKRES_DONE, dlm->key,
242660d663cbSxuejiufei &deref, sizeof(deref), node, &r);
242760d663cbSxuejiufei if (ret < 0) {
242860d663cbSxuejiufei mlog(ML_ERROR, "%s: res %.*s, error %d send DEREF DONE "
242960d663cbSxuejiufei " to node %u\n", dlm->name, namelen,
243060d663cbSxuejiufei lockname, ret, node);
243160d663cbSxuejiufei } else if (r < 0) {
243260d663cbSxuejiufei /* ignore the error */
243360d663cbSxuejiufei mlog(ML_ERROR, "%s: res %.*s, DEREF to node %u got %d\n",
243460d663cbSxuejiufei dlm->name, namelen, lockname, node, r);
243560d663cbSxuejiufei dlm_print_one_lock_resource(res);
243660d663cbSxuejiufei }
243760d663cbSxuejiufei }
243860d663cbSxuejiufei
dlm_deref_lockres_worker(struct dlm_work_item * item,void * data)2439f3f85464SSunil Mushran static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data)
2440f3f85464SSunil Mushran {
2441f3f85464SSunil Mushran struct dlm_ctxt *dlm;
2442f3f85464SSunil Mushran struct dlm_lock_resource *res;
2443f3f85464SSunil Mushran u8 node;
2444f3f85464SSunil Mushran u8 cleared = 0;
2445f3f85464SSunil Mushran
2446f3f85464SSunil Mushran dlm = item->dlm;
2447f3f85464SSunil Mushran res = item->u.dl.deref_res;
2448f3f85464SSunil Mushran node = item->u.dl.deref_node;
2449f3f85464SSunil Mushran
2450f3f85464SSunil Mushran spin_lock(&res->spinlock);
2451f3f85464SSunil Mushran BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF);
2452f3f85464SSunil Mushran __dlm_wait_on_lockres_flags(res, DLM_LOCK_RES_SETREF_INPROG);
2453b5560143Sjiangyiwen if (test_bit(node, res->refmap)) {
24548d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, node);
2455f3f85464SSunil Mushran cleared = 1;
2456f3f85464SSunil Mushran }
2457f3f85464SSunil Mushran spin_unlock(&res->spinlock);
2458f3f85464SSunil Mushran
2459842b90b6Sxuejiufei dlm_drop_lockres_ref_done(dlm, res, node);
2460842b90b6Sxuejiufei
2461f3f85464SSunil Mushran if (cleared) {
2462f3f85464SSunil Mushran mlog(0, "%s:%.*s node %u ref dropped in dispatch\n",
2463f3f85464SSunil Mushran dlm->name, res->lockname.len, res->lockname.name, node);
2464f3f85464SSunil Mushran dlm_lockres_calc_usage(dlm, res);
2465f3f85464SSunil Mushran } else {
2466f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref "
2467f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name,
2468f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node);
24692af37ce8STao Ma dlm_print_one_lock_resource(res);
2470f3f85464SSunil Mushran }
2471f3f85464SSunil Mushran
2472f3f85464SSunil Mushran dlm_lockres_put(res);
2473f3f85464SSunil Mushran }
2474f3f85464SSunil Mushran
24759f62e960SSunil Mushran /*
2476baa31b89SChangwei Ge * A migratable resource is one that is :
24779f62e960SSunil Mushran * 1. locally mastered, and,
24789f62e960SSunil Mushran * 2. zero local locks, and,
24799f62e960SSunil Mushran * 3. one or more non-local locks, or, one or more references
24809f62e960SSunil Mushran * Returns 1 if yes, 0 if not.
24812f5bf1f2SSunil Mushran */
dlm_is_lockres_migratable(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)2482baa31b89SChangwei Ge static int dlm_is_lockres_migratable(struct dlm_ctxt *dlm,
24839f62e960SSunil Mushran struct dlm_lock_resource *res)
24842f5bf1f2SSunil Mushran {
24859f62e960SSunil Mushran enum dlm_lockres_list idx;
24869f62e960SSunil Mushran int nonlocal = 0, node_ref;
2487800deef3SChristoph Hellwig struct list_head *queue;
24882f5bf1f2SSunil Mushran struct dlm_lock *lock;
24899f62e960SSunil Mushran u64 cookie;
24902f5bf1f2SSunil Mushran
24912f5bf1f2SSunil Mushran assert_spin_locked(&res->spinlock);
24922f5bf1f2SSunil Mushran
2493fae477b6SXue jiufei /* delay migration when the lockres is in MIGRATING state */
2494fae477b6SXue jiufei if (res->state & DLM_LOCK_RES_MIGRATING)
2495fae477b6SXue jiufei return 0;
2496fae477b6SXue jiufei
2497bba1cb17STariq Saeed /* delay migration when the lockres is in RECOCERING state */
2498814ce694SJiufei Xue if (res->state & (DLM_LOCK_RES_RECOVERING|
2499814ce694SJiufei Xue DLM_LOCK_RES_RECOVERY_WAITING))
2500bba1cb17STariq Saeed return 0;
2501bba1cb17STariq Saeed
25029f62e960SSunil Mushran if (res->owner != dlm->node_num)
25039f62e960SSunil Mushran return 0;
2504388c4bcbSSunil Mushran
25059f62e960SSunil Mushran for (idx = DLM_GRANTED_LIST; idx <= DLM_BLOCKED_LIST; idx++) {
25069f62e960SSunil Mushran queue = dlm_list_idx_to_ptr(res, idx);
2507800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) {
25089f62e960SSunil Mushran if (lock->ml.node != dlm->node_num) {
25099f62e960SSunil Mushran nonlocal++;
25109f62e960SSunil Mushran continue;
25119f62e960SSunil Mushran }
25129f62e960SSunil Mushran cookie = be64_to_cpu(lock->ml.cookie);
2513baa31b89SChangwei Ge mlog(0, "%s: Not migratable res %.*s, lock %u:%llu on "
25149f62e960SSunil Mushran "%s list\n", dlm->name, res->lockname.len,
25159f62e960SSunil Mushran res->lockname.name,
25169f62e960SSunil Mushran dlm_get_lock_cookie_node(cookie),
25179f62e960SSunil Mushran dlm_get_lock_cookie_seq(cookie),
25189f62e960SSunil Mushran dlm_list_in_text(idx));
25199f62e960SSunil Mushran return 0;
25202f5bf1f2SSunil Mushran }
25212f5bf1f2SSunil Mushran }
25229f62e960SSunil Mushran
25239f62e960SSunil Mushran if (!nonlocal) {
2524b5c7e7ecSYury Norov node_ref = find_first_bit(res->refmap, O2NM_MAX_NODES);
25259f62e960SSunil Mushran if (node_ref >= O2NM_MAX_NODES)
25269f62e960SSunil Mushran return 0;
25272f5bf1f2SSunil Mushran }
25282f5bf1f2SSunil Mushran
2529510c4879SColin Ian King mlog(0, "%s: res %.*s, Migratable\n", dlm->name, res->lockname.len,
25309f62e960SSunil Mushran res->lockname.name);
2531388c4bcbSSunil Mushran
25329f62e960SSunil Mushran return 1;
25332f5bf1f2SSunil Mushran }
25346714d8e8SKurt Hackel
25356714d8e8SKurt Hackel /*
25366714d8e8SKurt Hackel * DLM_MIGRATE_LOCKRES
25376714d8e8SKurt Hackel */
25386714d8e8SKurt Hackel
25396714d8e8SKurt Hackel
dlm_migrate_lockres(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 target)2540faf0ec9fSAdrian Bunk static int dlm_migrate_lockres(struct dlm_ctxt *dlm,
254166effd3cSSunil Mushran struct dlm_lock_resource *res, u8 target)
25426714d8e8SKurt Hackel {
25436714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL;
25446714d8e8SKurt Hackel struct dlm_master_list_entry *oldmle = NULL;
25456714d8e8SKurt Hackel struct dlm_migratable_lockres *mres = NULL;
25462f5bf1f2SSunil Mushran int ret = 0;
25476714d8e8SKurt Hackel const char *name;
25486714d8e8SKurt Hackel unsigned int namelen;
25496714d8e8SKurt Hackel int mle_added = 0;
25502f5bf1f2SSunil Mushran int wake = 0;
25516714d8e8SKurt Hackel
25526714d8e8SKurt Hackel if (!dlm_grab(dlm))
25536714d8e8SKurt Hackel return -EINVAL;
25546714d8e8SKurt Hackel
25556714d8e8SKurt Hackel name = res->lockname.name;
25566714d8e8SKurt Hackel namelen = res->lockname.len;
25576714d8e8SKurt Hackel
255866effd3cSSunil Mushran mlog(0, "%s: Migrating %.*s to node %u\n", dlm->name, namelen, name,
255966effd3cSSunil Mushran target);
25606714d8e8SKurt Hackel
256166effd3cSSunil Mushran /* preallocate up front. if this fails, abort */
25626714d8e8SKurt Hackel ret = -ENOMEM;
2563ad8100e0SKurt Hackel mres = (struct dlm_migratable_lockres *) __get_free_page(GFP_NOFS);
25646714d8e8SKurt Hackel if (!mres) {
25656714d8e8SKurt Hackel mlog_errno(ret);
25666714d8e8SKurt Hackel goto leave;
25676714d8e8SKurt Hackel }
25686714d8e8SKurt Hackel
25693914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS);
25706714d8e8SKurt Hackel if (!mle) {
25716714d8e8SKurt Hackel mlog_errno(ret);
25726714d8e8SKurt Hackel goto leave;
25736714d8e8SKurt Hackel }
25746714d8e8SKurt Hackel ret = 0;
25756714d8e8SKurt Hackel
25766714d8e8SKurt Hackel /*
25776714d8e8SKurt Hackel * clear any existing master requests and
25786714d8e8SKurt Hackel * add the migration mle to the list
25796714d8e8SKurt Hackel */
258066effd3cSSunil Mushran spin_lock(&dlm->spinlock);
25816714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
25826714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, name,
25836714d8e8SKurt Hackel namelen, target, dlm->node_num);
2584bef5502dSxuejiufei /* get an extra reference on the mle.
2585bef5502dSxuejiufei * otherwise the assert_master from the new
2586bef5502dSxuejiufei * master will destroy this.
2587bef5502dSxuejiufei */
25883db409faSChangwei Ge if (ret != -EEXIST)
2589bef5502dSxuejiufei dlm_get_mle_inuse(mle);
25903db409faSChangwei Ge
25916714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
25926714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
25936714d8e8SKurt Hackel
25946714d8e8SKurt Hackel if (ret == -EEXIST) {
25956714d8e8SKurt Hackel mlog(0, "another process is already migrating it\n");
25966714d8e8SKurt Hackel goto fail;
25976714d8e8SKurt Hackel }
25986714d8e8SKurt Hackel mle_added = 1;
25996714d8e8SKurt Hackel
26006714d8e8SKurt Hackel /*
26016714d8e8SKurt Hackel * set the MIGRATING flag and flush asts
26026714d8e8SKurt Hackel * if we fail after this we need to re-dirty the lockres
26036714d8e8SKurt Hackel */
26046714d8e8SKurt Hackel if (dlm_mark_lockres_migrating(dlm, res, target) < 0) {
26056714d8e8SKurt Hackel mlog(ML_ERROR, "tried to migrate %.*s to %u, but "
26066714d8e8SKurt Hackel "the target went down.\n", res->lockname.len,
26076714d8e8SKurt Hackel res->lockname.name, target);
26086714d8e8SKurt Hackel spin_lock(&res->spinlock);
26096714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
2610a6fa3640SKurt Hackel wake = 1;
26116714d8e8SKurt Hackel spin_unlock(&res->spinlock);
26126714d8e8SKurt Hackel ret = -EINVAL;
26136714d8e8SKurt Hackel }
26146714d8e8SKurt Hackel
26156714d8e8SKurt Hackel fail:
261632e49326Sxuejiufei if (ret != -EEXIST && oldmle) {
26176714d8e8SKurt Hackel /* master is known, detach if not already detached */
26186714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle);
26196714d8e8SKurt Hackel dlm_put_mle(oldmle);
26206714d8e8SKurt Hackel }
26216714d8e8SKurt Hackel
26226714d8e8SKurt Hackel if (ret < 0) {
26236714d8e8SKurt Hackel if (mle_added) {
26246714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
26256714d8e8SKurt Hackel dlm_put_mle(mle);
2626bef5502dSxuejiufei dlm_put_mle_inuse(mle);
26276714d8e8SKurt Hackel } else if (mle) {
26286714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
262966effd3cSSunil Mushran mle = NULL;
26306714d8e8SKurt Hackel }
26316714d8e8SKurt Hackel goto leave;
26326714d8e8SKurt Hackel }
26336714d8e8SKurt Hackel
26346714d8e8SKurt Hackel /*
26356714d8e8SKurt Hackel * at this point, we have a migration target, an mle
26366714d8e8SKurt Hackel * in the master list, and the MIGRATING flag set on
26376714d8e8SKurt Hackel * the lockres
26386714d8e8SKurt Hackel */
26396714d8e8SKurt Hackel
26401cd04dbeSKurt Hackel /* now that remote nodes are spinning on the MIGRATING flag,
26411cd04dbeSKurt Hackel * ensure that all assert_master work is flushed. */
26421cd04dbeSKurt Hackel flush_workqueue(dlm->dlm_worker);
26436714d8e8SKurt Hackel
26446714d8e8SKurt Hackel /* notify new node and send all lock state */
26456714d8e8SKurt Hackel /* call send_one_lockres with migration flag.
26466714d8e8SKurt Hackel * this serves as notice to the target node that a
26476714d8e8SKurt Hackel * migration is starting. */
26486714d8e8SKurt Hackel ret = dlm_send_one_lockres(dlm, res, mres, target,
26496714d8e8SKurt Hackel DLM_MRES_MIGRATION);
26506714d8e8SKurt Hackel
26516714d8e8SKurt Hackel if (ret < 0) {
26526714d8e8SKurt Hackel mlog(0, "migration to node %u failed with %d\n",
26536714d8e8SKurt Hackel target, ret);
26546714d8e8SKurt Hackel /* migration failed, detach and clean up mle */
26556714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
26566714d8e8SKurt Hackel dlm_put_mle(mle);
2657a2bf0477SKurt Hackel dlm_put_mle_inuse(mle);
2658a2bf0477SKurt Hackel spin_lock(&res->spinlock);
2659a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
2660a6fa3640SKurt Hackel wake = 1;
2661a2bf0477SKurt Hackel spin_unlock(&res->spinlock);
2662df016c66SSunil Mushran if (dlm_is_host_down(ret))
2663df016c66SSunil Mushran dlm_wait_for_node_death(dlm, target,
2664df016c66SSunil Mushran DLM_NODE_DEATH_WAIT_MAX);
26656714d8e8SKurt Hackel goto leave;
26666714d8e8SKurt Hackel }
26676714d8e8SKurt Hackel
26686714d8e8SKurt Hackel /* at this point, the target sends a message to all nodes,
26696714d8e8SKurt Hackel * (using dlm_do_migrate_request). this node is skipped since
26706714d8e8SKurt Hackel * we had to put an mle in the list to begin the process. this
26716714d8e8SKurt Hackel * node now waits for target to do an assert master. this node
26726714d8e8SKurt Hackel * will be the last one notified, ensuring that the migration
26736714d8e8SKurt Hackel * is complete everywhere. if the target dies while this is
26746714d8e8SKurt Hackel * going on, some nodes could potentially see the target as the
26756714d8e8SKurt Hackel * master, so it is important that my recovery finds the migration
2676af901ca1SAndré Goddard Rosa * mle and sets the master to UNKNOWN. */
26776714d8e8SKurt Hackel
26786714d8e8SKurt Hackel
26796714d8e8SKurt Hackel /* wait for new node to assert master */
26806714d8e8SKurt Hackel while (1) {
26816714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(mle->wq,
26826714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1),
26836714d8e8SKurt Hackel msecs_to_jiffies(5000));
26846714d8e8SKurt Hackel
26856714d8e8SKurt Hackel if (ret >= 0) {
26866714d8e8SKurt Hackel if (atomic_read(&mle->woken) == 1 ||
26876714d8e8SKurt Hackel res->owner == target)
26886714d8e8SKurt Hackel break;
26896714d8e8SKurt Hackel
26901cd04dbeSKurt Hackel mlog(0, "%s:%.*s: timed out during migration\n",
26911cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name);
2692e2faea4cSKurt Hackel /* avoid hang during shutdown when migrating lockres
2693e2faea4cSKurt Hackel * to a node which also goes down */
2694e2faea4cSKurt Hackel if (dlm_is_node_dead(dlm, target)) {
2695aa852354SKurt Hackel mlog(0, "%s:%.*s: expected migration "
2696aa852354SKurt Hackel "target %u is no longer up, restarting\n",
2697e2faea4cSKurt Hackel dlm->name, res->lockname.len,
2698e2faea4cSKurt Hackel res->lockname.name, target);
26991cd04dbeSKurt Hackel ret = -EINVAL;
27006714d8e8SKurt Hackel /* migration failed, detach and clean up mle */
27016714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
27026714d8e8SKurt Hackel dlm_put_mle(mle);
2703a2bf0477SKurt Hackel dlm_put_mle_inuse(mle);
2704a2bf0477SKurt Hackel spin_lock(&res->spinlock);
2705a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
2706a6fa3640SKurt Hackel wake = 1;
2707a2bf0477SKurt Hackel spin_unlock(&res->spinlock);
27086714d8e8SKurt Hackel goto leave;
27096714d8e8SKurt Hackel }
27101cd04dbeSKurt Hackel } else
27111cd04dbeSKurt Hackel mlog(0, "%s:%.*s: caught signal during migration\n",
27121cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name);
27136714d8e8SKurt Hackel }
27146714d8e8SKurt Hackel
27156714d8e8SKurt Hackel /* all done, set the owner, clear the flag */
27166714d8e8SKurt Hackel spin_lock(&res->spinlock);
27176714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, target);
27186714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
27196714d8e8SKurt Hackel dlm_remove_nonlocal_locks(dlm, res);
27206714d8e8SKurt Hackel spin_unlock(&res->spinlock);
27216714d8e8SKurt Hackel wake_up(&res->wq);
27226714d8e8SKurt Hackel
27236714d8e8SKurt Hackel /* master is known, detach if not already detached */
27246714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle);
2725a2bf0477SKurt Hackel dlm_put_mle_inuse(mle);
27266714d8e8SKurt Hackel ret = 0;
27276714d8e8SKurt Hackel
27286714d8e8SKurt Hackel dlm_lockres_calc_usage(dlm, res);
27296714d8e8SKurt Hackel
27306714d8e8SKurt Hackel leave:
27316714d8e8SKurt Hackel /* re-dirty the lockres if we failed */
27326714d8e8SKurt Hackel if (ret < 0)
27336714d8e8SKurt Hackel dlm_kick_thread(dlm, res);
27346714d8e8SKurt Hackel
2735a6fa3640SKurt Hackel /* wake up waiters if the MIGRATING flag got set
2736a6fa3640SKurt Hackel * but migration failed */
2737a6fa3640SKurt Hackel if (wake)
2738a6fa3640SKurt Hackel wake_up(&res->wq);
2739a6fa3640SKurt Hackel
27406714d8e8SKurt Hackel if (mres)
27416714d8e8SKurt Hackel free_page((unsigned long)mres);
27426714d8e8SKurt Hackel
27436714d8e8SKurt Hackel dlm_put(dlm);
27446714d8e8SKurt Hackel
27459f62e960SSunil Mushran mlog(0, "%s: Migrating %.*s to %u, returns %d\n", dlm->name, namelen,
27469f62e960SSunil Mushran name, target, ret);
27476714d8e8SKurt Hackel return ret;
27486714d8e8SKurt Hackel }
27496714d8e8SKurt Hackel
27509f62e960SSunil Mushran /*
27519f62e960SSunil Mushran * Should be called only after beginning the domain leave process.
2752ba2bf218SKurt Hackel * There should not be any remaining locks on nonlocal lock resources,
2753ba2bf218SKurt Hackel * and there should be no local locks left on locally mastered resources.
2754ba2bf218SKurt Hackel *
2755ba2bf218SKurt Hackel * Called with the dlm spinlock held, may drop it to do migration, but
2756ba2bf218SKurt Hackel * will re-acquire before exit.
2757ba2bf218SKurt Hackel *
27589f62e960SSunil Mushran * Returns: 1 if dlm->spinlock was dropped/retaken, 0 if never dropped
27599f62e960SSunil Mushran */
dlm_empty_lockres(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)2760ba2bf218SKurt Hackel int dlm_empty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
27618f745e62SJules Irenge __must_hold(&dlm->spinlock)
2762ba2bf218SKurt Hackel {
276366effd3cSSunil Mushran int ret;
2764ba2bf218SKurt Hackel int lock_dropped = 0;
276566effd3cSSunil Mushran u8 target = O2NM_MAX_NODES;
27669f62e960SSunil Mushran
27679f62e960SSunil Mushran assert_spin_locked(&dlm->spinlock);
2768ba2bf218SKurt Hackel
2769b36c3f84SSunil Mushran spin_lock(&res->spinlock);
2770baa31b89SChangwei Ge if (dlm_is_lockres_migratable(dlm, res))
277166effd3cSSunil Mushran target = dlm_pick_migration_target(dlm, res);
2772b36c3f84SSunil Mushran spin_unlock(&res->spinlock);
277366effd3cSSunil Mushran
277466effd3cSSunil Mushran if (target == O2NM_MAX_NODES)
2775ba2bf218SKurt Hackel goto leave;
2776ba2bf218SKurt Hackel
2777ba2bf218SKurt Hackel /* Wheee! Migrate lockres here! Will sleep so drop spinlock. */
2778ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock);
2779ba2bf218SKurt Hackel lock_dropped = 1;
278066effd3cSSunil Mushran ret = dlm_migrate_lockres(dlm, res, target);
278166effd3cSSunil Mushran if (ret)
278266effd3cSSunil Mushran mlog(0, "%s: res %.*s, Migrate to node %u failed with %d\n",
278366effd3cSSunil Mushran dlm->name, res->lockname.len, res->lockname.name,
278466effd3cSSunil Mushran target, ret);
2785ba2bf218SKurt Hackel spin_lock(&dlm->spinlock);
2786ba2bf218SKurt Hackel leave:
2787ba2bf218SKurt Hackel return lock_dropped;
2788ba2bf218SKurt Hackel }
2789ba2bf218SKurt Hackel
dlm_lock_basts_flushed(struct dlm_ctxt * dlm,struct dlm_lock * lock)27906714d8e8SKurt Hackel int dlm_lock_basts_flushed(struct dlm_ctxt *dlm, struct dlm_lock *lock)
27916714d8e8SKurt Hackel {
27926714d8e8SKurt Hackel int ret;
27936714d8e8SKurt Hackel spin_lock(&dlm->ast_lock);
27946714d8e8SKurt Hackel spin_lock(&lock->spinlock);
27956714d8e8SKurt Hackel ret = (list_empty(&lock->bast_list) && !lock->bast_pending);
27966714d8e8SKurt Hackel spin_unlock(&lock->spinlock);
27976714d8e8SKurt Hackel spin_unlock(&dlm->ast_lock);
27986714d8e8SKurt Hackel return ret;
27996714d8e8SKurt Hackel }
28006714d8e8SKurt Hackel
dlm_migration_can_proceed(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 mig_target)28016714d8e8SKurt Hackel static int dlm_migration_can_proceed(struct dlm_ctxt *dlm,
28026714d8e8SKurt Hackel struct dlm_lock_resource *res,
28036714d8e8SKurt Hackel u8 mig_target)
28046714d8e8SKurt Hackel {
28056714d8e8SKurt Hackel int can_proceed;
28066714d8e8SKurt Hackel spin_lock(&res->spinlock);
28076714d8e8SKurt Hackel can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING);
28086714d8e8SKurt Hackel spin_unlock(&res->spinlock);
28096714d8e8SKurt Hackel
28106714d8e8SKurt Hackel /* target has died, so make the caller break out of the
28116714d8e8SKurt Hackel * wait_event, but caller must recheck the domain_map */
28126714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
28136714d8e8SKurt Hackel if (!test_bit(mig_target, dlm->domain_map))
28146714d8e8SKurt Hackel can_proceed = 1;
28156714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
28166714d8e8SKurt Hackel return can_proceed;
28176714d8e8SKurt Hackel }
28186714d8e8SKurt Hackel
dlm_lockres_is_dirty(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)2819faf0ec9fSAdrian Bunk static int dlm_lockres_is_dirty(struct dlm_ctxt *dlm,
2820faf0ec9fSAdrian Bunk struct dlm_lock_resource *res)
28216714d8e8SKurt Hackel {
28226714d8e8SKurt Hackel int ret;
28236714d8e8SKurt Hackel spin_lock(&res->spinlock);
28246714d8e8SKurt Hackel ret = !!(res->state & DLM_LOCK_RES_DIRTY);
28256714d8e8SKurt Hackel spin_unlock(&res->spinlock);
28266714d8e8SKurt Hackel return ret;
28276714d8e8SKurt Hackel }
28286714d8e8SKurt Hackel
28296714d8e8SKurt Hackel
dlm_mark_lockres_migrating(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 target)28306714d8e8SKurt Hackel static int dlm_mark_lockres_migrating(struct dlm_ctxt *dlm,
28316714d8e8SKurt Hackel struct dlm_lock_resource *res,
28326714d8e8SKurt Hackel u8 target)
28336714d8e8SKurt Hackel {
28346714d8e8SKurt Hackel int ret = 0;
28356714d8e8SKurt Hackel
28366714d8e8SKurt Hackel mlog(0, "dlm_mark_lockres_migrating: %.*s, from %u to %u\n",
28376714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num,
28386714d8e8SKurt Hackel target);
28396714d8e8SKurt Hackel /* need to set MIGRATING flag on lockres. this is done by
28406714d8e8SKurt Hackel * ensuring that all asts have been flushed for this lockres. */
28416714d8e8SKurt Hackel spin_lock(&res->spinlock);
28426714d8e8SKurt Hackel BUG_ON(res->migration_pending);
28436714d8e8SKurt Hackel res->migration_pending = 1;
28446714d8e8SKurt Hackel /* strategy is to reserve an extra ast then release
28456714d8e8SKurt Hackel * it below, letting the release do all of the work */
28466714d8e8SKurt Hackel __dlm_lockres_reserve_ast(res);
28476714d8e8SKurt Hackel spin_unlock(&res->spinlock);
28486714d8e8SKurt Hackel
2849ddc09c8dSKurt Hackel /* now flush all the pending asts */
28506714d8e8SKurt Hackel dlm_kick_thread(dlm, res);
2851ddc09c8dSKurt Hackel /* before waiting on DIRTY, block processes which may
2852ddc09c8dSKurt Hackel * try to dirty the lockres before MIGRATING is set */
2853ddc09c8dSKurt Hackel spin_lock(&res->spinlock);
2854ddc09c8dSKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_BLOCK_DIRTY);
2855ddc09c8dSKurt Hackel res->state |= DLM_LOCK_RES_BLOCK_DIRTY;
2856ddc09c8dSKurt Hackel spin_unlock(&res->spinlock);
2857ddc09c8dSKurt Hackel /* now wait on any pending asts and the DIRTY state */
28586714d8e8SKurt Hackel wait_event(dlm->ast_wq, !dlm_lockres_is_dirty(dlm, res));
28596714d8e8SKurt Hackel dlm_lockres_release_ast(dlm, res);
28606714d8e8SKurt Hackel
28616714d8e8SKurt Hackel mlog(0, "about to wait on migration_wq, dirty=%s\n",
28626714d8e8SKurt Hackel res->state & DLM_LOCK_RES_DIRTY ? "yes" : "no");
28636714d8e8SKurt Hackel /* if the extra ref we just put was the final one, this
28646714d8e8SKurt Hackel * will pass thru immediately. otherwise, we need to wait
28656714d8e8SKurt Hackel * for the last ast to finish. */
28666714d8e8SKurt Hackel again:
28676714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(dlm->migration_wq,
28686714d8e8SKurt Hackel dlm_migration_can_proceed(dlm, res, target),
28696714d8e8SKurt Hackel msecs_to_jiffies(1000));
28706714d8e8SKurt Hackel if (ret < 0) {
28716714d8e8SKurt Hackel mlog(0, "woken again: migrating? %s, dead? %s\n",
28726714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no",
28736714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes");
28746714d8e8SKurt Hackel } else {
28756714d8e8SKurt Hackel mlog(0, "all is well: migrating? %s, dead? %s\n",
28766714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no",
28776714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes");
28786714d8e8SKurt Hackel }
28796714d8e8SKurt Hackel if (!dlm_migration_can_proceed(dlm, res, target)) {
28806714d8e8SKurt Hackel mlog(0, "trying again...\n");
28816714d8e8SKurt Hackel goto again;
28826714d8e8SKurt Hackel }
28836714d8e8SKurt Hackel
2884a39953ddSWengang Wang ret = 0;
28856714d8e8SKurt Hackel /* did the target go down or die? */
28866714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
28876714d8e8SKurt Hackel if (!test_bit(target, dlm->domain_map)) {
28886714d8e8SKurt Hackel mlog(ML_ERROR, "aha. migration target %u just went down\n",
28896714d8e8SKurt Hackel target);
28906714d8e8SKurt Hackel ret = -EHOSTDOWN;
28916714d8e8SKurt Hackel }
28926714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
28936714d8e8SKurt Hackel
28946714d8e8SKurt Hackel /*
2895a39953ddSWengang Wang * if target is down, we need to clear DLM_LOCK_RES_BLOCK_DIRTY for
2896a39953ddSWengang Wang * another try; otherwise, we are sure the MIGRATING state is there,
28974d39f0acSMasahiro Yamada * drop the unneeded state which blocked threads trying to DIRTY
2898a39953ddSWengang Wang */
2899a39953ddSWengang Wang spin_lock(&res->spinlock);
2900a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_BLOCK_DIRTY));
2901a39953ddSWengang Wang res->state &= ~DLM_LOCK_RES_BLOCK_DIRTY;
2902a39953ddSWengang Wang if (!ret)
2903a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_MIGRATING));
2904cc28d6d8Sxuejiufei else
2905cc28d6d8Sxuejiufei res->migration_pending = 0;
2906a39953ddSWengang Wang spin_unlock(&res->spinlock);
2907a39953ddSWengang Wang
2908a39953ddSWengang Wang /*
29096714d8e8SKurt Hackel * at this point:
29106714d8e8SKurt Hackel *
2911a39953ddSWengang Wang * o the DLM_LOCK_RES_MIGRATING flag is set if target not down
29126714d8e8SKurt Hackel * o there are no pending asts on this lockres
29136714d8e8SKurt Hackel * o all processes trying to reserve an ast on this
29146714d8e8SKurt Hackel * lockres must wait for the MIGRATING flag to clear
29156714d8e8SKurt Hackel */
29166714d8e8SKurt Hackel return ret;
29176714d8e8SKurt Hackel }
29186714d8e8SKurt Hackel
29196714d8e8SKurt Hackel /* last step in the migration process.
29206714d8e8SKurt Hackel * original master calls this to free all of the dlm_lock
29216714d8e8SKurt Hackel * structures that used to be for other nodes. */
dlm_remove_nonlocal_locks(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)29226714d8e8SKurt Hackel static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm,
29236714d8e8SKurt Hackel struct dlm_lock_resource *res)
29246714d8e8SKurt Hackel {
29256714d8e8SKurt Hackel struct list_head *queue = &res->granted;
2926ba2bf218SKurt Hackel int i, bit;
2927800deef3SChristoph Hellwig struct dlm_lock *lock, *next;
29286714d8e8SKurt Hackel
29296714d8e8SKurt Hackel assert_spin_locked(&res->spinlock);
29306714d8e8SKurt Hackel
29316714d8e8SKurt Hackel BUG_ON(res->owner == dlm->node_num);
29326714d8e8SKurt Hackel
29336714d8e8SKurt Hackel for (i=0; i<3; i++) {
2934800deef3SChristoph Hellwig list_for_each_entry_safe(lock, next, queue, list) {
29356714d8e8SKurt Hackel if (lock->ml.node != dlm->node_num) {
29366714d8e8SKurt Hackel mlog(0, "putting lock for node %u\n",
29376714d8e8SKurt Hackel lock->ml.node);
29386714d8e8SKurt Hackel /* be extra careful */
29396714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->ast_list));
29406714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->bast_list));
29416714d8e8SKurt Hackel BUG_ON(lock->ast_pending);
29426714d8e8SKurt Hackel BUG_ON(lock->bast_pending);
29438d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res,
29448d400b81SSunil Mushran lock->ml.node);
29456714d8e8SKurt Hackel list_del_init(&lock->list);
29466714d8e8SKurt Hackel dlm_lock_put(lock);
29472c5c54acSSunil Mushran /* In a normal unlock, we would have added a
29482c5c54acSSunil Mushran * DLM_UNLOCK_FREE_LOCK action. Force it. */
29492c5c54acSSunil Mushran dlm_lock_put(lock);
29506714d8e8SKurt Hackel }
29516714d8e8SKurt Hackel }
29526714d8e8SKurt Hackel queue++;
29536714d8e8SKurt Hackel }
2954ba2bf218SKurt Hackel bit = 0;
2955ba2bf218SKurt Hackel while (1) {
2956ba2bf218SKurt Hackel bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
2957ba2bf218SKurt Hackel if (bit >= O2NM_MAX_NODES)
2958ba2bf218SKurt Hackel break;
2959ba2bf218SKurt Hackel /* do not clear the local node reference, if there is a
2960ba2bf218SKurt Hackel * process holding this, let it drop the ref itself */
2961ba2bf218SKurt Hackel if (bit != dlm->node_num) {
2962ba2bf218SKurt Hackel mlog(0, "%s:%.*s: node %u had a ref to this "
2963ba2bf218SKurt Hackel "migrating lockres, clearing\n", dlm->name,
2964ba2bf218SKurt Hackel res->lockname.len, res->lockname.name, bit);
29658d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, bit);
2966ba2bf218SKurt Hackel }
2967ba2bf218SKurt Hackel bit++;
2968ba2bf218SKurt Hackel }
29696714d8e8SKurt Hackel }
29706714d8e8SKurt Hackel
297166effd3cSSunil Mushran /*
297266effd3cSSunil Mushran * Pick a node to migrate the lock resource to. This function selects a
297366effd3cSSunil Mushran * potential target based first on the locks and then on refmap. It skips
297466effd3cSSunil Mushran * nodes that are in the process of exiting the domain.
297566effd3cSSunil Mushran */
dlm_pick_migration_target(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)29766714d8e8SKurt Hackel static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm,
29776714d8e8SKurt Hackel struct dlm_lock_resource *res)
29786714d8e8SKurt Hackel {
297966effd3cSSunil Mushran enum dlm_lockres_list idx;
2980ca49b6d8SColin Ian King struct list_head *queue;
29816714d8e8SKurt Hackel struct dlm_lock *lock;
298266effd3cSSunil Mushran int noderef;
298366effd3cSSunil Mushran u8 nodenum = O2NM_MAX_NODES;
29846714d8e8SKurt Hackel
29856714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
298666effd3cSSunil Mushran assert_spin_locked(&res->spinlock);
29876714d8e8SKurt Hackel
298866effd3cSSunil Mushran /* Go through all the locks */
298966effd3cSSunil Mushran for (idx = DLM_GRANTED_LIST; idx <= DLM_BLOCKED_LIST; idx++) {
299066effd3cSSunil Mushran queue = dlm_list_idx_to_ptr(res, idx);
2991800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) {
299266effd3cSSunil Mushran if (lock->ml.node == dlm->node_num)
299366effd3cSSunil Mushran continue;
299466effd3cSSunil Mushran if (test_bit(lock->ml.node, dlm->exit_domain_map))
299566effd3cSSunil Mushran continue;
299666effd3cSSunil Mushran nodenum = lock->ml.node;
299766effd3cSSunil Mushran goto bail;
29986714d8e8SKurt Hackel }
29996714d8e8SKurt Hackel }
3000388c4bcbSSunil Mushran
300166effd3cSSunil Mushran /* Go thru the refmap */
300266effd3cSSunil Mushran noderef = -1;
30036714d8e8SKurt Hackel while (1) {
300466effd3cSSunil Mushran noderef = find_next_bit(res->refmap, O2NM_MAX_NODES,
300566effd3cSSunil Mushran noderef + 1);
300666effd3cSSunil Mushran if (noderef >= O2NM_MAX_NODES)
30076714d8e8SKurt Hackel break;
300866effd3cSSunil Mushran if (noderef == dlm->node_num)
300966effd3cSSunil Mushran continue;
301066effd3cSSunil Mushran if (test_bit(noderef, dlm->exit_domain_map))
301166effd3cSSunil Mushran continue;
301266effd3cSSunil Mushran nodenum = noderef;
301366effd3cSSunil Mushran goto bail;
301466effd3cSSunil Mushran }
301566effd3cSSunil Mushran
301666effd3cSSunil Mushran bail:
30176714d8e8SKurt Hackel return nodenum;
30186714d8e8SKurt Hackel }
30196714d8e8SKurt Hackel
30206714d8e8SKurt Hackel /* this is called by the new master once all lockres
30216714d8e8SKurt Hackel * data has been received */
dlm_do_migrate_request(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 master,u8 new_master,struct dlm_node_iter * iter)30226714d8e8SKurt Hackel static int dlm_do_migrate_request(struct dlm_ctxt *dlm,
30236714d8e8SKurt Hackel struct dlm_lock_resource *res,
30246714d8e8SKurt Hackel u8 master, u8 new_master,
30256714d8e8SKurt Hackel struct dlm_node_iter *iter)
30266714d8e8SKurt Hackel {
30276714d8e8SKurt Hackel struct dlm_migrate_request migrate;
30282b832564SSunil Mushran int ret, skip, status = 0;
30296714d8e8SKurt Hackel int nodenum;
30306714d8e8SKurt Hackel
30316714d8e8SKurt Hackel memset(&migrate, 0, sizeof(migrate));
30326714d8e8SKurt Hackel migrate.namelen = res->lockname.len;
30336714d8e8SKurt Hackel memcpy(migrate.name, res->lockname.name, migrate.namelen);
30346714d8e8SKurt Hackel migrate.new_master = new_master;
30356714d8e8SKurt Hackel migrate.master = master;
30366714d8e8SKurt Hackel
30376714d8e8SKurt Hackel ret = 0;
30386714d8e8SKurt Hackel
30396714d8e8SKurt Hackel /* send message to all nodes, except the master and myself */
30406714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(iter)) >= 0) {
30416714d8e8SKurt Hackel if (nodenum == master ||
30426714d8e8SKurt Hackel nodenum == new_master)
30436714d8e8SKurt Hackel continue;
30446714d8e8SKurt Hackel
30452b832564SSunil Mushran /* We could race exit domain. If exited, skip. */
30462b832564SSunil Mushran spin_lock(&dlm->spinlock);
30472b832564SSunil Mushran skip = (!test_bit(nodenum, dlm->domain_map));
30482b832564SSunil Mushran spin_unlock(&dlm->spinlock);
30492b832564SSunil Mushran if (skip) {
30502b832564SSunil Mushran clear_bit(nodenum, iter->node_map);
30512b832564SSunil Mushran continue;
30522b832564SSunil Mushran }
30532b832564SSunil Mushran
30546714d8e8SKurt Hackel ret = o2net_send_message(DLM_MIGRATE_REQUEST_MSG, dlm->key,
30556714d8e8SKurt Hackel &migrate, sizeof(migrate), nodenum,
30566714d8e8SKurt Hackel &status);
30572b832564SSunil Mushran if (ret < 0) {
30588decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, Error %d send "
30598decab3cSSunil Mushran "MIGRATE_REQUEST to node %u\n", dlm->name,
30608decab3cSSunil Mushran migrate.namelen, migrate.name, ret, nodenum);
30612b832564SSunil Mushran if (!dlm_is_host_down(ret)) {
30622b832564SSunil Mushran mlog(ML_ERROR, "unhandled error=%d!\n", ret);
30632b832564SSunil Mushran BUG();
30642b832564SSunil Mushran }
30652b832564SSunil Mushran clear_bit(nodenum, iter->node_map);
30662b832564SSunil Mushran ret = 0;
30672b832564SSunil Mushran } else if (status < 0) {
30686714d8e8SKurt Hackel mlog(0, "migrate request (node %u) returned %d!\n",
30696714d8e8SKurt Hackel nodenum, status);
30706714d8e8SKurt Hackel ret = status;
3071ba2bf218SKurt Hackel } else if (status == DLM_MIGRATE_RESPONSE_MASTERY_REF) {
3072ba2bf218SKurt Hackel /* during the migration request we short-circuited
3073ba2bf218SKurt Hackel * the mastery of the lockres. make sure we have
3074ba2bf218SKurt Hackel * a mastery ref for nodenum */
3075ba2bf218SKurt Hackel mlog(0, "%s:%.*s: need ref for node %u\n",
3076ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name,
3077ba2bf218SKurt Hackel nodenum);
3078ba2bf218SKurt Hackel spin_lock(&res->spinlock);
30798d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, nodenum);
3080ba2bf218SKurt Hackel spin_unlock(&res->spinlock);
30816714d8e8SKurt Hackel }
30826714d8e8SKurt Hackel }
30836714d8e8SKurt Hackel
30846714d8e8SKurt Hackel if (ret < 0)
30856714d8e8SKurt Hackel mlog_errno(ret);
30866714d8e8SKurt Hackel
30876714d8e8SKurt Hackel mlog(0, "returning ret=%d\n", ret);
30886714d8e8SKurt Hackel return ret;
30896714d8e8SKurt Hackel }
30906714d8e8SKurt Hackel
30916714d8e8SKurt Hackel
30926714d8e8SKurt Hackel /* if there is an existing mle for this lockres, we now know who the master is.
30936714d8e8SKurt Hackel * (the one who sent us *this* message) we can clear it up right away.
30946714d8e8SKurt Hackel * since the process that put the mle on the list still has a reference to it,
30956714d8e8SKurt Hackel * we can unhash it now, set the master and wake the process. as a result,
30966714d8e8SKurt Hackel * we will have no mle in the list to start with. now we can add an mle for
30976714d8e8SKurt Hackel * the migration and this should be the only one found for those scanning the
30986714d8e8SKurt Hackel * list. */
dlm_migrate_request_handler(struct o2net_msg * msg,u32 len,void * data,void ** ret_data)3099d74c9803SKurt Hackel int dlm_migrate_request_handler(struct o2net_msg *msg, u32 len, void *data,
3100d74c9803SKurt Hackel void **ret_data)
31016714d8e8SKurt Hackel {
31026714d8e8SKurt Hackel struct dlm_ctxt *dlm = data;
31036714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL;
31046714d8e8SKurt Hackel struct dlm_migrate_request *migrate = (struct dlm_migrate_request *) msg->buf;
31056714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *oldmle = NULL;
31066714d8e8SKurt Hackel const char *name;
3107a3d33291SMark Fasheh unsigned int namelen, hash;
31086714d8e8SKurt Hackel int ret = 0;
31096714d8e8SKurt Hackel
31106714d8e8SKurt Hackel if (!dlm_grab(dlm))
3111c372f219SXue jiufei return 0;
31126714d8e8SKurt Hackel
31136714d8e8SKurt Hackel name = migrate->name;
31146714d8e8SKurt Hackel namelen = migrate->namelen;
3115a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen);
31166714d8e8SKurt Hackel
31176714d8e8SKurt Hackel /* preallocate.. if this fails, abort */
31183914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS);
31196714d8e8SKurt Hackel
31206714d8e8SKurt Hackel if (!mle) {
31216714d8e8SKurt Hackel ret = -ENOMEM;
31226714d8e8SKurt Hackel goto leave;
31236714d8e8SKurt Hackel }
31246714d8e8SKurt Hackel
31256714d8e8SKurt Hackel /* check for pre-existing lock */
31266714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
3127a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash);
31286714d8e8SKurt Hackel if (res) {
31296714d8e8SKurt Hackel spin_lock(&res->spinlock);
31306714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) {
31316714d8e8SKurt Hackel /* if all is working ok, this can only mean that we got
31326714d8e8SKurt Hackel * a migrate request from a node that we now see as
31336714d8e8SKurt Hackel * dead. what can we do here? drop it to the floor? */
31346714d8e8SKurt Hackel spin_unlock(&res->spinlock);
31356714d8e8SKurt Hackel mlog(ML_ERROR, "Got a migrate request, but the "
31366714d8e8SKurt Hackel "lockres is marked as recovering!");
31376714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle);
31386714d8e8SKurt Hackel ret = -EINVAL; /* need a better solution */
31396714d8e8SKurt Hackel goto unlock;
31406714d8e8SKurt Hackel }
31416714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING;
31426714d8e8SKurt Hackel spin_unlock(&res->spinlock);
31436714d8e8SKurt Hackel }
31446714d8e8SKurt Hackel
31456d98c3ccSWengang Wang spin_lock(&dlm->master_lock);
31466714d8e8SKurt Hackel /* ignore status. only nonzero status would BUG. */
31476714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle,
31486714d8e8SKurt Hackel name, namelen,
31496714d8e8SKurt Hackel migrate->new_master,
31506714d8e8SKurt Hackel migrate->master);
31516714d8e8SKurt Hackel
31520cc482eeSGuozhonghua if (ret < 0)
31530cc482eeSGuozhonghua kmem_cache_free(dlm_mle_cache, mle);
31540cc482eeSGuozhonghua
31556714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
31566d98c3ccSWengang Wang unlock:
31576714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
31586714d8e8SKurt Hackel
31596714d8e8SKurt Hackel if (oldmle) {
31606714d8e8SKurt Hackel /* master is known, detach if not already detached */
31616714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle);
31626714d8e8SKurt Hackel dlm_put_mle(oldmle);
31636714d8e8SKurt Hackel }
31646714d8e8SKurt Hackel
31656714d8e8SKurt Hackel if (res)
31666714d8e8SKurt Hackel dlm_lockres_put(res);
31676714d8e8SKurt Hackel leave:
31686714d8e8SKurt Hackel dlm_put(dlm);
31696714d8e8SKurt Hackel return ret;
31706714d8e8SKurt Hackel }
31716714d8e8SKurt Hackel
31726714d8e8SKurt Hackel /* must be holding dlm->spinlock and dlm->master_lock
31736714d8e8SKurt Hackel * when adding a migration mle, we can clear any other mles
31746714d8e8SKurt Hackel * in the master list because we know with certainty that
31756714d8e8SKurt Hackel * the master is "master". so we remove any old mle from
31766714d8e8SKurt Hackel * the list after setting it's master field, and then add
31776714d8e8SKurt Hackel * the new migration mle. this way we can hold with the rule
31786714d8e8SKurt Hackel * of having only one mle for a given lock name at all times. */
dlm_add_migration_mle(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,struct dlm_master_list_entry * mle,struct dlm_master_list_entry ** oldmle,const char * name,unsigned int namelen,u8 new_master,u8 master)31796714d8e8SKurt Hackel static int dlm_add_migration_mle(struct dlm_ctxt *dlm,
31806714d8e8SKurt Hackel struct dlm_lock_resource *res,
31816714d8e8SKurt Hackel struct dlm_master_list_entry *mle,
31826714d8e8SKurt Hackel struct dlm_master_list_entry **oldmle,
31836714d8e8SKurt Hackel const char *name, unsigned int namelen,
31846714d8e8SKurt Hackel u8 new_master, u8 master)
31856714d8e8SKurt Hackel {
31866714d8e8SKurt Hackel int found;
31876714d8e8SKurt Hackel int ret = 0;
31886714d8e8SKurt Hackel
31896714d8e8SKurt Hackel *oldmle = NULL;
31906714d8e8SKurt Hackel
31916714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
31926714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock);
31936714d8e8SKurt Hackel
31946714d8e8SKurt Hackel /* caller is responsible for any ref taken here on oldmle */
31956714d8e8SKurt Hackel found = dlm_find_mle(dlm, oldmle, (char *)name, namelen);
31966714d8e8SKurt Hackel if (found) {
31976714d8e8SKurt Hackel struct dlm_master_list_entry *tmp = *oldmle;
31986714d8e8SKurt Hackel spin_lock(&tmp->spinlock);
31996714d8e8SKurt Hackel if (tmp->type == DLM_MLE_MIGRATION) {
32006714d8e8SKurt Hackel if (master == dlm->node_num) {
32016714d8e8SKurt Hackel /* ah another process raced me to it */
32026714d8e8SKurt Hackel mlog(0, "tried to migrate %.*s, but some "
32036714d8e8SKurt Hackel "process beat me to it\n",
32046714d8e8SKurt Hackel namelen, name);
320532e49326Sxuejiufei spin_unlock(&tmp->spinlock);
320632e49326Sxuejiufei return -EEXIST;
32076714d8e8SKurt Hackel } else {
32086714d8e8SKurt Hackel /* bad. 2 NODES are trying to migrate! */
32096714d8e8SKurt Hackel mlog(ML_ERROR, "migration error mle: "
32106714d8e8SKurt Hackel "master=%u new_master=%u // request: "
32116714d8e8SKurt Hackel "master=%u new_master=%u // "
32126714d8e8SKurt Hackel "lockres=%.*s\n",
32136714d8e8SKurt Hackel tmp->master, tmp->new_master,
32146714d8e8SKurt Hackel master, new_master,
32156714d8e8SKurt Hackel namelen, name);
32166714d8e8SKurt Hackel BUG();
32176714d8e8SKurt Hackel }
32186714d8e8SKurt Hackel } else {
32196714d8e8SKurt Hackel /* this is essentially what assert_master does */
32206714d8e8SKurt Hackel tmp->master = master;
32216714d8e8SKurt Hackel atomic_set(&tmp->woken, 1);
32226714d8e8SKurt Hackel wake_up(&tmp->wq);
32231c084577SSunil Mushran /* remove it so that only one mle will be found */
32241c084577SSunil Mushran __dlm_unlink_mle(dlm, tmp);
3225ba2bf218SKurt Hackel __dlm_mle_detach_hb_events(dlm, tmp);
3226b9aaac5aSjiangyiwen if (tmp->type == DLM_MLE_MASTER) {
3227ba2bf218SKurt Hackel ret = DLM_MIGRATE_RESPONSE_MASTERY_REF;
3228ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master=%u, newmaster=%u, "
3229b9aaac5aSjiangyiwen "telling master to get ref "
3230b9aaac5aSjiangyiwen "for cleared out mle during "
3231b9aaac5aSjiangyiwen "migration\n", dlm->name,
3232b9aaac5aSjiangyiwen namelen, name, master,
3233b9aaac5aSjiangyiwen new_master);
3234b9aaac5aSjiangyiwen }
32356714d8e8SKurt Hackel }
32366714d8e8SKurt Hackel spin_unlock(&tmp->spinlock);
32376714d8e8SKurt Hackel }
32386714d8e8SKurt Hackel
32396714d8e8SKurt Hackel /* now add a migration mle to the tail of the list */
32406714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MIGRATION, dlm, res, name, namelen);
32416714d8e8SKurt Hackel mle->new_master = new_master;
3242ba2bf218SKurt Hackel /* the new master will be sending an assert master for this.
3243ba2bf218SKurt Hackel * at that point we will get the refmap reference */
32446714d8e8SKurt Hackel mle->master = master;
32456714d8e8SKurt Hackel /* do this for consistency with other mle types */
32466714d8e8SKurt Hackel set_bit(new_master, mle->maybe_map);
32471c084577SSunil Mushran __dlm_insert_mle(dlm, mle);
32486714d8e8SKurt Hackel
32496714d8e8SKurt Hackel return ret;
32506714d8e8SKurt Hackel }
32516714d8e8SKurt Hackel
3252c2cd4a44SSunil Mushran /*
3253c2cd4a44SSunil Mushran * Sets the owner of the lockres, associated to the mle, to UNKNOWN
3254c2cd4a44SSunil Mushran */
dlm_reset_mleres_owner(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)3255c2cd4a44SSunil Mushran static struct dlm_lock_resource *dlm_reset_mleres_owner(struct dlm_ctxt *dlm,
3256c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle)
3257c2cd4a44SSunil Mushran {
3258c2cd4a44SSunil Mushran struct dlm_lock_resource *res;
3259c2cd4a44SSunil Mushran
3260c2cd4a44SSunil Mushran /* Find the lockres associated to the mle and set its owner to UNK */
32617141514bSSunil Mushran res = __dlm_lookup_lockres(dlm, mle->mname, mle->mnamelen,
32627141514bSSunil Mushran mle->mnamehash);
3263c2cd4a44SSunil Mushran if (res) {
3264c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock);
3265c2cd4a44SSunil Mushran
3266c2cd4a44SSunil Mushran /* move lockres onto recovery list */
3267c2cd4a44SSunil Mushran spin_lock(&res->spinlock);
3268c2cd4a44SSunil Mushran dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN);
3269c2cd4a44SSunil Mushran dlm_move_lockres_to_recovery_list(dlm, res);
3270c2cd4a44SSunil Mushran spin_unlock(&res->spinlock);
3271c2cd4a44SSunil Mushran dlm_lockres_put(res);
3272c2cd4a44SSunil Mushran
3273c2cd4a44SSunil Mushran /* about to get rid of mle, detach from heartbeat */
3274c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle);
3275c2cd4a44SSunil Mushran
3276c2cd4a44SSunil Mushran /* dump the mle */
3277c2cd4a44SSunil Mushran spin_lock(&dlm->master_lock);
3278c2cd4a44SSunil Mushran __dlm_put_mle(mle);
3279c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock);
3280c2cd4a44SSunil Mushran }
3281c2cd4a44SSunil Mushran
3282c2cd4a44SSunil Mushran return res;
3283c2cd4a44SSunil Mushran }
3284c2cd4a44SSunil Mushran
dlm_clean_migration_mle(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle)3285c2cd4a44SSunil Mushran static void dlm_clean_migration_mle(struct dlm_ctxt *dlm,
3286c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle)
3287c2cd4a44SSunil Mushran {
3288c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle);
3289c2cd4a44SSunil Mushran
3290c2cd4a44SSunil Mushran spin_lock(&mle->spinlock);
3291c2cd4a44SSunil Mushran __dlm_unlink_mle(dlm, mle);
3292c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1);
3293c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock);
3294c2cd4a44SSunil Mushran
3295c2cd4a44SSunil Mushran wake_up(&mle->wq);
3296c2cd4a44SSunil Mushran }
3297c2cd4a44SSunil Mushran
dlm_clean_block_mle(struct dlm_ctxt * dlm,struct dlm_master_list_entry * mle,u8 dead_node)3298c2cd4a44SSunil Mushran static void dlm_clean_block_mle(struct dlm_ctxt *dlm,
3299c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle, u8 dead_node)
3300c2cd4a44SSunil Mushran {
3301c2cd4a44SSunil Mushran int bit;
3302c2cd4a44SSunil Mushran
3303c2cd4a44SSunil Mushran BUG_ON(mle->type != DLM_MLE_BLOCK);
3304c2cd4a44SSunil Mushran
3305c2cd4a44SSunil Mushran spin_lock(&mle->spinlock);
3306b5c7e7ecSYury Norov bit = find_first_bit(mle->maybe_map, O2NM_MAX_NODES);
3307c2cd4a44SSunil Mushran if (bit != dead_node) {
3308c2cd4a44SSunil Mushran mlog(0, "mle found, but dead node %u would not have been "
3309c2cd4a44SSunil Mushran "master\n", dead_node);
3310c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock);
3311c2cd4a44SSunil Mushran } else {
3312c2cd4a44SSunil Mushran /* Must drop the refcount by one since the assert_master will
3313c2cd4a44SSunil Mushran * never arrive. This may result in the mle being unlinked and
3314c2cd4a44SSunil Mushran * freed, but there may still be a process waiting in the
3315c2cd4a44SSunil Mushran * dlmlock path which is fine. */
3316c2cd4a44SSunil Mushran mlog(0, "node %u was expected master\n", dead_node);
3317c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1);
3318c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock);
3319c2cd4a44SSunil Mushran wake_up(&mle->wq);
3320c2cd4a44SSunil Mushran
3321c2cd4a44SSunil Mushran /* Do not need events any longer, so detach from heartbeat */
3322c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle);
3323c2cd4a44SSunil Mushran __dlm_put_mle(mle);
3324c2cd4a44SSunil Mushran }
3325c2cd4a44SSunil Mushran }
33266714d8e8SKurt Hackel
dlm_clean_master_list(struct dlm_ctxt * dlm,u8 dead_node)33276714d8e8SKurt Hackel void dlm_clean_master_list(struct dlm_ctxt *dlm, u8 dead_node)
33286714d8e8SKurt Hackel {
33292ed6c750SSunil Mushran struct dlm_master_list_entry *mle;
33306714d8e8SKurt Hackel struct dlm_lock_resource *res;
33312ed6c750SSunil Mushran struct hlist_head *bucket;
3332df53cd3bSDong Fang struct hlist_node *tmp;
33332ed6c750SSunil Mushran unsigned int i;
33346714d8e8SKurt Hackel
3335ef6b689bSTao Ma mlog(0, "dlm=%s, dead node=%u\n", dlm->name, dead_node);
33366714d8e8SKurt Hackel top:
33376714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock);
33386714d8e8SKurt Hackel
33396714d8e8SKurt Hackel /* clean the master list */
33406714d8e8SKurt Hackel spin_lock(&dlm->master_lock);
33412ed6c750SSunil Mushran for (i = 0; i < DLM_HASH_BUCKETS; i++) {
33422ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, i);
3343df53cd3bSDong Fang hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) {
33446714d8e8SKurt Hackel BUG_ON(mle->type != DLM_MLE_BLOCK &&
33456714d8e8SKurt Hackel mle->type != DLM_MLE_MASTER &&
33466714d8e8SKurt Hackel mle->type != DLM_MLE_MIGRATION);
33476714d8e8SKurt Hackel
334867ae1f06SSunil Mushran /* MASTER mles are initiated locally. The waiting
334967ae1f06SSunil Mushran * process will notice the node map change shortly.
335067ae1f06SSunil Mushran * Let that happen as normal. */
33516714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER)
33526714d8e8SKurt Hackel continue;
33536714d8e8SKurt Hackel
335467ae1f06SSunil Mushran /* BLOCK mles are initiated by other nodes. Need to
335567ae1f06SSunil Mushran * clean up if the dead node would have been the
335667ae1f06SSunil Mushran * master. */
33576714d8e8SKurt Hackel if (mle->type == DLM_MLE_BLOCK) {
3358c2cd4a44SSunil Mushran dlm_clean_block_mle(dlm, mle, dead_node);
33596714d8e8SKurt Hackel continue;
33606714d8e8SKurt Hackel }
33616714d8e8SKurt Hackel
336267ae1f06SSunil Mushran /* Everything else is a MIGRATION mle */
33636714d8e8SKurt Hackel
336467ae1f06SSunil Mushran /* The rule for MIGRATION mles is that the master
336567ae1f06SSunil Mushran * becomes UNKNOWN if *either* the original or the new
336667ae1f06SSunil Mushran * master dies. All UNKNOWN lockres' are sent to
336767ae1f06SSunil Mushran * whichever node becomes the recovery master. The new
336867ae1f06SSunil Mushran * master is responsible for determining if there is
336967ae1f06SSunil Mushran * still a master for this lockres, or if he needs to
337067ae1f06SSunil Mushran * take over mastery. Either way, this node should
337167ae1f06SSunil Mushran * expect another message to resolve this. */
337267ae1f06SSunil Mushran
33736714d8e8SKurt Hackel if (mle->master != dead_node &&
33746714d8e8SKurt Hackel mle->new_master != dead_node)
33756714d8e8SKurt Hackel continue;
33766714d8e8SKurt Hackel
3377bef5502dSxuejiufei if (mle->new_master == dead_node && mle->inuse) {
3378bef5502dSxuejiufei mlog(ML_NOTICE, "%s: target %u died during "
3379bef5502dSxuejiufei "migration from %u, the MLE is "
3380bef5502dSxuejiufei "still keep used, ignore it!\n",
3381bef5502dSxuejiufei dlm->name, dead_node,
3382bef5502dSxuejiufei mle->master);
3383bef5502dSxuejiufei continue;
3384bef5502dSxuejiufei }
3385bef5502dSxuejiufei
338667ae1f06SSunil Mushran /* If we have reached this point, this mle needs to be
338767ae1f06SSunil Mushran * removed from the list and freed. */
3388c2cd4a44SSunil Mushran dlm_clean_migration_mle(dlm, mle);
33896714d8e8SKurt Hackel
3390aa852354SKurt Hackel mlog(0, "%s: node %u died during migration from "
339167ae1f06SSunil Mushran "%u to %u!\n", dlm->name, dead_node, mle->master,
339267ae1f06SSunil Mushran mle->new_master);
3393c2cd4a44SSunil Mushran
3394c2cd4a44SSunil Mushran /* If we find a lockres associated with the mle, we've
3395c2cd4a44SSunil Mushran * hit this rare case that messes up our lock ordering.
3396c2cd4a44SSunil Mushran * If so, we need to drop the master lock so that we can
3397c2cd4a44SSunil Mushran * take the lockres lock, meaning that we will have to
33986714d8e8SKurt Hackel * restart from the head of list. */
3399c2cd4a44SSunil Mushran res = dlm_reset_mleres_owner(dlm, mle);
3400c2cd4a44SSunil Mushran if (res)
34016714d8e8SKurt Hackel /* restart */
34026714d8e8SKurt Hackel goto top;
34036714d8e8SKurt Hackel
340467ae1f06SSunil Mushran /* This may be the last reference */
34056714d8e8SKurt Hackel __dlm_put_mle(mle);
34066714d8e8SKurt Hackel }
34072ed6c750SSunil Mushran }
34086714d8e8SKurt Hackel spin_unlock(&dlm->master_lock);
34096714d8e8SKurt Hackel }
34106714d8e8SKurt Hackel
dlm_finish_migration(struct dlm_ctxt * dlm,struct dlm_lock_resource * res,u8 old_master)34116714d8e8SKurt Hackel int dlm_finish_migration(struct dlm_ctxt *dlm, struct dlm_lock_resource *res,
34126714d8e8SKurt Hackel u8 old_master)
34136714d8e8SKurt Hackel {
34146714d8e8SKurt Hackel struct dlm_node_iter iter;
34156714d8e8SKurt Hackel int ret = 0;
34166714d8e8SKurt Hackel
34176714d8e8SKurt Hackel spin_lock(&dlm->spinlock);
34186714d8e8SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter);
34196714d8e8SKurt Hackel clear_bit(old_master, iter.node_map);
34206714d8e8SKurt Hackel clear_bit(dlm->node_num, iter.node_map);
34216714d8e8SKurt Hackel spin_unlock(&dlm->spinlock);
34226714d8e8SKurt Hackel
3423ba2bf218SKurt Hackel /* ownership of the lockres is changing. account for the
3424ba2bf218SKurt Hackel * mastery reference here since old_master will briefly have
3425ba2bf218SKurt Hackel * a reference after the migration completes */
3426ba2bf218SKurt Hackel spin_lock(&res->spinlock);
34278d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, old_master);
3428ba2bf218SKurt Hackel spin_unlock(&res->spinlock);
3429ba2bf218SKurt Hackel
34306714d8e8SKurt Hackel mlog(0, "now time to do a migrate request to other nodes\n");
34316714d8e8SKurt Hackel ret = dlm_do_migrate_request(dlm, res, old_master,
34326714d8e8SKurt Hackel dlm->node_num, &iter);
34336714d8e8SKurt Hackel if (ret < 0) {
34346714d8e8SKurt Hackel mlog_errno(ret);
34356714d8e8SKurt Hackel goto leave;
34366714d8e8SKurt Hackel }
34376714d8e8SKurt Hackel
34386714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s to all except the original node\n",
34396714d8e8SKurt Hackel res->lockname.len, res->lockname.name);
34406714d8e8SKurt Hackel /* this call now finishes out the nodemap
34416714d8e8SKurt Hackel * even if one or more nodes die */
3442ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map,
34436714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION);
34446714d8e8SKurt Hackel if (ret < 0) {
34456714d8e8SKurt Hackel /* no longer need to retry. all living nodes contacted. */
34466714d8e8SKurt Hackel mlog_errno(ret);
34476714d8e8SKurt Hackel ret = 0;
34486714d8e8SKurt Hackel }
34496714d8e8SKurt Hackel
3450*b270f492SJoseph Qi bitmap_zero(iter.node_map, O2NM_MAX_NODES);
34516714d8e8SKurt Hackel set_bit(old_master, iter.node_map);
34526714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s back to %u\n",
34536714d8e8SKurt Hackel res->lockname.len, res->lockname.name, old_master);
3454ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map,
34556714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION);
34566714d8e8SKurt Hackel if (ret < 0) {
34576714d8e8SKurt Hackel mlog(0, "assert master to original master failed "
34586714d8e8SKurt Hackel "with %d.\n", ret);
34596714d8e8SKurt Hackel /* the only nonzero status here would be because of
34606714d8e8SKurt Hackel * a dead original node. we're done. */
34616714d8e8SKurt Hackel ret = 0;
34626714d8e8SKurt Hackel }
34636714d8e8SKurt Hackel
34646714d8e8SKurt Hackel /* all done, set the owner, clear the flag */
34656714d8e8SKurt Hackel spin_lock(&res->spinlock);
34666714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, dlm->node_num);
34676714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING;
34686714d8e8SKurt Hackel spin_unlock(&res->spinlock);
34696714d8e8SKurt Hackel /* re-dirty it on the new master */
34706714d8e8SKurt Hackel dlm_kick_thread(dlm, res);
34716714d8e8SKurt Hackel wake_up(&res->wq);
34726714d8e8SKurt Hackel leave:
34736714d8e8SKurt Hackel return ret;
34746714d8e8SKurt Hackel }
34756714d8e8SKurt Hackel
34766714d8e8SKurt Hackel /*
34776714d8e8SKurt Hackel * LOCKRES AST REFCOUNT
34786714d8e8SKurt Hackel * this is integral to migration
34796714d8e8SKurt Hackel */
34806714d8e8SKurt Hackel
34816714d8e8SKurt Hackel /* for future intent to call an ast, reserve one ahead of time.
34826714d8e8SKurt Hackel * this should be called only after waiting on the lockres
34836714d8e8SKurt Hackel * with dlm_wait_on_lockres, and while still holding the
34846714d8e8SKurt Hackel * spinlock after the call. */
__dlm_lockres_reserve_ast(struct dlm_lock_resource * res)34856714d8e8SKurt Hackel void __dlm_lockres_reserve_ast(struct dlm_lock_resource *res)
34866714d8e8SKurt Hackel {
34876714d8e8SKurt Hackel assert_spin_locked(&res->spinlock);
34886714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) {
34896714d8e8SKurt Hackel __dlm_print_one_lock_resource(res);
34906714d8e8SKurt Hackel }
34916714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING);
34926714d8e8SKurt Hackel
34936714d8e8SKurt Hackel atomic_inc(&res->asts_reserved);
34946714d8e8SKurt Hackel }
34956714d8e8SKurt Hackel
34966714d8e8SKurt Hackel /*
34976714d8e8SKurt Hackel * used to drop the reserved ast, either because it went unused,
34986714d8e8SKurt Hackel * or because the ast/bast was actually called.
34996714d8e8SKurt Hackel *
35006714d8e8SKurt Hackel * also, if there is a pending migration on this lockres,
35016714d8e8SKurt Hackel * and this was the last pending ast on the lockres,
35026714d8e8SKurt Hackel * atomically set the MIGRATING flag before we drop the lock.
35036714d8e8SKurt Hackel * this is how we ensure that migration can proceed with no
35046714d8e8SKurt Hackel * asts in progress. note that it is ok if the state of the
35056714d8e8SKurt Hackel * queues is such that a lock should be granted in the future
35066714d8e8SKurt Hackel * or that a bast should be fired, because the new master will
35076714d8e8SKurt Hackel * shuffle the lists on this lockres as soon as it is migrated.
35086714d8e8SKurt Hackel */
dlm_lockres_release_ast(struct dlm_ctxt * dlm,struct dlm_lock_resource * res)35096714d8e8SKurt Hackel void dlm_lockres_release_ast(struct dlm_ctxt *dlm,
35106714d8e8SKurt Hackel struct dlm_lock_resource *res)
35116714d8e8SKurt Hackel {
35126714d8e8SKurt Hackel if (!atomic_dec_and_lock(&res->asts_reserved, &res->spinlock))
35136714d8e8SKurt Hackel return;
35146714d8e8SKurt Hackel
35156714d8e8SKurt Hackel if (!res->migration_pending) {
35166714d8e8SKurt Hackel spin_unlock(&res->spinlock);
35176714d8e8SKurt Hackel return;
35186714d8e8SKurt Hackel }
35196714d8e8SKurt Hackel
35206714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING);
35216714d8e8SKurt Hackel res->migration_pending = 0;
35226714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING;
35236714d8e8SKurt Hackel spin_unlock(&res->spinlock);
35246714d8e8SKurt Hackel wake_up(&res->wq);
35256714d8e8SKurt Hackel wake_up(&dlm->migration_wq);
35266714d8e8SKurt Hackel }
35275dad6c39SSrinivas Eeda
dlm_force_free_mles(struct dlm_ctxt * dlm)35285dad6c39SSrinivas Eeda void dlm_force_free_mles(struct dlm_ctxt *dlm)
35295dad6c39SSrinivas Eeda {
35305dad6c39SSrinivas Eeda int i;
35315dad6c39SSrinivas Eeda struct hlist_head *bucket;
35325dad6c39SSrinivas Eeda struct dlm_master_list_entry *mle;
3533df53cd3bSDong Fang struct hlist_node *tmp;
35345dad6c39SSrinivas Eeda
35355dad6c39SSrinivas Eeda /*
35365dad6c39SSrinivas Eeda * We notified all other nodes that we are exiting the domain and
35375dad6c39SSrinivas Eeda * marked the dlm state to DLM_CTXT_LEAVING. If any mles are still
35385dad6c39SSrinivas Eeda * around we force free them and wake any processes that are waiting
35395dad6c39SSrinivas Eeda * on the mles
35405dad6c39SSrinivas Eeda */
35415dad6c39SSrinivas Eeda spin_lock(&dlm->spinlock);
35425dad6c39SSrinivas Eeda spin_lock(&dlm->master_lock);
35435dad6c39SSrinivas Eeda
35445dad6c39SSrinivas Eeda BUG_ON(dlm->dlm_state != DLM_CTXT_LEAVING);
3545b5c7e7ecSYury Norov BUG_ON((find_first_bit(dlm->domain_map, O2NM_MAX_NODES) < O2NM_MAX_NODES));
35465dad6c39SSrinivas Eeda
35475dad6c39SSrinivas Eeda for (i = 0; i < DLM_HASH_BUCKETS; i++) {
35485dad6c39SSrinivas Eeda bucket = dlm_master_hash(dlm, i);
3549df53cd3bSDong Fang hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) {
35505dad6c39SSrinivas Eeda if (mle->type != DLM_MLE_BLOCK) {
35515dad6c39SSrinivas Eeda mlog(ML_ERROR, "bad mle: %p\n", mle);
35525dad6c39SSrinivas Eeda dlm_print_one_mle(mle);
35535dad6c39SSrinivas Eeda }
35545dad6c39SSrinivas Eeda atomic_set(&mle->woken, 1);
35555dad6c39SSrinivas Eeda wake_up(&mle->wq);
35565dad6c39SSrinivas Eeda
35575dad6c39SSrinivas Eeda __dlm_unlink_mle(dlm, mle);
35585dad6c39SSrinivas Eeda __dlm_mle_detach_hb_events(dlm, mle);
35595dad6c39SSrinivas Eeda __dlm_put_mle(mle);
35605dad6c39SSrinivas Eeda }
35615dad6c39SSrinivas Eeda }
35625dad6c39SSrinivas Eeda spin_unlock(&dlm->master_lock);
35635dad6c39SSrinivas Eeda spin_unlock(&dlm->spinlock);
35645dad6c39SSrinivas Eeda }
3565