16714d8e8SKurt Hackel /* -*- mode: c; c-basic-offset: 8; -*- 26714d8e8SKurt Hackel * vim: noexpandtab sw=8 ts=8 sts=0: 36714d8e8SKurt Hackel * 46714d8e8SKurt Hackel * dlmmod.c 56714d8e8SKurt Hackel * 66714d8e8SKurt Hackel * standalone DLM module 76714d8e8SKurt Hackel * 86714d8e8SKurt Hackel * Copyright (C) 2004 Oracle. All rights reserved. 96714d8e8SKurt Hackel * 106714d8e8SKurt Hackel * This program is free software; you can redistribute it and/or 116714d8e8SKurt Hackel * modify it under the terms of the GNU General Public 126714d8e8SKurt Hackel * License as published by the Free Software Foundation; either 136714d8e8SKurt Hackel * version 2 of the License, or (at your option) any later version. 146714d8e8SKurt Hackel * 156714d8e8SKurt Hackel * This program is distributed in the hope that it will be useful, 166714d8e8SKurt Hackel * but WITHOUT ANY WARRANTY; without even the implied warranty of 176714d8e8SKurt Hackel * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 186714d8e8SKurt Hackel * General Public License for more details. 196714d8e8SKurt Hackel * 206714d8e8SKurt Hackel * You should have received a copy of the GNU General Public 216714d8e8SKurt Hackel * License along with this program; if not, write to the 226714d8e8SKurt Hackel * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 236714d8e8SKurt Hackel * Boston, MA 021110-1307, USA. 246714d8e8SKurt Hackel * 256714d8e8SKurt Hackel */ 266714d8e8SKurt Hackel 276714d8e8SKurt Hackel 286714d8e8SKurt Hackel #include <linux/module.h> 296714d8e8SKurt Hackel #include <linux/fs.h> 306714d8e8SKurt Hackel #include <linux/types.h> 316714d8e8SKurt Hackel #include <linux/slab.h> 326714d8e8SKurt Hackel #include <linux/highmem.h> 336714d8e8SKurt Hackel #include <linux/init.h> 346714d8e8SKurt Hackel #include <linux/sysctl.h> 356714d8e8SKurt Hackel #include <linux/random.h> 366714d8e8SKurt Hackel #include <linux/blkdev.h> 376714d8e8SKurt Hackel #include <linux/socket.h> 386714d8e8SKurt Hackel #include <linux/inet.h> 396714d8e8SKurt Hackel #include <linux/spinlock.h> 406714d8e8SKurt Hackel #include <linux/delay.h> 416714d8e8SKurt Hackel 426714d8e8SKurt Hackel 436714d8e8SKurt Hackel #include "cluster/heartbeat.h" 446714d8e8SKurt Hackel #include "cluster/nodemanager.h" 456714d8e8SKurt Hackel #include "cluster/tcp.h" 466714d8e8SKurt Hackel 476714d8e8SKurt Hackel #include "dlmapi.h" 486714d8e8SKurt Hackel #include "dlmcommon.h" 4982353b59SAdrian Bunk #include "dlmdomain.h" 50e5a0334cSSunil Mushran #include "dlmdebug.h" 516714d8e8SKurt Hackel 526714d8e8SKurt Hackel #define MLOG_MASK_PREFIX (ML_DLM|ML_DLM_MASTER) 536714d8e8SKurt Hackel #include "cluster/masklog.h" 546714d8e8SKurt Hackel 556714d8e8SKurt Hackel static void dlm_mle_node_down(struct dlm_ctxt *dlm, 566714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 576714d8e8SKurt Hackel struct o2nm_node *node, 586714d8e8SKurt Hackel int idx); 596714d8e8SKurt Hackel static void dlm_mle_node_up(struct dlm_ctxt *dlm, 606714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 616714d8e8SKurt Hackel struct o2nm_node *node, 626714d8e8SKurt Hackel int idx); 636714d8e8SKurt Hackel 646714d8e8SKurt Hackel static void dlm_assert_master_worker(struct dlm_work_item *item, void *data); 65ba2bf218SKurt Hackel static int dlm_do_assert_master(struct dlm_ctxt *dlm, 66ba2bf218SKurt Hackel struct dlm_lock_resource *res, 67ba2bf218SKurt Hackel void *nodemap, u32 flags); 68f3f85464SSunil Mushran static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data); 696714d8e8SKurt Hackel 706714d8e8SKurt Hackel static inline int dlm_mle_equal(struct dlm_ctxt *dlm, 716714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 726714d8e8SKurt Hackel const char *name, 736714d8e8SKurt Hackel unsigned int namelen) 746714d8e8SKurt Hackel { 756714d8e8SKurt Hackel if (dlm != mle->dlm) 766714d8e8SKurt Hackel return 0; 776714d8e8SKurt Hackel 787141514bSSunil Mushran if (namelen != mle->mnamelen || 797141514bSSunil Mushran memcmp(name, mle->mname, namelen) != 0) 806714d8e8SKurt Hackel return 0; 81f77a9a78SSunil Mushran 826714d8e8SKurt Hackel return 1; 836714d8e8SKurt Hackel } 846714d8e8SKurt Hackel 851a5c4e2aSFabian Frederick static struct kmem_cache *dlm_lockres_cache; 861a5c4e2aSFabian Frederick static struct kmem_cache *dlm_lockname_cache; 871a5c4e2aSFabian Frederick static struct kmem_cache *dlm_mle_cache; 886714d8e8SKurt Hackel 896714d8e8SKurt Hackel static void dlm_mle_release(struct kref *kref); 906714d8e8SKurt Hackel static void dlm_init_mle(struct dlm_master_list_entry *mle, 916714d8e8SKurt Hackel enum dlm_mle_type type, 926714d8e8SKurt Hackel struct dlm_ctxt *dlm, 936714d8e8SKurt Hackel struct dlm_lock_resource *res, 946714d8e8SKurt Hackel const char *name, 956714d8e8SKurt Hackel unsigned int namelen); 966714d8e8SKurt Hackel static void dlm_put_mle(struct dlm_master_list_entry *mle); 976714d8e8SKurt Hackel static void __dlm_put_mle(struct dlm_master_list_entry *mle); 986714d8e8SKurt Hackel static int dlm_find_mle(struct dlm_ctxt *dlm, 996714d8e8SKurt Hackel struct dlm_master_list_entry **mle, 1006714d8e8SKurt Hackel char *name, unsigned int namelen); 1016714d8e8SKurt Hackel 102ba2bf218SKurt Hackel static int dlm_do_master_request(struct dlm_lock_resource *res, 103ba2bf218SKurt Hackel struct dlm_master_list_entry *mle, int to); 1046714d8e8SKurt Hackel 1056714d8e8SKurt Hackel 1066714d8e8SKurt Hackel static int dlm_wait_for_lock_mastery(struct dlm_ctxt *dlm, 1076714d8e8SKurt Hackel struct dlm_lock_resource *res, 1086714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 1096714d8e8SKurt Hackel int *blocked); 1106714d8e8SKurt Hackel static int dlm_restart_lock_mastery(struct dlm_ctxt *dlm, 1116714d8e8SKurt Hackel struct dlm_lock_resource *res, 1126714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 1136714d8e8SKurt Hackel int blocked); 1146714d8e8SKurt Hackel static int dlm_add_migration_mle(struct dlm_ctxt *dlm, 1156714d8e8SKurt Hackel struct dlm_lock_resource *res, 1166714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 1176714d8e8SKurt Hackel struct dlm_master_list_entry **oldmle, 1186714d8e8SKurt Hackel const char *name, unsigned int namelen, 1196714d8e8SKurt Hackel u8 new_master, u8 master); 1206714d8e8SKurt Hackel 1216714d8e8SKurt Hackel static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm, 1226714d8e8SKurt Hackel struct dlm_lock_resource *res); 1236714d8e8SKurt Hackel static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm, 1246714d8e8SKurt Hackel struct dlm_lock_resource *res); 1256714d8e8SKurt Hackel static int dlm_mark_lockres_migrating(struct dlm_ctxt *dlm, 1266714d8e8SKurt Hackel struct dlm_lock_resource *res, 1276714d8e8SKurt Hackel u8 target); 128c03872f5SKurt Hackel static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, 129c03872f5SKurt Hackel struct dlm_lock_resource *res); 1306714d8e8SKurt Hackel 1316714d8e8SKurt Hackel 1326714d8e8SKurt Hackel int dlm_is_host_down(int errno) 1336714d8e8SKurt Hackel { 1346714d8e8SKurt Hackel switch (errno) { 1356714d8e8SKurt Hackel case -EBADF: 1366714d8e8SKurt Hackel case -ECONNREFUSED: 1376714d8e8SKurt Hackel case -ENOTCONN: 1386714d8e8SKurt Hackel case -ECONNRESET: 1396714d8e8SKurt Hackel case -EPIPE: 1406714d8e8SKurt Hackel case -EHOSTDOWN: 1416714d8e8SKurt Hackel case -EHOSTUNREACH: 1426714d8e8SKurt Hackel case -ETIMEDOUT: 1436714d8e8SKurt Hackel case -ECONNABORTED: 1446714d8e8SKurt Hackel case -ENETDOWN: 1456714d8e8SKurt Hackel case -ENETUNREACH: 1466714d8e8SKurt Hackel case -ENETRESET: 1476714d8e8SKurt Hackel case -ESHUTDOWN: 1486714d8e8SKurt Hackel case -ENOPROTOOPT: 1496714d8e8SKurt Hackel case -EINVAL: /* if returned from our tcp code, 1506714d8e8SKurt Hackel this means there is no socket */ 1516714d8e8SKurt Hackel return 1; 1526714d8e8SKurt Hackel } 1536714d8e8SKurt Hackel return 0; 1546714d8e8SKurt Hackel } 1556714d8e8SKurt Hackel 1566714d8e8SKurt Hackel 1576714d8e8SKurt Hackel /* 1586714d8e8SKurt Hackel * MASTER LIST FUNCTIONS 1596714d8e8SKurt Hackel */ 1606714d8e8SKurt Hackel 1616714d8e8SKurt Hackel 1626714d8e8SKurt Hackel /* 1636714d8e8SKurt Hackel * regarding master list entries and heartbeat callbacks: 1646714d8e8SKurt Hackel * 1656714d8e8SKurt Hackel * in order to avoid sleeping and allocation that occurs in 1666714d8e8SKurt Hackel * heartbeat, master list entries are simply attached to the 1676714d8e8SKurt Hackel * dlm's established heartbeat callbacks. the mle is attached 1686714d8e8SKurt Hackel * when it is created, and since the dlm->spinlock is held at 1696714d8e8SKurt Hackel * that time, any heartbeat event will be properly discovered 1706714d8e8SKurt Hackel * by the mle. the mle needs to be detached from the 1716714d8e8SKurt Hackel * dlm->mle_hb_events list as soon as heartbeat events are no 1726714d8e8SKurt Hackel * longer useful to the mle, and before the mle is freed. 1736714d8e8SKurt Hackel * 1746714d8e8SKurt Hackel * as a general rule, heartbeat events are no longer needed by 1756714d8e8SKurt Hackel * the mle once an "answer" regarding the lock master has been 1766714d8e8SKurt Hackel * received. 1776714d8e8SKurt Hackel */ 1786714d8e8SKurt Hackel static inline void __dlm_mle_attach_hb_events(struct dlm_ctxt *dlm, 1796714d8e8SKurt Hackel struct dlm_master_list_entry *mle) 1806714d8e8SKurt Hackel { 1816714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 1826714d8e8SKurt Hackel 1836714d8e8SKurt Hackel list_add_tail(&mle->hb_events, &dlm->mle_hb_events); 1846714d8e8SKurt Hackel } 1856714d8e8SKurt Hackel 1866714d8e8SKurt Hackel 1876714d8e8SKurt Hackel static inline void __dlm_mle_detach_hb_events(struct dlm_ctxt *dlm, 1886714d8e8SKurt Hackel struct dlm_master_list_entry *mle) 1896714d8e8SKurt Hackel { 1906714d8e8SKurt Hackel if (!list_empty(&mle->hb_events)) 1916714d8e8SKurt Hackel list_del_init(&mle->hb_events); 1926714d8e8SKurt Hackel } 1936714d8e8SKurt Hackel 1946714d8e8SKurt Hackel 1956714d8e8SKurt Hackel static inline void dlm_mle_detach_hb_events(struct dlm_ctxt *dlm, 1966714d8e8SKurt Hackel struct dlm_master_list_entry *mle) 1976714d8e8SKurt Hackel { 1986714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 1996714d8e8SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle); 2006714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 2016714d8e8SKurt Hackel } 2026714d8e8SKurt Hackel 203a2bf0477SKurt Hackel static void dlm_get_mle_inuse(struct dlm_master_list_entry *mle) 204a2bf0477SKurt Hackel { 205a2bf0477SKurt Hackel struct dlm_ctxt *dlm; 206a2bf0477SKurt Hackel dlm = mle->dlm; 207a2bf0477SKurt Hackel 208a2bf0477SKurt Hackel assert_spin_locked(&dlm->spinlock); 209a2bf0477SKurt Hackel assert_spin_locked(&dlm->master_lock); 210a2bf0477SKurt Hackel mle->inuse++; 211a2bf0477SKurt Hackel kref_get(&mle->mle_refs); 212a2bf0477SKurt Hackel } 213a2bf0477SKurt Hackel 214a2bf0477SKurt Hackel static void dlm_put_mle_inuse(struct dlm_master_list_entry *mle) 215a2bf0477SKurt Hackel { 216a2bf0477SKurt Hackel struct dlm_ctxt *dlm; 217a2bf0477SKurt Hackel dlm = mle->dlm; 218a2bf0477SKurt Hackel 219a2bf0477SKurt Hackel spin_lock(&dlm->spinlock); 220a2bf0477SKurt Hackel spin_lock(&dlm->master_lock); 221a2bf0477SKurt Hackel mle->inuse--; 222a2bf0477SKurt Hackel __dlm_put_mle(mle); 223a2bf0477SKurt Hackel spin_unlock(&dlm->master_lock); 224a2bf0477SKurt Hackel spin_unlock(&dlm->spinlock); 225a2bf0477SKurt Hackel 226a2bf0477SKurt Hackel } 227a2bf0477SKurt Hackel 2286714d8e8SKurt Hackel /* remove from list and free */ 2296714d8e8SKurt Hackel static void __dlm_put_mle(struct dlm_master_list_entry *mle) 2306714d8e8SKurt Hackel { 2316714d8e8SKurt Hackel struct dlm_ctxt *dlm; 2326714d8e8SKurt Hackel dlm = mle->dlm; 2336714d8e8SKurt Hackel 2346714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 2356714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 236aa852354SKurt Hackel if (!atomic_read(&mle->mle_refs.refcount)) { 237aa852354SKurt Hackel /* this may or may not crash, but who cares. 238aa852354SKurt Hackel * it's a BUG. */ 239aa852354SKurt Hackel mlog(ML_ERROR, "bad mle: %p\n", mle); 240aa852354SKurt Hackel dlm_print_one_mle(mle); 241aa852354SKurt Hackel BUG(); 242aa852354SKurt Hackel } else 2436714d8e8SKurt Hackel kref_put(&mle->mle_refs, dlm_mle_release); 2446714d8e8SKurt Hackel } 2456714d8e8SKurt Hackel 2466714d8e8SKurt Hackel 2476714d8e8SKurt Hackel /* must not have any spinlocks coming in */ 2486714d8e8SKurt Hackel static void dlm_put_mle(struct dlm_master_list_entry *mle) 2496714d8e8SKurt Hackel { 2506714d8e8SKurt Hackel struct dlm_ctxt *dlm; 2516714d8e8SKurt Hackel dlm = mle->dlm; 2526714d8e8SKurt Hackel 2536714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 2546714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 2556714d8e8SKurt Hackel __dlm_put_mle(mle); 2566714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 2576714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 2586714d8e8SKurt Hackel } 2596714d8e8SKurt Hackel 2606714d8e8SKurt Hackel static inline void dlm_get_mle(struct dlm_master_list_entry *mle) 2616714d8e8SKurt Hackel { 2626714d8e8SKurt Hackel kref_get(&mle->mle_refs); 2636714d8e8SKurt Hackel } 2646714d8e8SKurt Hackel 2656714d8e8SKurt Hackel static void dlm_init_mle(struct dlm_master_list_entry *mle, 2666714d8e8SKurt Hackel enum dlm_mle_type type, 2676714d8e8SKurt Hackel struct dlm_ctxt *dlm, 2686714d8e8SKurt Hackel struct dlm_lock_resource *res, 2696714d8e8SKurt Hackel const char *name, 2706714d8e8SKurt Hackel unsigned int namelen) 2716714d8e8SKurt Hackel { 2726714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 2736714d8e8SKurt Hackel 2746714d8e8SKurt Hackel mle->dlm = dlm; 2756714d8e8SKurt Hackel mle->type = type; 2762ed6c750SSunil Mushran INIT_HLIST_NODE(&mle->master_hash_node); 2776714d8e8SKurt Hackel INIT_LIST_HEAD(&mle->hb_events); 2786714d8e8SKurt Hackel memset(mle->maybe_map, 0, sizeof(mle->maybe_map)); 2796714d8e8SKurt Hackel spin_lock_init(&mle->spinlock); 2806714d8e8SKurt Hackel init_waitqueue_head(&mle->wq); 2816714d8e8SKurt Hackel atomic_set(&mle->woken, 0); 2826714d8e8SKurt Hackel kref_init(&mle->mle_refs); 2836714d8e8SKurt Hackel memset(mle->response_map, 0, sizeof(mle->response_map)); 2846714d8e8SKurt Hackel mle->master = O2NM_MAX_NODES; 2856714d8e8SKurt Hackel mle->new_master = O2NM_MAX_NODES; 286a2bf0477SKurt Hackel mle->inuse = 0; 2876714d8e8SKurt Hackel 288f77a9a78SSunil Mushran BUG_ON(mle->type != DLM_MLE_BLOCK && 289f77a9a78SSunil Mushran mle->type != DLM_MLE_MASTER && 290f77a9a78SSunil Mushran mle->type != DLM_MLE_MIGRATION); 291f77a9a78SSunil Mushran 2926714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) { 2936714d8e8SKurt Hackel BUG_ON(!res); 2947141514bSSunil Mushran mle->mleres = res; 2957141514bSSunil Mushran memcpy(mle->mname, res->lockname.name, res->lockname.len); 2967141514bSSunil Mushran mle->mnamelen = res->lockname.len; 2977141514bSSunil Mushran mle->mnamehash = res->lockname.hash; 298f77a9a78SSunil Mushran } else { 2996714d8e8SKurt Hackel BUG_ON(!name); 3007141514bSSunil Mushran mle->mleres = NULL; 3017141514bSSunil Mushran memcpy(mle->mname, name, namelen); 3027141514bSSunil Mushran mle->mnamelen = namelen; 3037141514bSSunil Mushran mle->mnamehash = dlm_lockid_hash(name, namelen); 3046714d8e8SKurt Hackel } 3056714d8e8SKurt Hackel 3062041d8fdSSunil Mushran atomic_inc(&dlm->mle_tot_count[mle->type]); 3072041d8fdSSunil Mushran atomic_inc(&dlm->mle_cur_count[mle->type]); 3082041d8fdSSunil Mushran 3096714d8e8SKurt Hackel /* copy off the node_map and register hb callbacks on our copy */ 3106714d8e8SKurt Hackel memcpy(mle->node_map, dlm->domain_map, sizeof(mle->node_map)); 3116714d8e8SKurt Hackel memcpy(mle->vote_map, dlm->domain_map, sizeof(mle->vote_map)); 3126714d8e8SKurt Hackel clear_bit(dlm->node_num, mle->vote_map); 3136714d8e8SKurt Hackel clear_bit(dlm->node_num, mle->node_map); 3146714d8e8SKurt Hackel 3156714d8e8SKurt Hackel /* attach the mle to the domain node up/down events */ 3166714d8e8SKurt Hackel __dlm_mle_attach_hb_events(dlm, mle); 3176714d8e8SKurt Hackel } 3186714d8e8SKurt Hackel 3191c084577SSunil Mushran void __dlm_unlink_mle(struct dlm_ctxt *dlm, struct dlm_master_list_entry *mle) 3201c084577SSunil Mushran { 3211c084577SSunil Mushran assert_spin_locked(&dlm->spinlock); 3221c084577SSunil Mushran assert_spin_locked(&dlm->master_lock); 3231c084577SSunil Mushran 3242ed6c750SSunil Mushran if (!hlist_unhashed(&mle->master_hash_node)) 3252ed6c750SSunil Mushran hlist_del_init(&mle->master_hash_node); 3261c084577SSunil Mushran } 3271c084577SSunil Mushran 3281c084577SSunil Mushran void __dlm_insert_mle(struct dlm_ctxt *dlm, struct dlm_master_list_entry *mle) 3291c084577SSunil Mushran { 3302ed6c750SSunil Mushran struct hlist_head *bucket; 3312ed6c750SSunil Mushran 3321c084577SSunil Mushran assert_spin_locked(&dlm->master_lock); 3331c084577SSunil Mushran 3347141514bSSunil Mushran bucket = dlm_master_hash(dlm, mle->mnamehash); 3352ed6c750SSunil Mushran hlist_add_head(&mle->master_hash_node, bucket); 3361c084577SSunil Mushran } 3376714d8e8SKurt Hackel 3386714d8e8SKurt Hackel /* returns 1 if found, 0 if not */ 3396714d8e8SKurt Hackel static int dlm_find_mle(struct dlm_ctxt *dlm, 3406714d8e8SKurt Hackel struct dlm_master_list_entry **mle, 3416714d8e8SKurt Hackel char *name, unsigned int namelen) 3426714d8e8SKurt Hackel { 3436714d8e8SKurt Hackel struct dlm_master_list_entry *tmpmle; 3442ed6c750SSunil Mushran struct hlist_head *bucket; 3452ed6c750SSunil Mushran unsigned int hash; 3466714d8e8SKurt Hackel 3476714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 3486714d8e8SKurt Hackel 3492ed6c750SSunil Mushran hash = dlm_lockid_hash(name, namelen); 3502ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, hash); 351df53cd3bSDong Fang hlist_for_each_entry(tmpmle, bucket, master_hash_node) { 3526714d8e8SKurt Hackel if (!dlm_mle_equal(dlm, tmpmle, name, namelen)) 3536714d8e8SKurt Hackel continue; 3546714d8e8SKurt Hackel dlm_get_mle(tmpmle); 3556714d8e8SKurt Hackel *mle = tmpmle; 3566714d8e8SKurt Hackel return 1; 3576714d8e8SKurt Hackel } 3586714d8e8SKurt Hackel return 0; 3596714d8e8SKurt Hackel } 3606714d8e8SKurt Hackel 3616714d8e8SKurt Hackel void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up) 3626714d8e8SKurt Hackel { 3636714d8e8SKurt Hackel struct dlm_master_list_entry *mle; 3646714d8e8SKurt Hackel 3656714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 3666714d8e8SKurt Hackel 367800deef3SChristoph Hellwig list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) { 3686714d8e8SKurt Hackel if (node_up) 3696714d8e8SKurt Hackel dlm_mle_node_up(dlm, mle, NULL, idx); 3706714d8e8SKurt Hackel else 3716714d8e8SKurt Hackel dlm_mle_node_down(dlm, mle, NULL, idx); 3726714d8e8SKurt Hackel } 3736714d8e8SKurt Hackel } 3746714d8e8SKurt Hackel 3756714d8e8SKurt Hackel static void dlm_mle_node_down(struct dlm_ctxt *dlm, 3766714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 3776714d8e8SKurt Hackel struct o2nm_node *node, int idx) 3786714d8e8SKurt Hackel { 3796714d8e8SKurt Hackel spin_lock(&mle->spinlock); 3806714d8e8SKurt Hackel 3816714d8e8SKurt Hackel if (!test_bit(idx, mle->node_map)) 3826714d8e8SKurt Hackel mlog(0, "node %u already removed from nodemap!\n", idx); 3836714d8e8SKurt Hackel else 3846714d8e8SKurt Hackel clear_bit(idx, mle->node_map); 3856714d8e8SKurt Hackel 3866714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 3876714d8e8SKurt Hackel } 3886714d8e8SKurt Hackel 3896714d8e8SKurt Hackel static void dlm_mle_node_up(struct dlm_ctxt *dlm, 3906714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 3916714d8e8SKurt Hackel struct o2nm_node *node, int idx) 3926714d8e8SKurt Hackel { 3936714d8e8SKurt Hackel spin_lock(&mle->spinlock); 3946714d8e8SKurt Hackel 3956714d8e8SKurt Hackel if (test_bit(idx, mle->node_map)) 3966714d8e8SKurt Hackel mlog(0, "node %u already in node map!\n", idx); 3976714d8e8SKurt Hackel else 3986714d8e8SKurt Hackel set_bit(idx, mle->node_map); 3996714d8e8SKurt Hackel 4006714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 4016714d8e8SKurt Hackel } 4026714d8e8SKurt Hackel 4036714d8e8SKurt Hackel 4046714d8e8SKurt Hackel int dlm_init_mle_cache(void) 4056714d8e8SKurt Hackel { 40612eb0035SSunil Mushran dlm_mle_cache = kmem_cache_create("o2dlm_mle", 4076714d8e8SKurt Hackel sizeof(struct dlm_master_list_entry), 4086714d8e8SKurt Hackel 0, SLAB_HWCACHE_ALIGN, 40920c2df83SPaul Mundt NULL); 4106714d8e8SKurt Hackel if (dlm_mle_cache == NULL) 4116714d8e8SKurt Hackel return -ENOMEM; 4126714d8e8SKurt Hackel return 0; 4136714d8e8SKurt Hackel } 4146714d8e8SKurt Hackel 4156714d8e8SKurt Hackel void dlm_destroy_mle_cache(void) 4166714d8e8SKurt Hackel { 4176714d8e8SKurt Hackel if (dlm_mle_cache) 4186714d8e8SKurt Hackel kmem_cache_destroy(dlm_mle_cache); 4196714d8e8SKurt Hackel } 4206714d8e8SKurt Hackel 4216714d8e8SKurt Hackel static void dlm_mle_release(struct kref *kref) 4226714d8e8SKurt Hackel { 4236714d8e8SKurt Hackel struct dlm_master_list_entry *mle; 4246714d8e8SKurt Hackel struct dlm_ctxt *dlm; 4256714d8e8SKurt Hackel 4266714d8e8SKurt Hackel mle = container_of(kref, struct dlm_master_list_entry, mle_refs); 4276714d8e8SKurt Hackel dlm = mle->dlm; 4286714d8e8SKurt Hackel 4296714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 4306714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 4316714d8e8SKurt Hackel 4327141514bSSunil Mushran mlog(0, "Releasing mle for %.*s, type %d\n", mle->mnamelen, mle->mname, 4337141514bSSunil Mushran mle->type); 4342ed6c750SSunil Mushran 4356714d8e8SKurt Hackel /* remove from list if not already */ 4361c084577SSunil Mushran __dlm_unlink_mle(dlm, mle); 4376714d8e8SKurt Hackel 4386714d8e8SKurt Hackel /* detach the mle from the domain node up/down events */ 4396714d8e8SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle); 4406714d8e8SKurt Hackel 4412041d8fdSSunil Mushran atomic_dec(&dlm->mle_cur_count[mle->type]); 4422041d8fdSSunil Mushran 4436714d8e8SKurt Hackel /* NOTE: kfree under spinlock here. 4446714d8e8SKurt Hackel * if this is bad, we can move this to a freelist. */ 4456714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 4466714d8e8SKurt Hackel } 4476714d8e8SKurt Hackel 4486714d8e8SKurt Hackel 4496714d8e8SKurt Hackel /* 4506714d8e8SKurt Hackel * LOCK RESOURCE FUNCTIONS 4516714d8e8SKurt Hackel */ 4526714d8e8SKurt Hackel 453724bdca9SSunil Mushran int dlm_init_master_caches(void) 454724bdca9SSunil Mushran { 455724bdca9SSunil Mushran dlm_lockres_cache = kmem_cache_create("o2dlm_lockres", 456724bdca9SSunil Mushran sizeof(struct dlm_lock_resource), 457724bdca9SSunil Mushran 0, SLAB_HWCACHE_ALIGN, NULL); 458724bdca9SSunil Mushran if (!dlm_lockres_cache) 459724bdca9SSunil Mushran goto bail; 460724bdca9SSunil Mushran 461724bdca9SSunil Mushran dlm_lockname_cache = kmem_cache_create("o2dlm_lockname", 462724bdca9SSunil Mushran DLM_LOCKID_NAME_MAX, 0, 463724bdca9SSunil Mushran SLAB_HWCACHE_ALIGN, NULL); 464724bdca9SSunil Mushran if (!dlm_lockname_cache) 465724bdca9SSunil Mushran goto bail; 466724bdca9SSunil Mushran 467724bdca9SSunil Mushran return 0; 468724bdca9SSunil Mushran bail: 469724bdca9SSunil Mushran dlm_destroy_master_caches(); 470724bdca9SSunil Mushran return -ENOMEM; 471724bdca9SSunil Mushran } 472724bdca9SSunil Mushran 473724bdca9SSunil Mushran void dlm_destroy_master_caches(void) 474724bdca9SSunil Mushran { 47566db6cfdSJoseph Qi if (dlm_lockname_cache) { 476724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockname_cache); 47766db6cfdSJoseph Qi dlm_lockname_cache = NULL; 47866db6cfdSJoseph Qi } 479724bdca9SSunil Mushran 48066db6cfdSJoseph Qi if (dlm_lockres_cache) { 481724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockres_cache); 48266db6cfdSJoseph Qi dlm_lockres_cache = NULL; 48366db6cfdSJoseph Qi } 484724bdca9SSunil Mushran } 485724bdca9SSunil Mushran 4866714d8e8SKurt Hackel static void dlm_lockres_release(struct kref *kref) 4876714d8e8SKurt Hackel { 4886714d8e8SKurt Hackel struct dlm_lock_resource *res; 489b0d4f817SSunil Mushran struct dlm_ctxt *dlm; 4906714d8e8SKurt Hackel 4916714d8e8SKurt Hackel res = container_of(kref, struct dlm_lock_resource, refs); 492b0d4f817SSunil Mushran dlm = res->dlm; 4936714d8e8SKurt Hackel 4946714d8e8SKurt Hackel /* This should not happen -- all lockres' have a name 4956714d8e8SKurt Hackel * associated with them at init time. */ 4966714d8e8SKurt Hackel BUG_ON(!res->lockname.name); 4976714d8e8SKurt Hackel 4986714d8e8SKurt Hackel mlog(0, "destroying lockres %.*s\n", res->lockname.len, 4996714d8e8SKurt Hackel res->lockname.name); 5006714d8e8SKurt Hackel 5016800791aSSunil Mushran atomic_dec(&dlm->res_cur_count); 5026800791aSSunil Mushran 503a7f90d83SKurt Hackel if (!hlist_unhashed(&res->hash_node) || 504a7f90d83SKurt Hackel !list_empty(&res->granted) || 505a7f90d83SKurt Hackel !list_empty(&res->converting) || 506a7f90d83SKurt Hackel !list_empty(&res->blocked) || 507a7f90d83SKurt Hackel !list_empty(&res->dirty) || 508a7f90d83SKurt Hackel !list_empty(&res->recovering) || 509a7f90d83SKurt Hackel !list_empty(&res->purge)) { 510a7f90d83SKurt Hackel mlog(ML_ERROR, 511a7f90d83SKurt Hackel "Going to BUG for resource %.*s." 512a7f90d83SKurt Hackel " We're on a list! [%c%c%c%c%c%c%c]\n", 513a7f90d83SKurt Hackel res->lockname.len, res->lockname.name, 514a7f90d83SKurt Hackel !hlist_unhashed(&res->hash_node) ? 'H' : ' ', 515a7f90d83SKurt Hackel !list_empty(&res->granted) ? 'G' : ' ', 516a7f90d83SKurt Hackel !list_empty(&res->converting) ? 'C' : ' ', 517a7f90d83SKurt Hackel !list_empty(&res->blocked) ? 'B' : ' ', 518a7f90d83SKurt Hackel !list_empty(&res->dirty) ? 'D' : ' ', 519a7f90d83SKurt Hackel !list_empty(&res->recovering) ? 'R' : ' ', 520a7f90d83SKurt Hackel !list_empty(&res->purge) ? 'P' : ' '); 521a7f90d83SKurt Hackel 522a7f90d83SKurt Hackel dlm_print_one_lock_resource(res); 523a7f90d83SKurt Hackel } 524a7f90d83SKurt Hackel 5256714d8e8SKurt Hackel /* By the time we're ready to blow this guy away, we shouldn't 5266714d8e8SKurt Hackel * be on any lists. */ 52781f2094aSMark Fasheh BUG_ON(!hlist_unhashed(&res->hash_node)); 5286714d8e8SKurt Hackel BUG_ON(!list_empty(&res->granted)); 5296714d8e8SKurt Hackel BUG_ON(!list_empty(&res->converting)); 5306714d8e8SKurt Hackel BUG_ON(!list_empty(&res->blocked)); 5316714d8e8SKurt Hackel BUG_ON(!list_empty(&res->dirty)); 5326714d8e8SKurt Hackel BUG_ON(!list_empty(&res->recovering)); 5336714d8e8SKurt Hackel BUG_ON(!list_empty(&res->purge)); 5346714d8e8SKurt Hackel 535724bdca9SSunil Mushran kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name); 5366714d8e8SKurt Hackel 537724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res); 5386714d8e8SKurt Hackel } 5396714d8e8SKurt Hackel 5406714d8e8SKurt Hackel void dlm_lockres_put(struct dlm_lock_resource *res) 5416714d8e8SKurt Hackel { 5426714d8e8SKurt Hackel kref_put(&res->refs, dlm_lockres_release); 5436714d8e8SKurt Hackel } 5446714d8e8SKurt Hackel 5456714d8e8SKurt Hackel static void dlm_init_lockres(struct dlm_ctxt *dlm, 5466714d8e8SKurt Hackel struct dlm_lock_resource *res, 5476714d8e8SKurt Hackel const char *name, unsigned int namelen) 5486714d8e8SKurt Hackel { 5496714d8e8SKurt Hackel char *qname; 5506714d8e8SKurt Hackel 5516714d8e8SKurt Hackel /* If we memset here, we lose our reference to the kmalloc'd 5526714d8e8SKurt Hackel * res->lockname.name, so be sure to init every field 5536714d8e8SKurt Hackel * correctly! */ 5546714d8e8SKurt Hackel 5556714d8e8SKurt Hackel qname = (char *) res->lockname.name; 5566714d8e8SKurt Hackel memcpy(qname, name, namelen); 5576714d8e8SKurt Hackel 5586714d8e8SKurt Hackel res->lockname.len = namelen; 559a3d33291SMark Fasheh res->lockname.hash = dlm_lockid_hash(name, namelen); 5606714d8e8SKurt Hackel 5616714d8e8SKurt Hackel init_waitqueue_head(&res->wq); 5626714d8e8SKurt Hackel spin_lock_init(&res->spinlock); 56381f2094aSMark Fasheh INIT_HLIST_NODE(&res->hash_node); 5646714d8e8SKurt Hackel INIT_LIST_HEAD(&res->granted); 5656714d8e8SKurt Hackel INIT_LIST_HEAD(&res->converting); 5666714d8e8SKurt Hackel INIT_LIST_HEAD(&res->blocked); 5676714d8e8SKurt Hackel INIT_LIST_HEAD(&res->dirty); 5686714d8e8SKurt Hackel INIT_LIST_HEAD(&res->recovering); 5696714d8e8SKurt Hackel INIT_LIST_HEAD(&res->purge); 57029576f8bSSunil Mushran INIT_LIST_HEAD(&res->tracking); 5716714d8e8SKurt Hackel atomic_set(&res->asts_reserved, 0); 5726714d8e8SKurt Hackel res->migration_pending = 0; 573ba2bf218SKurt Hackel res->inflight_locks = 0; 574ac4fef4dSXue jiufei res->inflight_assert_workers = 0; 5756714d8e8SKurt Hackel 576b0d4f817SSunil Mushran res->dlm = dlm; 577b0d4f817SSunil Mushran 5786714d8e8SKurt Hackel kref_init(&res->refs); 5796714d8e8SKurt Hackel 5806800791aSSunil Mushran atomic_inc(&dlm->res_tot_count); 5816800791aSSunil Mushran atomic_inc(&dlm->res_cur_count); 5826800791aSSunil Mushran 5836714d8e8SKurt Hackel /* just for consistency */ 5846714d8e8SKurt Hackel spin_lock(&res->spinlock); 5856714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN); 5866714d8e8SKurt Hackel spin_unlock(&res->spinlock); 5876714d8e8SKurt Hackel 5886714d8e8SKurt Hackel res->state = DLM_LOCK_RES_IN_PROGRESS; 5896714d8e8SKurt Hackel 5906714d8e8SKurt Hackel res->last_used = 0; 5916714d8e8SKurt Hackel 59218c6ac38SSunil Mushran spin_lock(&dlm->spinlock); 59329576f8bSSunil Mushran list_add_tail(&res->tracking, &dlm->tracking_list); 59418c6ac38SSunil Mushran spin_unlock(&dlm->spinlock); 59529576f8bSSunil Mushran 5966714d8e8SKurt Hackel memset(res->lvb, 0, DLM_LVB_LEN); 597ba2bf218SKurt Hackel memset(res->refmap, 0, sizeof(res->refmap)); 5986714d8e8SKurt Hackel } 5996714d8e8SKurt Hackel 6006714d8e8SKurt Hackel struct dlm_lock_resource *dlm_new_lockres(struct dlm_ctxt *dlm, 6016714d8e8SKurt Hackel const char *name, 6026714d8e8SKurt Hackel unsigned int namelen) 6036714d8e8SKurt Hackel { 604724bdca9SSunil Mushran struct dlm_lock_resource *res = NULL; 6056714d8e8SKurt Hackel 6063914ed0cSJulia Lawall res = kmem_cache_zalloc(dlm_lockres_cache, GFP_NOFS); 6076714d8e8SKurt Hackel if (!res) 608724bdca9SSunil Mushran goto error; 6096714d8e8SKurt Hackel 6103914ed0cSJulia Lawall res->lockname.name = kmem_cache_zalloc(dlm_lockname_cache, GFP_NOFS); 611724bdca9SSunil Mushran if (!res->lockname.name) 612724bdca9SSunil Mushran goto error; 6136714d8e8SKurt Hackel 6146714d8e8SKurt Hackel dlm_init_lockres(dlm, res, name, namelen); 6156714d8e8SKurt Hackel return res; 616724bdca9SSunil Mushran 617724bdca9SSunil Mushran error: 618724bdca9SSunil Mushran if (res) 619724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res); 620724bdca9SSunil Mushran return NULL; 6216714d8e8SKurt Hackel } 6226714d8e8SKurt Hackel 6238d400b81SSunil Mushran void dlm_lockres_set_refmap_bit(struct dlm_ctxt *dlm, 6248d400b81SSunil Mushran struct dlm_lock_resource *res, int bit) 625ba2bf218SKurt Hackel { 6268d400b81SSunil Mushran assert_spin_locked(&res->spinlock); 6278d400b81SSunil Mushran 6288d400b81SSunil Mushran mlog(0, "res %.*s, set node %u, %ps()\n", res->lockname.len, 6298d400b81SSunil Mushran res->lockname.name, bit, __builtin_return_address(0)); 6308d400b81SSunil Mushran 6318d400b81SSunil Mushran set_bit(bit, res->refmap); 6328d400b81SSunil Mushran } 6338d400b81SSunil Mushran 6348d400b81SSunil Mushran void dlm_lockres_clear_refmap_bit(struct dlm_ctxt *dlm, 6358d400b81SSunil Mushran struct dlm_lock_resource *res, int bit) 6368d400b81SSunil Mushran { 6378d400b81SSunil Mushran assert_spin_locked(&res->spinlock); 6388d400b81SSunil Mushran 6398d400b81SSunil Mushran mlog(0, "res %.*s, clr node %u, %ps()\n", res->lockname.len, 6408d400b81SSunil Mushran res->lockname.name, bit, __builtin_return_address(0)); 6418d400b81SSunil Mushran 6428d400b81SSunil Mushran clear_bit(bit, res->refmap); 6438d400b81SSunil Mushran } 6448d400b81SSunil Mushran 6455760a97cSJoseph Qi static void __dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm, 6468d400b81SSunil Mushran struct dlm_lock_resource *res) 6478d400b81SSunil Mushran { 648ba2bf218SKurt Hackel res->inflight_locks++; 649ff0a522eSSunil Mushran 6508d400b81SSunil Mushran mlog(0, "%s: res %.*s, inflight++: now %u, %ps()\n", dlm->name, 6518d400b81SSunil Mushran res->lockname.len, res->lockname.name, res->inflight_locks, 6528d400b81SSunil Mushran __builtin_return_address(0)); 653ba2bf218SKurt Hackel } 654ba2bf218SKurt Hackel 6555760a97cSJoseph Qi void dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm, 6565760a97cSJoseph Qi struct dlm_lock_resource *res) 6575760a97cSJoseph Qi { 6585760a97cSJoseph Qi assert_spin_locked(&res->spinlock); 6595760a97cSJoseph Qi __dlm_lockres_grab_inflight_ref(dlm, res); 6605760a97cSJoseph Qi } 6615760a97cSJoseph Qi 6628d400b81SSunil Mushran void dlm_lockres_drop_inflight_ref(struct dlm_ctxt *dlm, 6638d400b81SSunil Mushran struct dlm_lock_resource *res) 664ba2bf218SKurt Hackel { 665ba2bf218SKurt Hackel assert_spin_locked(&res->spinlock); 666ba2bf218SKurt Hackel 667ba2bf218SKurt Hackel BUG_ON(res->inflight_locks == 0); 6688d400b81SSunil Mushran 669ba2bf218SKurt Hackel res->inflight_locks--; 670ff0a522eSSunil Mushran 6718d400b81SSunil Mushran mlog(0, "%s: res %.*s, inflight--: now %u, %ps()\n", dlm->name, 6728d400b81SSunil Mushran res->lockname.len, res->lockname.name, res->inflight_locks, 6738d400b81SSunil Mushran __builtin_return_address(0)); 6748d400b81SSunil Mushran 675ba2bf218SKurt Hackel wake_up(&res->wq); 676ba2bf218SKurt Hackel } 677ba2bf218SKurt Hackel 678ac4fef4dSXue jiufei void __dlm_lockres_grab_inflight_worker(struct dlm_ctxt *dlm, 679ac4fef4dSXue jiufei struct dlm_lock_resource *res) 680ac4fef4dSXue jiufei { 681ac4fef4dSXue jiufei assert_spin_locked(&res->spinlock); 682ac4fef4dSXue jiufei res->inflight_assert_workers++; 683ac4fef4dSXue jiufei mlog(0, "%s:%.*s: inflight assert worker++: now %u\n", 684ac4fef4dSXue jiufei dlm->name, res->lockname.len, res->lockname.name, 685ac4fef4dSXue jiufei res->inflight_assert_workers); 686ac4fef4dSXue jiufei } 687ac4fef4dSXue jiufei 688ac4fef4dSXue jiufei static void __dlm_lockres_drop_inflight_worker(struct dlm_ctxt *dlm, 689ac4fef4dSXue jiufei struct dlm_lock_resource *res) 690ac4fef4dSXue jiufei { 691ac4fef4dSXue jiufei assert_spin_locked(&res->spinlock); 692ac4fef4dSXue jiufei BUG_ON(res->inflight_assert_workers == 0); 693ac4fef4dSXue jiufei res->inflight_assert_workers--; 694ac4fef4dSXue jiufei mlog(0, "%s:%.*s: inflight assert worker--: now %u\n", 695ac4fef4dSXue jiufei dlm->name, res->lockname.len, res->lockname.name, 696ac4fef4dSXue jiufei res->inflight_assert_workers); 697ac4fef4dSXue jiufei } 698ac4fef4dSXue jiufei 699ac4fef4dSXue jiufei static void dlm_lockres_drop_inflight_worker(struct dlm_ctxt *dlm, 700ac4fef4dSXue jiufei struct dlm_lock_resource *res) 701ac4fef4dSXue jiufei { 702ac4fef4dSXue jiufei spin_lock(&res->spinlock); 703ac4fef4dSXue jiufei __dlm_lockres_drop_inflight_worker(dlm, res); 704ac4fef4dSXue jiufei spin_unlock(&res->spinlock); 705ac4fef4dSXue jiufei } 706ac4fef4dSXue jiufei 7076714d8e8SKurt Hackel /* 7086714d8e8SKurt Hackel * lookup a lock resource by name. 7096714d8e8SKurt Hackel * may already exist in the hashtable. 7106714d8e8SKurt Hackel * lockid is null terminated 7116714d8e8SKurt Hackel * 7126714d8e8SKurt Hackel * if not, allocate enough for the lockres and for 7136714d8e8SKurt Hackel * the temporary structure used in doing the mastering. 7146714d8e8SKurt Hackel * 7156714d8e8SKurt Hackel * also, do a lookup in the dlm->master_list to see 7166714d8e8SKurt Hackel * if another node has begun mastering the same lock. 7176714d8e8SKurt Hackel * if so, there should be a block entry in there 7186714d8e8SKurt Hackel * for this name, and we should *not* attempt to master 7196714d8e8SKurt Hackel * the lock here. need to wait around for that node 7206714d8e8SKurt Hackel * to assert_master (or die). 7216714d8e8SKurt Hackel * 7226714d8e8SKurt Hackel */ 7236714d8e8SKurt Hackel struct dlm_lock_resource * dlm_get_lock_resource(struct dlm_ctxt *dlm, 7246714d8e8SKurt Hackel const char *lockid, 7253384f3dfSMark Fasheh int namelen, 7266714d8e8SKurt Hackel int flags) 7276714d8e8SKurt Hackel { 7286714d8e8SKurt Hackel struct dlm_lock_resource *tmpres=NULL, *res=NULL; 7296714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 7306714d8e8SKurt Hackel struct dlm_master_list_entry *alloc_mle = NULL; 7316714d8e8SKurt Hackel int blocked = 0; 7326714d8e8SKurt Hackel int ret, nodenum; 7336714d8e8SKurt Hackel struct dlm_node_iter iter; 7343384f3dfSMark Fasheh unsigned int hash; 7356714d8e8SKurt Hackel int tries = 0; 736c03872f5SKurt Hackel int bit, wait_on_recovery = 0; 7376714d8e8SKurt Hackel 7386714d8e8SKurt Hackel BUG_ON(!lockid); 7396714d8e8SKurt Hackel 740a3d33291SMark Fasheh hash = dlm_lockid_hash(lockid, namelen); 7416714d8e8SKurt Hackel 7426714d8e8SKurt Hackel mlog(0, "get lockres %s (len %d)\n", lockid, namelen); 7436714d8e8SKurt Hackel 7446714d8e8SKurt Hackel lookup: 7456714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 746ba2bf218SKurt Hackel tmpres = __dlm_lookup_lockres_full(dlm, lockid, namelen, hash); 7476714d8e8SKurt Hackel if (tmpres) { 7487b791d68SSunil Mushran spin_unlock(&dlm->spinlock); 749ba2bf218SKurt Hackel spin_lock(&tmpres->spinlock); 750b1432a2aSJunxiao Bi 751b1432a2aSJunxiao Bi /* 752b1432a2aSJunxiao Bi * Right after dlm spinlock was released, dlm_thread could have 753b1432a2aSJunxiao Bi * purged the lockres. Check if lockres got unhashed. If so 754b1432a2aSJunxiao Bi * start over. 755b1432a2aSJunxiao Bi */ 756b1432a2aSJunxiao Bi if (hlist_unhashed(&tmpres->hash_node)) { 757b1432a2aSJunxiao Bi spin_unlock(&tmpres->spinlock); 758b1432a2aSJunxiao Bi dlm_lockres_put(tmpres); 759b1432a2aSJunxiao Bi tmpres = NULL; 760b1432a2aSJunxiao Bi goto lookup; 761b1432a2aSJunxiao Bi } 762b1432a2aSJunxiao Bi 763ff0a522eSSunil Mushran /* Wait on the thread that is mastering the resource */ 7647b791d68SSunil Mushran if (tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN) { 7657b791d68SSunil Mushran __dlm_wait_on_lockres(tmpres); 7667b791d68SSunil Mushran BUG_ON(tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN); 767ba2bf218SKurt Hackel spin_unlock(&tmpres->spinlock); 768ba2bf218SKurt Hackel dlm_lockres_put(tmpres); 769ba2bf218SKurt Hackel tmpres = NULL; 770ba2bf218SKurt Hackel goto lookup; 771ba2bf218SKurt Hackel } 772ba2bf218SKurt Hackel 773ff0a522eSSunil Mushran /* Wait on the resource purge to complete before continuing */ 774ff0a522eSSunil Mushran if (tmpres->state & DLM_LOCK_RES_DROPPING_REF) { 775ff0a522eSSunil Mushran BUG_ON(tmpres->owner == dlm->node_num); 776ff0a522eSSunil Mushran __dlm_wait_on_lockres_flags(tmpres, 777ff0a522eSSunil Mushran DLM_LOCK_RES_DROPPING_REF); 778ff0a522eSSunil Mushran spin_unlock(&tmpres->spinlock); 779ff0a522eSSunil Mushran dlm_lockres_put(tmpres); 780ff0a522eSSunil Mushran tmpres = NULL; 781ff0a522eSSunil Mushran goto lookup; 782ff0a522eSSunil Mushran } 783ff0a522eSSunil Mushran 784ff0a522eSSunil Mushran /* Grab inflight ref to pin the resource */ 785ff0a522eSSunil Mushran dlm_lockres_grab_inflight_ref(dlm, tmpres); 786ff0a522eSSunil Mushran 787ff0a522eSSunil Mushran spin_unlock(&tmpres->spinlock); 788f57a22ddSYiwen Jiang if (res) { 789f57a22ddSYiwen Jiang spin_lock(&dlm->track_lock); 790f57a22ddSYiwen Jiang if (!list_empty(&res->tracking)) 791f57a22ddSYiwen Jiang list_del_init(&res->tracking); 792f57a22ddSYiwen Jiang else 793f57a22ddSYiwen Jiang mlog(ML_ERROR, "Resource %.*s not " 794f57a22ddSYiwen Jiang "on the Tracking list\n", 795f57a22ddSYiwen Jiang res->lockname.len, 796f57a22ddSYiwen Jiang res->lockname.name); 797f57a22ddSYiwen Jiang spin_unlock(&dlm->track_lock); 7986714d8e8SKurt Hackel dlm_lockres_put(res); 799f57a22ddSYiwen Jiang } 8006714d8e8SKurt Hackel res = tmpres; 8016714d8e8SKurt Hackel goto leave; 8026714d8e8SKurt Hackel } 8036714d8e8SKurt Hackel 8046714d8e8SKurt Hackel if (!res) { 8056714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 8066714d8e8SKurt Hackel mlog(0, "allocating a new resource\n"); 8076714d8e8SKurt Hackel /* nothing found and we need to allocate one. */ 8083914ed0cSJulia Lawall alloc_mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 8096714d8e8SKurt Hackel if (!alloc_mle) 8106714d8e8SKurt Hackel goto leave; 8116714d8e8SKurt Hackel res = dlm_new_lockres(dlm, lockid, namelen); 8126714d8e8SKurt Hackel if (!res) 8136714d8e8SKurt Hackel goto leave; 8146714d8e8SKurt Hackel goto lookup; 8156714d8e8SKurt Hackel } 8166714d8e8SKurt Hackel 8176714d8e8SKurt Hackel mlog(0, "no lockres found, allocated our own: %p\n", res); 8186714d8e8SKurt Hackel 8196714d8e8SKurt Hackel if (flags & LKM_LOCAL) { 8206714d8e8SKurt Hackel /* caller knows it's safe to assume it's not mastered elsewhere 8216714d8e8SKurt Hackel * DONE! return right away */ 8226714d8e8SKurt Hackel spin_lock(&res->spinlock); 8236714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, dlm->node_num); 8246714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res); 825ba2bf218SKurt Hackel dlm_lockres_grab_inflight_ref(dlm, res); 8266714d8e8SKurt Hackel spin_unlock(&res->spinlock); 8276714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 8286714d8e8SKurt Hackel /* lockres still marked IN_PROGRESS */ 8296714d8e8SKurt Hackel goto wake_waiters; 8306714d8e8SKurt Hackel } 8316714d8e8SKurt Hackel 8326714d8e8SKurt Hackel /* check master list to see if another node has started mastering it */ 8336714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 8346714d8e8SKurt Hackel 8356714d8e8SKurt Hackel /* if we found a block, wait for lock to be mastered by another node */ 8366714d8e8SKurt Hackel blocked = dlm_find_mle(dlm, &mle, (char *)lockid, namelen); 8376714d8e8SKurt Hackel if (blocked) { 838ba2bf218SKurt Hackel int mig; 8396714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) { 8406714d8e8SKurt Hackel mlog(ML_ERROR, "master entry for nonexistent lock!\n"); 8416714d8e8SKurt Hackel BUG(); 842ba2bf218SKurt Hackel } 843ba2bf218SKurt Hackel mig = (mle->type == DLM_MLE_MIGRATION); 844ba2bf218SKurt Hackel /* if there is a migration in progress, let the migration 845ba2bf218SKurt Hackel * finish before continuing. we can wait for the absence 846ba2bf218SKurt Hackel * of the MIGRATION mle: either the migrate finished or 847ba2bf218SKurt Hackel * one of the nodes died and the mle was cleaned up. 848ba2bf218SKurt Hackel * if there is a BLOCK here, but it already has a master 849ba2bf218SKurt Hackel * set, we are too late. the master does not have a ref 850ba2bf218SKurt Hackel * for us in the refmap. detach the mle and drop it. 851ba2bf218SKurt Hackel * either way, go back to the top and start over. */ 852ba2bf218SKurt Hackel if (mig || mle->master != O2NM_MAX_NODES) { 853ba2bf218SKurt Hackel BUG_ON(mig && mle->master == dlm->node_num); 854ba2bf218SKurt Hackel /* we arrived too late. the master does not 855ba2bf218SKurt Hackel * have a ref for us. retry. */ 856ba2bf218SKurt Hackel mlog(0, "%s:%.*s: late on %s\n", 857ba2bf218SKurt Hackel dlm->name, namelen, lockid, 858ba2bf218SKurt Hackel mig ? "MIGRATION" : "BLOCK"); 8596714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 8606714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 8616714d8e8SKurt Hackel 8626714d8e8SKurt Hackel /* master is known, detach */ 863ba2bf218SKurt Hackel if (!mig) 8646714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 8656714d8e8SKurt Hackel dlm_put_mle(mle); 8666714d8e8SKurt Hackel mle = NULL; 86725985edcSLucas De Marchi /* this is lame, but we can't wait on either 868ba2bf218SKurt Hackel * the mle or lockres waitqueue here */ 869ba2bf218SKurt Hackel if (mig) 870ba2bf218SKurt Hackel msleep(100); 871ba2bf218SKurt Hackel goto lookup; 8726714d8e8SKurt Hackel } 8736714d8e8SKurt Hackel } else { 8746714d8e8SKurt Hackel /* go ahead and try to master lock on this node */ 8756714d8e8SKurt Hackel mle = alloc_mle; 8766714d8e8SKurt Hackel /* make sure this does not get freed below */ 8776714d8e8SKurt Hackel alloc_mle = NULL; 8786714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MASTER, dlm, res, NULL, 0); 8796714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map); 8801c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 881c03872f5SKurt Hackel 882c03872f5SKurt Hackel /* still holding the dlm spinlock, check the recovery map 883c03872f5SKurt Hackel * to see if there are any nodes that still need to be 884c03872f5SKurt Hackel * considered. these will not appear in the mle nodemap 885c03872f5SKurt Hackel * but they might own this lockres. wait on them. */ 886c03872f5SKurt Hackel bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); 887c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) { 8888decab3cSSunil Mushran mlog(0, "%s: res %.*s, At least one node (%d) " 8898decab3cSSunil Mushran "to recover before lock mastery can begin\n", 890c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit); 891c03872f5SKurt Hackel wait_on_recovery = 1; 892c03872f5SKurt Hackel } 8936714d8e8SKurt Hackel } 8946714d8e8SKurt Hackel 8956714d8e8SKurt Hackel /* at this point there is either a DLM_MLE_BLOCK or a 8966714d8e8SKurt Hackel * DLM_MLE_MASTER on the master list, so it's safe to add the 8976714d8e8SKurt Hackel * lockres to the hashtable. anyone who finds the lock will 8986714d8e8SKurt Hackel * still have to wait on the IN_PROGRESS. */ 8996714d8e8SKurt Hackel 9006714d8e8SKurt Hackel /* finally add the lockres to its hash bucket */ 9016714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res); 9028d400b81SSunil Mushran 9035760a97cSJoseph Qi /* since this lockres is new it doesn't not require the spinlock */ 9045760a97cSJoseph Qi __dlm_lockres_grab_inflight_ref(dlm, res); 905ba2bf218SKurt Hackel 9066714d8e8SKurt Hackel /* get an extra ref on the mle in case this is a BLOCK 9076714d8e8SKurt Hackel * if so, the creator of the BLOCK may try to put the last 9086714d8e8SKurt Hackel * ref at this time in the assert master handler, so we 9096714d8e8SKurt Hackel * need an extra one to keep from a bad ptr deref. */ 910a2bf0477SKurt Hackel dlm_get_mle_inuse(mle); 9116714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 9126714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 9136714d8e8SKurt Hackel 914e7e69eb3SKurt Hackel redo_request: 915c03872f5SKurt Hackel while (wait_on_recovery) { 916c03872f5SKurt Hackel /* any cluster changes that occurred after dropping the 917c03872f5SKurt Hackel * dlm spinlock would be detectable be a change on the mle, 918c03872f5SKurt Hackel * so we only need to clear out the recovery map once. */ 919c03872f5SKurt Hackel if (dlm_is_recovery_lock(lockid, namelen)) { 9208decab3cSSunil Mushran mlog(0, "%s: Recovery map is not empty, but must " 9218decab3cSSunil Mushran "master $RECOVERY lock now\n", dlm->name); 922c03872f5SKurt Hackel if (!dlm_pre_master_reco_lockres(dlm, res)) 923c03872f5SKurt Hackel wait_on_recovery = 0; 924c03872f5SKurt Hackel else { 925c03872f5SKurt Hackel mlog(0, "%s: waiting 500ms for heartbeat state " 926c03872f5SKurt Hackel "change\n", dlm->name); 927c03872f5SKurt Hackel msleep(500); 928c03872f5SKurt Hackel } 929c03872f5SKurt Hackel continue; 930c03872f5SKurt Hackel } 931c03872f5SKurt Hackel 932c03872f5SKurt Hackel dlm_kick_recovery_thread(dlm); 933aa087b84SKurt Hackel msleep(1000); 934c03872f5SKurt Hackel dlm_wait_for_recovery(dlm); 935c03872f5SKurt Hackel 936c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 937c03872f5SKurt Hackel bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); 938c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) { 9398decab3cSSunil Mushran mlog(0, "%s: res %.*s, At least one node (%d) " 9408decab3cSSunil Mushran "to recover before lock mastery can begin\n", 941c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit); 942c03872f5SKurt Hackel wait_on_recovery = 1; 943c03872f5SKurt Hackel } else 944c03872f5SKurt Hackel wait_on_recovery = 0; 945c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 946b7084ab5SKurt Hackel 947b7084ab5SKurt Hackel if (wait_on_recovery) 948b7084ab5SKurt Hackel dlm_wait_for_node_recovery(dlm, bit, 10000); 949c03872f5SKurt Hackel } 950c03872f5SKurt Hackel 9516714d8e8SKurt Hackel /* must wait for lock to be mastered elsewhere */ 9526714d8e8SKurt Hackel if (blocked) 9536714d8e8SKurt Hackel goto wait; 9546714d8e8SKurt Hackel 9556714d8e8SKurt Hackel ret = -EINVAL; 9566714d8e8SKurt Hackel dlm_node_iter_init(mle->vote_map, &iter); 9576714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) { 958ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, nodenum); 9596714d8e8SKurt Hackel if (ret < 0) 9606714d8e8SKurt Hackel mlog_errno(ret); 9616714d8e8SKurt Hackel if (mle->master != O2NM_MAX_NODES) { 9626714d8e8SKurt Hackel /* found a master ! */ 9639c6510a5SKurt Hackel if (mle->master <= nodenum) 9646714d8e8SKurt Hackel break; 9659c6510a5SKurt Hackel /* if our master request has not reached the master 9669c6510a5SKurt Hackel * yet, keep going until it does. this is how the 9679c6510a5SKurt Hackel * master will know that asserts are needed back to 9689c6510a5SKurt Hackel * the lower nodes. */ 9698decab3cSSunil Mushran mlog(0, "%s: res %.*s, Requests only up to %u but " 9708decab3cSSunil Mushran "master is %u, keep going\n", dlm->name, namelen, 9719c6510a5SKurt Hackel lockid, nodenum, mle->master); 9726714d8e8SKurt Hackel } 9736714d8e8SKurt Hackel } 9746714d8e8SKurt Hackel 9756714d8e8SKurt Hackel wait: 9766714d8e8SKurt Hackel /* keep going until the response map includes all nodes */ 9776714d8e8SKurt Hackel ret = dlm_wait_for_lock_mastery(dlm, res, mle, &blocked); 9786714d8e8SKurt Hackel if (ret < 0) { 979e7e69eb3SKurt Hackel wait_on_recovery = 1; 9808decab3cSSunil Mushran mlog(0, "%s: res %.*s, Node map changed, redo the master " 9818decab3cSSunil Mushran "request now, blocked=%d\n", dlm->name, res->lockname.len, 9826714d8e8SKurt Hackel res->lockname.name, blocked); 9836714d8e8SKurt Hackel if (++tries > 20) { 9848decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, Spinning on " 9856714d8e8SKurt Hackel "dlm_wait_for_lock_mastery, blocked = %d\n", 9866714d8e8SKurt Hackel dlm->name, res->lockname.len, 9876714d8e8SKurt Hackel res->lockname.name, blocked); 9886714d8e8SKurt Hackel dlm_print_one_lock_resource(res); 9898a9343faSMark Fasheh dlm_print_one_mle(mle); 9906714d8e8SKurt Hackel tries = 0; 9916714d8e8SKurt Hackel } 9926714d8e8SKurt Hackel goto redo_request; 9936714d8e8SKurt Hackel } 9946714d8e8SKurt Hackel 9958decab3cSSunil Mushran mlog(0, "%s: res %.*s, Mastered by %u\n", dlm->name, res->lockname.len, 9968decab3cSSunil Mushran res->lockname.name, res->owner); 9976714d8e8SKurt Hackel /* make sure we never continue without this */ 9986714d8e8SKurt Hackel BUG_ON(res->owner == O2NM_MAX_NODES); 9996714d8e8SKurt Hackel 10006714d8e8SKurt Hackel /* master is known, detach if not already detached */ 10016714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 10026714d8e8SKurt Hackel dlm_put_mle(mle); 10036714d8e8SKurt Hackel /* put the extra ref */ 1004a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 10056714d8e8SKurt Hackel 10066714d8e8SKurt Hackel wake_waiters: 10076714d8e8SKurt Hackel spin_lock(&res->spinlock); 10086714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_IN_PROGRESS; 10096714d8e8SKurt Hackel spin_unlock(&res->spinlock); 10106714d8e8SKurt Hackel wake_up(&res->wq); 10116714d8e8SKurt Hackel 10126714d8e8SKurt Hackel leave: 10136714d8e8SKurt Hackel /* need to free the unused mle */ 10146714d8e8SKurt Hackel if (alloc_mle) 10156714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, alloc_mle); 10166714d8e8SKurt Hackel 10176714d8e8SKurt Hackel return res; 10186714d8e8SKurt Hackel } 10196714d8e8SKurt Hackel 10206714d8e8SKurt Hackel 10216714d8e8SKurt Hackel #define DLM_MASTERY_TIMEOUT_MS 5000 10226714d8e8SKurt Hackel 10236714d8e8SKurt Hackel static int dlm_wait_for_lock_mastery(struct dlm_ctxt *dlm, 10246714d8e8SKurt Hackel struct dlm_lock_resource *res, 10256714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 10266714d8e8SKurt Hackel int *blocked) 10276714d8e8SKurt Hackel { 10286714d8e8SKurt Hackel u8 m; 10296714d8e8SKurt Hackel int ret, bit; 10306714d8e8SKurt Hackel int map_changed, voting_done; 10316714d8e8SKurt Hackel int assert, sleep; 10326714d8e8SKurt Hackel 10336714d8e8SKurt Hackel recheck: 10346714d8e8SKurt Hackel ret = 0; 10356714d8e8SKurt Hackel assert = 0; 10366714d8e8SKurt Hackel 10376714d8e8SKurt Hackel /* check if another node has already become the owner */ 10386714d8e8SKurt Hackel spin_lock(&res->spinlock); 10396714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 10409c6510a5SKurt Hackel mlog(0, "%s:%.*s: owner is suddenly %u\n", dlm->name, 10419c6510a5SKurt Hackel res->lockname.len, res->lockname.name, res->owner); 10426714d8e8SKurt Hackel spin_unlock(&res->spinlock); 10439c6510a5SKurt Hackel /* this will cause the master to re-assert across 10449c6510a5SKurt Hackel * the whole cluster, freeing up mles */ 1045588e0090SKurt Hackel if (res->owner != dlm->node_num) { 1046ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, res->owner); 10479c6510a5SKurt Hackel if (ret < 0) { 10489c6510a5SKurt Hackel /* give recovery a chance to run */ 10499c6510a5SKurt Hackel mlog(ML_ERROR, "link to %u went down?: %d\n", res->owner, ret); 10509c6510a5SKurt Hackel msleep(500); 10519c6510a5SKurt Hackel goto recheck; 10529c6510a5SKurt Hackel } 1053588e0090SKurt Hackel } 10549c6510a5SKurt Hackel ret = 0; 10556714d8e8SKurt Hackel goto leave; 10566714d8e8SKurt Hackel } 10576714d8e8SKurt Hackel spin_unlock(&res->spinlock); 10586714d8e8SKurt Hackel 10596714d8e8SKurt Hackel spin_lock(&mle->spinlock); 10606714d8e8SKurt Hackel m = mle->master; 10616714d8e8SKurt Hackel map_changed = (memcmp(mle->vote_map, mle->node_map, 10626714d8e8SKurt Hackel sizeof(mle->vote_map)) != 0); 10636714d8e8SKurt Hackel voting_done = (memcmp(mle->vote_map, mle->response_map, 10646714d8e8SKurt Hackel sizeof(mle->vote_map)) == 0); 10656714d8e8SKurt Hackel 10666714d8e8SKurt Hackel /* restart if we hit any errors */ 10676714d8e8SKurt Hackel if (map_changed) { 10686714d8e8SKurt Hackel int b; 10696714d8e8SKurt Hackel mlog(0, "%s: %.*s: node map changed, restarting\n", 10706714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 10716714d8e8SKurt Hackel ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked); 10726714d8e8SKurt Hackel b = (mle->type == DLM_MLE_BLOCK); 10736714d8e8SKurt Hackel if ((*blocked && !b) || (!*blocked && b)) { 10746714d8e8SKurt Hackel mlog(0, "%s:%.*s: status change: old=%d new=%d\n", 10756714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 10766714d8e8SKurt Hackel *blocked, b); 10776714d8e8SKurt Hackel *blocked = b; 10786714d8e8SKurt Hackel } 10796714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 10806714d8e8SKurt Hackel if (ret < 0) { 10816714d8e8SKurt Hackel mlog_errno(ret); 10826714d8e8SKurt Hackel goto leave; 10836714d8e8SKurt Hackel } 10846714d8e8SKurt Hackel mlog(0, "%s:%.*s: restart lock mastery succeeded, " 10856714d8e8SKurt Hackel "rechecking now\n", dlm->name, res->lockname.len, 10866714d8e8SKurt Hackel res->lockname.name); 10876714d8e8SKurt Hackel goto recheck; 1088aa852354SKurt Hackel } else { 1089aa852354SKurt Hackel if (!voting_done) { 1090aa852354SKurt Hackel mlog(0, "map not changed and voting not done " 1091aa852354SKurt Hackel "for %s:%.*s\n", dlm->name, res->lockname.len, 1092aa852354SKurt Hackel res->lockname.name); 1093aa852354SKurt Hackel } 10946714d8e8SKurt Hackel } 10956714d8e8SKurt Hackel 10966714d8e8SKurt Hackel if (m != O2NM_MAX_NODES) { 10976714d8e8SKurt Hackel /* another node has done an assert! 10986714d8e8SKurt Hackel * all done! */ 10996714d8e8SKurt Hackel sleep = 0; 11006714d8e8SKurt Hackel } else { 11016714d8e8SKurt Hackel sleep = 1; 11026714d8e8SKurt Hackel /* have all nodes responded? */ 11036714d8e8SKurt Hackel if (voting_done && !*blocked) { 11046714d8e8SKurt Hackel bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0); 11056714d8e8SKurt Hackel if (dlm->node_num <= bit) { 11066714d8e8SKurt Hackel /* my node number is lowest. 11076714d8e8SKurt Hackel * now tell other nodes that I am 11086714d8e8SKurt Hackel * mastering this. */ 11096714d8e8SKurt Hackel mle->master = dlm->node_num; 1110ba2bf218SKurt Hackel /* ref was grabbed in get_lock_resource 1111ba2bf218SKurt Hackel * will be dropped in dlmlock_master */ 11126714d8e8SKurt Hackel assert = 1; 11136714d8e8SKurt Hackel sleep = 0; 11146714d8e8SKurt Hackel } 11156714d8e8SKurt Hackel /* if voting is done, but we have not received 11166714d8e8SKurt Hackel * an assert master yet, we must sleep */ 11176714d8e8SKurt Hackel } 11186714d8e8SKurt Hackel } 11196714d8e8SKurt Hackel 11206714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 11216714d8e8SKurt Hackel 11226714d8e8SKurt Hackel /* sleep if we haven't finished voting yet */ 11236714d8e8SKurt Hackel if (sleep) { 11246714d8e8SKurt Hackel unsigned long timeo = msecs_to_jiffies(DLM_MASTERY_TIMEOUT_MS); 11256714d8e8SKurt Hackel 11266714d8e8SKurt Hackel /* 11276714d8e8SKurt Hackel if (atomic_read(&mle->mle_refs.refcount) < 2) 11286714d8e8SKurt Hackel mlog(ML_ERROR, "mle (%p) refs=%d, name=%.*s\n", mle, 11296714d8e8SKurt Hackel atomic_read(&mle->mle_refs.refcount), 11306714d8e8SKurt Hackel res->lockname.len, res->lockname.name); 11316714d8e8SKurt Hackel */ 11326714d8e8SKurt Hackel atomic_set(&mle->woken, 0); 11336714d8e8SKurt Hackel (void)wait_event_timeout(mle->wq, 11346714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1), 11356714d8e8SKurt Hackel timeo); 11366714d8e8SKurt Hackel if (res->owner == O2NM_MAX_NODES) { 1137ba2bf218SKurt Hackel mlog(0, "%s:%.*s: waiting again\n", dlm->name, 1138ba2bf218SKurt Hackel res->lockname.len, res->lockname.name); 11396714d8e8SKurt Hackel goto recheck; 11406714d8e8SKurt Hackel } 11416714d8e8SKurt Hackel mlog(0, "done waiting, master is %u\n", res->owner); 11426714d8e8SKurt Hackel ret = 0; 11436714d8e8SKurt Hackel goto leave; 11446714d8e8SKurt Hackel } 11456714d8e8SKurt Hackel 11466714d8e8SKurt Hackel ret = 0; /* done */ 11476714d8e8SKurt Hackel if (assert) { 11486714d8e8SKurt Hackel m = dlm->node_num; 11496714d8e8SKurt Hackel mlog(0, "about to master %.*s here, this=%u\n", 11506714d8e8SKurt Hackel res->lockname.len, res->lockname.name, m); 1151ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, mle->vote_map, 0); 11526714d8e8SKurt Hackel if (ret) { 11536714d8e8SKurt Hackel /* This is a failure in the network path, 11546714d8e8SKurt Hackel * not in the response to the assert_master 11556714d8e8SKurt Hackel * (any nonzero response is a BUG on this node). 11566714d8e8SKurt Hackel * Most likely a socket just got disconnected 11576714d8e8SKurt Hackel * due to node death. */ 11586714d8e8SKurt Hackel mlog_errno(ret); 11596714d8e8SKurt Hackel } 11606714d8e8SKurt Hackel /* no longer need to restart lock mastery. 11616714d8e8SKurt Hackel * all living nodes have been contacted. */ 11626714d8e8SKurt Hackel ret = 0; 11636714d8e8SKurt Hackel } 11646714d8e8SKurt Hackel 11656714d8e8SKurt Hackel /* set the lockres owner */ 11666714d8e8SKurt Hackel spin_lock(&res->spinlock); 1167ba2bf218SKurt Hackel /* mastery reference obtained either during 1168ba2bf218SKurt Hackel * assert_master_handler or in get_lock_resource */ 11696714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, m); 11706714d8e8SKurt Hackel spin_unlock(&res->spinlock); 11716714d8e8SKurt Hackel 11726714d8e8SKurt Hackel leave: 11736714d8e8SKurt Hackel return ret; 11746714d8e8SKurt Hackel } 11756714d8e8SKurt Hackel 11766714d8e8SKurt Hackel struct dlm_bitmap_diff_iter 11776714d8e8SKurt Hackel { 11786714d8e8SKurt Hackel int curnode; 11796714d8e8SKurt Hackel unsigned long *orig_bm; 11806714d8e8SKurt Hackel unsigned long *cur_bm; 11816714d8e8SKurt Hackel unsigned long diff_bm[BITS_TO_LONGS(O2NM_MAX_NODES)]; 11826714d8e8SKurt Hackel }; 11836714d8e8SKurt Hackel 11846714d8e8SKurt Hackel enum dlm_node_state_change 11856714d8e8SKurt Hackel { 11866714d8e8SKurt Hackel NODE_DOWN = -1, 11876714d8e8SKurt Hackel NODE_NO_CHANGE = 0, 11886714d8e8SKurt Hackel NODE_UP 11896714d8e8SKurt Hackel }; 11906714d8e8SKurt Hackel 11916714d8e8SKurt Hackel static void dlm_bitmap_diff_iter_init(struct dlm_bitmap_diff_iter *iter, 11926714d8e8SKurt Hackel unsigned long *orig_bm, 11936714d8e8SKurt Hackel unsigned long *cur_bm) 11946714d8e8SKurt Hackel { 11956714d8e8SKurt Hackel unsigned long p1, p2; 11966714d8e8SKurt Hackel int i; 11976714d8e8SKurt Hackel 11986714d8e8SKurt Hackel iter->curnode = -1; 11996714d8e8SKurt Hackel iter->orig_bm = orig_bm; 12006714d8e8SKurt Hackel iter->cur_bm = cur_bm; 12016714d8e8SKurt Hackel 12026714d8e8SKurt Hackel for (i = 0; i < BITS_TO_LONGS(O2NM_MAX_NODES); i++) { 12036714d8e8SKurt Hackel p1 = *(iter->orig_bm + i); 12046714d8e8SKurt Hackel p2 = *(iter->cur_bm + i); 12056714d8e8SKurt Hackel iter->diff_bm[i] = (p1 & ~p2) | (p2 & ~p1); 12066714d8e8SKurt Hackel } 12076714d8e8SKurt Hackel } 12086714d8e8SKurt Hackel 12096714d8e8SKurt Hackel static int dlm_bitmap_diff_iter_next(struct dlm_bitmap_diff_iter *iter, 12106714d8e8SKurt Hackel enum dlm_node_state_change *state) 12116714d8e8SKurt Hackel { 12126714d8e8SKurt Hackel int bit; 12136714d8e8SKurt Hackel 12146714d8e8SKurt Hackel if (iter->curnode >= O2NM_MAX_NODES) 12156714d8e8SKurt Hackel return -ENOENT; 12166714d8e8SKurt Hackel 12176714d8e8SKurt Hackel bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES, 12186714d8e8SKurt Hackel iter->curnode+1); 12196714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) { 12206714d8e8SKurt Hackel iter->curnode = O2NM_MAX_NODES; 12216714d8e8SKurt Hackel return -ENOENT; 12226714d8e8SKurt Hackel } 12236714d8e8SKurt Hackel 12246714d8e8SKurt Hackel /* if it was there in the original then this node died */ 12256714d8e8SKurt Hackel if (test_bit(bit, iter->orig_bm)) 12266714d8e8SKurt Hackel *state = NODE_DOWN; 12276714d8e8SKurt Hackel else 12286714d8e8SKurt Hackel *state = NODE_UP; 12296714d8e8SKurt Hackel 12306714d8e8SKurt Hackel iter->curnode = bit; 12316714d8e8SKurt Hackel return bit; 12326714d8e8SKurt Hackel } 12336714d8e8SKurt Hackel 12346714d8e8SKurt Hackel 12356714d8e8SKurt Hackel static int dlm_restart_lock_mastery(struct dlm_ctxt *dlm, 12366714d8e8SKurt Hackel struct dlm_lock_resource *res, 12376714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 12386714d8e8SKurt Hackel int blocked) 12396714d8e8SKurt Hackel { 12406714d8e8SKurt Hackel struct dlm_bitmap_diff_iter bdi; 12416714d8e8SKurt Hackel enum dlm_node_state_change sc; 12426714d8e8SKurt Hackel int node; 12436714d8e8SKurt Hackel int ret = 0; 12446714d8e8SKurt Hackel 12456714d8e8SKurt Hackel mlog(0, "something happened such that the " 12466714d8e8SKurt Hackel "master process may need to be restarted!\n"); 12476714d8e8SKurt Hackel 12486714d8e8SKurt Hackel assert_spin_locked(&mle->spinlock); 12496714d8e8SKurt Hackel 12506714d8e8SKurt Hackel dlm_bitmap_diff_iter_init(&bdi, mle->vote_map, mle->node_map); 12516714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc); 12526714d8e8SKurt Hackel while (node >= 0) { 12536714d8e8SKurt Hackel if (sc == NODE_UP) { 1254e2faea4cSKurt Hackel /* a node came up. clear any old vote from 1255e2faea4cSKurt Hackel * the response map and set it in the vote map 1256e2faea4cSKurt Hackel * then restart the mastery. */ 1257e2faea4cSKurt Hackel mlog(ML_NOTICE, "node %d up while restarting\n", node); 12586714d8e8SKurt Hackel 12596714d8e8SKurt Hackel /* redo the master request, but only for the new node */ 12606714d8e8SKurt Hackel mlog(0, "sending request to new node\n"); 12616714d8e8SKurt Hackel clear_bit(node, mle->response_map); 12626714d8e8SKurt Hackel set_bit(node, mle->vote_map); 12636714d8e8SKurt Hackel } else { 12646714d8e8SKurt Hackel mlog(ML_ERROR, "node down! %d\n", node); 12656714d8e8SKurt Hackel if (blocked) { 12666714d8e8SKurt Hackel int lowest = find_next_bit(mle->maybe_map, 12676714d8e8SKurt Hackel O2NM_MAX_NODES, 0); 12686714d8e8SKurt Hackel 12696714d8e8SKurt Hackel /* act like it was never there */ 12706714d8e8SKurt Hackel clear_bit(node, mle->maybe_map); 12716714d8e8SKurt Hackel 1272e7e69eb3SKurt Hackel if (node == lowest) { 1273e7e69eb3SKurt Hackel mlog(0, "expected master %u died" 1274e7e69eb3SKurt Hackel " while this node was blocked " 1275e7e69eb3SKurt Hackel "waiting on it!\n", node); 12766714d8e8SKurt Hackel lowest = find_next_bit(mle->maybe_map, 12776714d8e8SKurt Hackel O2NM_MAX_NODES, 12786714d8e8SKurt Hackel lowest+1); 12796714d8e8SKurt Hackel if (lowest < O2NM_MAX_NODES) { 1280e7e69eb3SKurt Hackel mlog(0, "%s:%.*s:still " 1281e7e69eb3SKurt Hackel "blocked. waiting on %u " 1282e7e69eb3SKurt Hackel "now\n", dlm->name, 1283e7e69eb3SKurt Hackel res->lockname.len, 1284e7e69eb3SKurt Hackel res->lockname.name, 1285e7e69eb3SKurt Hackel lowest); 1286e7e69eb3SKurt Hackel } else { 1287e7e69eb3SKurt Hackel /* mle is an MLE_BLOCK, but 1288e7e69eb3SKurt Hackel * there is now nothing left to 1289e7e69eb3SKurt Hackel * block on. we need to return 1290e7e69eb3SKurt Hackel * all the way back out and try 1291e7e69eb3SKurt Hackel * again with an MLE_MASTER. 1292e7e69eb3SKurt Hackel * dlm_do_local_recovery_cleanup 1293e7e69eb3SKurt Hackel * has already run, so the mle 1294e7e69eb3SKurt Hackel * refcount is ok */ 1295e7e69eb3SKurt Hackel mlog(0, "%s:%.*s: no " 1296e7e69eb3SKurt Hackel "longer blocking. try to " 1297e7e69eb3SKurt Hackel "master this here\n", 1298e7e69eb3SKurt Hackel dlm->name, 1299e7e69eb3SKurt Hackel res->lockname.len, 1300e7e69eb3SKurt Hackel res->lockname.name); 1301e7e69eb3SKurt Hackel mle->type = DLM_MLE_MASTER; 13027141514bSSunil Mushran mle->mleres = res; 1303e7e69eb3SKurt Hackel } 1304e7e69eb3SKurt Hackel } 13056714d8e8SKurt Hackel } 13066714d8e8SKurt Hackel 1307e7e69eb3SKurt Hackel /* now blank out everything, as if we had never 1308e7e69eb3SKurt Hackel * contacted anyone */ 1309e7e69eb3SKurt Hackel memset(mle->maybe_map, 0, sizeof(mle->maybe_map)); 1310e7e69eb3SKurt Hackel memset(mle->response_map, 0, sizeof(mle->response_map)); 1311e7e69eb3SKurt Hackel /* reset the vote_map to the current node_map */ 13126714d8e8SKurt Hackel memcpy(mle->vote_map, mle->node_map, 13136714d8e8SKurt Hackel sizeof(mle->node_map)); 1314e7e69eb3SKurt Hackel /* put myself into the maybe map */ 1315e7e69eb3SKurt Hackel if (mle->type != DLM_MLE_BLOCK) 13166714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map); 13176714d8e8SKurt Hackel } 13186714d8e8SKurt Hackel ret = -EAGAIN; 13196714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc); 13206714d8e8SKurt Hackel } 13216714d8e8SKurt Hackel return ret; 13226714d8e8SKurt Hackel } 13236714d8e8SKurt Hackel 13246714d8e8SKurt Hackel 13256714d8e8SKurt Hackel /* 13266714d8e8SKurt Hackel * DLM_MASTER_REQUEST_MSG 13276714d8e8SKurt Hackel * 13286714d8e8SKurt Hackel * returns: 0 on success, 13296714d8e8SKurt Hackel * -errno on a network error 13306714d8e8SKurt Hackel * 13316714d8e8SKurt Hackel * on error, the caller should assume the target node is "dead" 13326714d8e8SKurt Hackel * 13336714d8e8SKurt Hackel */ 13346714d8e8SKurt Hackel 1335ba2bf218SKurt Hackel static int dlm_do_master_request(struct dlm_lock_resource *res, 1336ba2bf218SKurt Hackel struct dlm_master_list_entry *mle, int to) 13376714d8e8SKurt Hackel { 13386714d8e8SKurt Hackel struct dlm_ctxt *dlm = mle->dlm; 13396714d8e8SKurt Hackel struct dlm_master_request request; 13406714d8e8SKurt Hackel int ret, response=0, resend; 13416714d8e8SKurt Hackel 13426714d8e8SKurt Hackel memset(&request, 0, sizeof(request)); 13436714d8e8SKurt Hackel request.node_idx = dlm->node_num; 13446714d8e8SKurt Hackel 13456714d8e8SKurt Hackel BUG_ON(mle->type == DLM_MLE_MIGRATION); 13466714d8e8SKurt Hackel 13477141514bSSunil Mushran request.namelen = (u8)mle->mnamelen; 13487141514bSSunil Mushran memcpy(request.name, mle->mname, request.namelen); 13496714d8e8SKurt Hackel 13506714d8e8SKurt Hackel again: 13516714d8e8SKurt Hackel ret = o2net_send_message(DLM_MASTER_REQUEST_MSG, dlm->key, &request, 13526714d8e8SKurt Hackel sizeof(request), to, &response); 13536714d8e8SKurt Hackel if (ret < 0) { 13546714d8e8SKurt Hackel if (ret == -ESRCH) { 13556714d8e8SKurt Hackel /* should never happen */ 13566714d8e8SKurt Hackel mlog(ML_ERROR, "TCP stack not ready!\n"); 13576714d8e8SKurt Hackel BUG(); 13586714d8e8SKurt Hackel } else if (ret == -EINVAL) { 13596714d8e8SKurt Hackel mlog(ML_ERROR, "bad args passed to o2net!\n"); 13606714d8e8SKurt Hackel BUG(); 13616714d8e8SKurt Hackel } else if (ret == -ENOMEM) { 13626714d8e8SKurt Hackel mlog(ML_ERROR, "out of memory while trying to send " 13636714d8e8SKurt Hackel "network message! retrying\n"); 13646714d8e8SKurt Hackel /* this is totally crude */ 13656714d8e8SKurt Hackel msleep(50); 13666714d8e8SKurt Hackel goto again; 13676714d8e8SKurt Hackel } else if (!dlm_is_host_down(ret)) { 13686714d8e8SKurt Hackel /* not a network error. bad. */ 13696714d8e8SKurt Hackel mlog_errno(ret); 13706714d8e8SKurt Hackel mlog(ML_ERROR, "unhandled error!"); 13716714d8e8SKurt Hackel BUG(); 13726714d8e8SKurt Hackel } 13736714d8e8SKurt Hackel /* all other errors should be network errors, 13746714d8e8SKurt Hackel * and likely indicate node death */ 13756714d8e8SKurt Hackel mlog(ML_ERROR, "link to %d went down!\n", to); 13766714d8e8SKurt Hackel goto out; 13776714d8e8SKurt Hackel } 13786714d8e8SKurt Hackel 13796714d8e8SKurt Hackel ret = 0; 13806714d8e8SKurt Hackel resend = 0; 13816714d8e8SKurt Hackel spin_lock(&mle->spinlock); 13826714d8e8SKurt Hackel switch (response) { 13836714d8e8SKurt Hackel case DLM_MASTER_RESP_YES: 13846714d8e8SKurt Hackel set_bit(to, mle->response_map); 13856714d8e8SKurt Hackel mlog(0, "node %u is the master, response=YES\n", to); 1386ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master node %u now knows I have a " 1387ba2bf218SKurt Hackel "reference\n", dlm->name, res->lockname.len, 1388ba2bf218SKurt Hackel res->lockname.name, to); 13896714d8e8SKurt Hackel mle->master = to; 13906714d8e8SKurt Hackel break; 13916714d8e8SKurt Hackel case DLM_MASTER_RESP_NO: 13926714d8e8SKurt Hackel mlog(0, "node %u not master, response=NO\n", to); 13936714d8e8SKurt Hackel set_bit(to, mle->response_map); 13946714d8e8SKurt Hackel break; 13956714d8e8SKurt Hackel case DLM_MASTER_RESP_MAYBE: 13966714d8e8SKurt Hackel mlog(0, "node %u not master, response=MAYBE\n", to); 13976714d8e8SKurt Hackel set_bit(to, mle->response_map); 13986714d8e8SKurt Hackel set_bit(to, mle->maybe_map); 13996714d8e8SKurt Hackel break; 14006714d8e8SKurt Hackel case DLM_MASTER_RESP_ERROR: 14016714d8e8SKurt Hackel mlog(0, "node %u hit an error, resending\n", to); 14026714d8e8SKurt Hackel resend = 1; 14036714d8e8SKurt Hackel response = 0; 14046714d8e8SKurt Hackel break; 14056714d8e8SKurt Hackel default: 14066714d8e8SKurt Hackel mlog(ML_ERROR, "bad response! %u\n", response); 14076714d8e8SKurt Hackel BUG(); 14086714d8e8SKurt Hackel } 14096714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 14106714d8e8SKurt Hackel if (resend) { 14116714d8e8SKurt Hackel /* this is also totally crude */ 14126714d8e8SKurt Hackel msleep(50); 14136714d8e8SKurt Hackel goto again; 14146714d8e8SKurt Hackel } 14156714d8e8SKurt Hackel 14166714d8e8SKurt Hackel out: 14176714d8e8SKurt Hackel return ret; 14186714d8e8SKurt Hackel } 14196714d8e8SKurt Hackel 14206714d8e8SKurt Hackel /* 14216714d8e8SKurt Hackel * locks that can be taken here: 14226714d8e8SKurt Hackel * dlm->spinlock 14236714d8e8SKurt Hackel * res->spinlock 14246714d8e8SKurt Hackel * mle->spinlock 14256714d8e8SKurt Hackel * dlm->master_list 14266714d8e8SKurt Hackel * 14276714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!! 14286714d8e8SKurt Hackel */ 1429d74c9803SKurt Hackel int dlm_master_request_handler(struct o2net_msg *msg, u32 len, void *data, 1430d74c9803SKurt Hackel void **ret_data) 14316714d8e8SKurt Hackel { 14326714d8e8SKurt Hackel u8 response = DLM_MASTER_RESP_MAYBE; 14336714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 14349c6510a5SKurt Hackel struct dlm_lock_resource *res = NULL; 14356714d8e8SKurt Hackel struct dlm_master_request *request = (struct dlm_master_request *) msg->buf; 14366714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *tmpmle = NULL; 14376714d8e8SKurt Hackel char *name; 1438a3d33291SMark Fasheh unsigned int namelen, hash; 14396714d8e8SKurt Hackel int found, ret; 14406714d8e8SKurt Hackel int set_maybe; 14419c6510a5SKurt Hackel int dispatch_assert = 0; 1442012572d4SJoseph Qi int dispatched = 0; 14436714d8e8SKurt Hackel 14446714d8e8SKurt Hackel if (!dlm_grab(dlm)) 14456714d8e8SKurt Hackel return DLM_MASTER_RESP_NO; 14466714d8e8SKurt Hackel 14476714d8e8SKurt Hackel if (!dlm_domain_fully_joined(dlm)) { 14486714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 14496714d8e8SKurt Hackel goto send_response; 14506714d8e8SKurt Hackel } 14516714d8e8SKurt Hackel 14526714d8e8SKurt Hackel name = request->name; 14536714d8e8SKurt Hackel namelen = request->namelen; 1454a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 14556714d8e8SKurt Hackel 14566714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 14576714d8e8SKurt Hackel response = DLM_IVBUFLEN; 14586714d8e8SKurt Hackel goto send_response; 14596714d8e8SKurt Hackel } 14606714d8e8SKurt Hackel 14616714d8e8SKurt Hackel way_up_top: 14626714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 1463a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 14646714d8e8SKurt Hackel if (res) { 14656714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 14666714d8e8SKurt Hackel 14676714d8e8SKurt Hackel /* take care of the easy cases up front */ 14686714d8e8SKurt Hackel spin_lock(&res->spinlock); 1469cb79662bSSrinivas Eeda 1470cb79662bSSrinivas Eeda /* 1471cb79662bSSrinivas Eeda * Right after dlm spinlock was released, dlm_thread could have 1472cb79662bSSrinivas Eeda * purged the lockres. Check if lockres got unhashed. If so 1473cb79662bSSrinivas Eeda * start over. 1474cb79662bSSrinivas Eeda */ 1475cb79662bSSrinivas Eeda if (hlist_unhashed(&res->hash_node)) { 1476cb79662bSSrinivas Eeda spin_unlock(&res->spinlock); 1477cb79662bSSrinivas Eeda dlm_lockres_put(res); 1478cb79662bSSrinivas Eeda goto way_up_top; 1479cb79662bSSrinivas Eeda } 1480cb79662bSSrinivas Eeda 14811cd04dbeSKurt Hackel if (res->state & (DLM_LOCK_RES_RECOVERING| 14821cd04dbeSKurt Hackel DLM_LOCK_RES_MIGRATING)) { 14836714d8e8SKurt Hackel spin_unlock(&res->spinlock); 14846714d8e8SKurt Hackel mlog(0, "returning DLM_MASTER_RESP_ERROR since res is " 14851cd04dbeSKurt Hackel "being recovered/migrated\n"); 14866714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR; 14876714d8e8SKurt Hackel if (mle) 14886714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 14896714d8e8SKurt Hackel goto send_response; 14906714d8e8SKurt Hackel } 14916714d8e8SKurt Hackel 14926714d8e8SKurt Hackel if (res->owner == dlm->node_num) { 14938d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, request->node_idx); 14946714d8e8SKurt Hackel spin_unlock(&res->spinlock); 14956714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES; 14966714d8e8SKurt Hackel if (mle) 14976714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 14986714d8e8SKurt Hackel 14996714d8e8SKurt Hackel /* this node is the owner. 15006714d8e8SKurt Hackel * there is some extra work that needs to 15016714d8e8SKurt Hackel * happen now. the requesting node has 15026714d8e8SKurt Hackel * caused all nodes up to this one to 15036714d8e8SKurt Hackel * create mles. this node now needs to 15046714d8e8SKurt Hackel * go back and clean those up. */ 15059c6510a5SKurt Hackel dispatch_assert = 1; 15066714d8e8SKurt Hackel goto send_response; 15076714d8e8SKurt Hackel } else if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 15086714d8e8SKurt Hackel spin_unlock(&res->spinlock); 15096714d8e8SKurt Hackel // mlog(0, "node %u is the master\n", res->owner); 15106714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15116714d8e8SKurt Hackel if (mle) 15126714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 15136714d8e8SKurt Hackel goto send_response; 15146714d8e8SKurt Hackel } 15156714d8e8SKurt Hackel 15166714d8e8SKurt Hackel /* ok, there is no owner. either this node is 15176714d8e8SKurt Hackel * being blocked, or it is actively trying to 15186714d8e8SKurt Hackel * master this lock. */ 15196714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) { 15206714d8e8SKurt Hackel mlog(ML_ERROR, "lock with no owner should be " 15216714d8e8SKurt Hackel "in-progress!\n"); 15226714d8e8SKurt Hackel BUG(); 15236714d8e8SKurt Hackel } 15246714d8e8SKurt Hackel 15256714d8e8SKurt Hackel // mlog(0, "lockres is in progress...\n"); 15266714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 15276714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen); 15286714d8e8SKurt Hackel if (!found) { 15296714d8e8SKurt Hackel mlog(ML_ERROR, "no mle found for this lock!\n"); 15306714d8e8SKurt Hackel BUG(); 15316714d8e8SKurt Hackel } 15326714d8e8SKurt Hackel set_maybe = 1; 15336714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock); 15346714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK) { 15356714d8e8SKurt Hackel // mlog(0, "this node is waiting for " 15366714d8e8SKurt Hackel // "lockres to be mastered\n"); 15376714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15386714d8e8SKurt Hackel } else if (tmpmle->type == DLM_MLE_MIGRATION) { 15396714d8e8SKurt Hackel mlog(0, "node %u is master, but trying to migrate to " 15406714d8e8SKurt Hackel "node %u.\n", tmpmle->master, tmpmle->new_master); 15416714d8e8SKurt Hackel if (tmpmle->master == dlm->node_num) { 15426714d8e8SKurt Hackel mlog(ML_ERROR, "no owner on lockres, but this " 15436714d8e8SKurt Hackel "node is trying to migrate it to %u?!\n", 15446714d8e8SKurt Hackel tmpmle->new_master); 15456714d8e8SKurt Hackel BUG(); 15466714d8e8SKurt Hackel } else { 15476714d8e8SKurt Hackel /* the real master can respond on its own */ 15486714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15496714d8e8SKurt Hackel } 15506714d8e8SKurt Hackel } else if (tmpmle->master != DLM_LOCK_RES_OWNER_UNKNOWN) { 15516714d8e8SKurt Hackel set_maybe = 0; 15529c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) { 15536714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES; 15549c6510a5SKurt Hackel /* this node will be the owner. 15559c6510a5SKurt Hackel * go back and clean the mles on any 15569c6510a5SKurt Hackel * other nodes */ 15579c6510a5SKurt Hackel dispatch_assert = 1; 15588d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, 1559ba2bf218SKurt Hackel request->node_idx); 15609c6510a5SKurt Hackel } else 15616714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15626714d8e8SKurt Hackel } else { 15636714d8e8SKurt Hackel // mlog(0, "this node is attempting to " 15646714d8e8SKurt Hackel // "master lockres\n"); 15656714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE; 15666714d8e8SKurt Hackel } 15676714d8e8SKurt Hackel if (set_maybe) 15686714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map); 15696714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock); 15706714d8e8SKurt Hackel 15716714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 15726714d8e8SKurt Hackel spin_unlock(&res->spinlock); 15736714d8e8SKurt Hackel 15746714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */ 15756714d8e8SKurt Hackel dlm_put_mle(tmpmle); 15766714d8e8SKurt Hackel if (mle) 15776714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 15786714d8e8SKurt Hackel goto send_response; 15796714d8e8SKurt Hackel } 15806714d8e8SKurt Hackel 15816714d8e8SKurt Hackel /* 15826714d8e8SKurt Hackel * lockres doesn't exist on this node 15836714d8e8SKurt Hackel * if there is an MLE_BLOCK, return NO 15846714d8e8SKurt Hackel * if there is an MLE_MASTER, return MAYBE 15856714d8e8SKurt Hackel * otherwise, add an MLE_BLOCK, return NO 15866714d8e8SKurt Hackel */ 15876714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 15886714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen); 15896714d8e8SKurt Hackel if (!found) { 15906714d8e8SKurt Hackel /* this lockid has never been seen on this node yet */ 15916714d8e8SKurt Hackel // mlog(0, "no mle found\n"); 15926714d8e8SKurt Hackel if (!mle) { 15936714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 15946714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 15956714d8e8SKurt Hackel 15963914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 15976714d8e8SKurt Hackel if (!mle) { 15986714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR; 15999c6510a5SKurt Hackel mlog_errno(-ENOMEM); 16006714d8e8SKurt Hackel goto send_response; 16016714d8e8SKurt Hackel } 16026714d8e8SKurt Hackel goto way_up_top; 16036714d8e8SKurt Hackel } 16046714d8e8SKurt Hackel 16056714d8e8SKurt Hackel // mlog(0, "this is second time thru, already allocated, " 16066714d8e8SKurt Hackel // "add the block.\n"); 160741b8c8a1SKurt Hackel dlm_init_mle(mle, DLM_MLE_BLOCK, dlm, NULL, name, namelen); 16086714d8e8SKurt Hackel set_bit(request->node_idx, mle->maybe_map); 16091c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 16106714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 16116714d8e8SKurt Hackel } else { 16126714d8e8SKurt Hackel // mlog(0, "mle was found\n"); 16136714d8e8SKurt Hackel set_maybe = 1; 16146714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock); 16159c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) { 16169c6510a5SKurt Hackel mlog(ML_ERROR, "no lockres, but an mle with this node as master!\n"); 16179c6510a5SKurt Hackel BUG(); 16189c6510a5SKurt Hackel } 16196714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK) 16206714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 16216714d8e8SKurt Hackel else if (tmpmle->type == DLM_MLE_MIGRATION) { 16226714d8e8SKurt Hackel mlog(0, "migration mle was found (%u->%u)\n", 16236714d8e8SKurt Hackel tmpmle->master, tmpmle->new_master); 16246714d8e8SKurt Hackel /* real master can respond on its own */ 16256714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 16266714d8e8SKurt Hackel } else 16276714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE; 16286714d8e8SKurt Hackel if (set_maybe) 16296714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map); 16306714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock); 16316714d8e8SKurt Hackel } 16326714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 16336714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 16346714d8e8SKurt Hackel 16356714d8e8SKurt Hackel if (found) { 16366714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */ 16376714d8e8SKurt Hackel dlm_put_mle(tmpmle); 16386714d8e8SKurt Hackel } 16396714d8e8SKurt Hackel send_response: 1640b31cfc02SSunil Mushran /* 1641b31cfc02SSunil Mushran * __dlm_lookup_lockres() grabbed a reference to this lockres. 1642b31cfc02SSunil Mushran * The reference is released by dlm_assert_master_worker() under 1643b31cfc02SSunil Mushran * the call to dlm_dispatch_assert_master(). If 1644b31cfc02SSunil Mushran * dlm_assert_master_worker() isn't called, we drop it here. 1645b31cfc02SSunil Mushran */ 16469c6510a5SKurt Hackel if (dispatch_assert) { 16479c6510a5SKurt Hackel if (response != DLM_MASTER_RESP_YES) 16489c6510a5SKurt Hackel mlog(ML_ERROR, "invalid response %d\n", response); 16499c6510a5SKurt Hackel if (!res) { 16509c6510a5SKurt Hackel mlog(ML_ERROR, "bad lockres while trying to assert!\n"); 16519c6510a5SKurt Hackel BUG(); 16529c6510a5SKurt Hackel } 16539c6510a5SKurt Hackel mlog(0, "%u is the owner of %.*s, cleaning everyone else\n", 16549c6510a5SKurt Hackel dlm->node_num, res->lockname.len, res->lockname.name); 16551e589581SJoseph Qi spin_lock(&res->spinlock); 16569c6510a5SKurt Hackel ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx, 16579c6510a5SKurt Hackel DLM_ASSERT_MASTER_MLE_CLEANUP); 16589c6510a5SKurt Hackel if (ret < 0) { 16599c6510a5SKurt Hackel mlog(ML_ERROR, "failed to dispatch assert master work\n"); 16609c6510a5SKurt Hackel response = DLM_MASTER_RESP_ERROR; 1661b67de018SJoseph Qi spin_unlock(&res->spinlock); 1662b31cfc02SSunil Mushran dlm_lockres_put(res); 1663012572d4SJoseph Qi } else { 1664012572d4SJoseph Qi dispatched = 1; 16651e589581SJoseph Qi __dlm_lockres_grab_inflight_worker(dlm, res); 16661e589581SJoseph Qi spin_unlock(&res->spinlock); 1667b67de018SJoseph Qi } 1668b31cfc02SSunil Mushran } else { 1669b31cfc02SSunil Mushran if (res) 1670b31cfc02SSunil Mushran dlm_lockres_put(res); 16719c6510a5SKurt Hackel } 16729c6510a5SKurt Hackel 1673012572d4SJoseph Qi if (!dispatched) 16746714d8e8SKurt Hackel dlm_put(dlm); 16756714d8e8SKurt Hackel return response; 16766714d8e8SKurt Hackel } 16776714d8e8SKurt Hackel 16786714d8e8SKurt Hackel /* 16796714d8e8SKurt Hackel * DLM_ASSERT_MASTER_MSG 16806714d8e8SKurt Hackel */ 16816714d8e8SKurt Hackel 16826714d8e8SKurt Hackel 16836714d8e8SKurt Hackel /* 16846714d8e8SKurt Hackel * NOTE: this can be used for debugging 16856714d8e8SKurt Hackel * can periodically run all locks owned by this node 16866714d8e8SKurt Hackel * and re-assert across the cluster... 16876714d8e8SKurt Hackel */ 168805488bbeSAdrian Bunk static int dlm_do_assert_master(struct dlm_ctxt *dlm, 1689ba2bf218SKurt Hackel struct dlm_lock_resource *res, 1690ba2bf218SKurt Hackel void *nodemap, u32 flags) 16916714d8e8SKurt Hackel { 16926714d8e8SKurt Hackel struct dlm_assert_master assert; 16936714d8e8SKurt Hackel int to, tmpret; 16946714d8e8SKurt Hackel struct dlm_node_iter iter; 16956714d8e8SKurt Hackel int ret = 0; 16969c6510a5SKurt Hackel int reassert; 1697ba2bf218SKurt Hackel const char *lockname = res->lockname.name; 1698ba2bf218SKurt Hackel unsigned int namelen = res->lockname.len; 16996714d8e8SKurt Hackel 17006714d8e8SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN); 1701f3f85464SSunil Mushran 1702f3f85464SSunil Mushran spin_lock(&res->spinlock); 1703f3f85464SSunil Mushran res->state |= DLM_LOCK_RES_SETREF_INPROG; 1704f3f85464SSunil Mushran spin_unlock(&res->spinlock); 1705f3f85464SSunil Mushran 17069c6510a5SKurt Hackel again: 17079c6510a5SKurt Hackel reassert = 0; 17086714d8e8SKurt Hackel 17096714d8e8SKurt Hackel /* note that if this nodemap is empty, it returns 0 */ 17106714d8e8SKurt Hackel dlm_node_iter_init(nodemap, &iter); 17116714d8e8SKurt Hackel while ((to = dlm_node_iter_next(&iter)) >= 0) { 17126714d8e8SKurt Hackel int r = 0; 1713a9ee4c8aSKurt Hackel struct dlm_master_list_entry *mle = NULL; 1714a9ee4c8aSKurt Hackel 17156714d8e8SKurt Hackel mlog(0, "sending assert master to %d (%.*s)\n", to, 17166714d8e8SKurt Hackel namelen, lockname); 17176714d8e8SKurt Hackel memset(&assert, 0, sizeof(assert)); 17186714d8e8SKurt Hackel assert.node_idx = dlm->node_num; 17196714d8e8SKurt Hackel assert.namelen = namelen; 17206714d8e8SKurt Hackel memcpy(assert.name, lockname, namelen); 17216714d8e8SKurt Hackel assert.flags = cpu_to_be32(flags); 17226714d8e8SKurt Hackel 17236714d8e8SKurt Hackel tmpret = o2net_send_message(DLM_ASSERT_MASTER_MSG, dlm->key, 17246714d8e8SKurt Hackel &assert, sizeof(assert), to, &r); 17256714d8e8SKurt Hackel if (tmpret < 0) { 1726a5196ec5SWengang Wang mlog(ML_ERROR, "Error %d when sending message %u (key " 1727a5196ec5SWengang Wang "0x%x) to node %u\n", tmpret, 1728a5196ec5SWengang Wang DLM_ASSERT_MASTER_MSG, dlm->key, to); 17296714d8e8SKurt Hackel if (!dlm_is_host_down(tmpret)) { 17303b3b84a8SKurt Hackel mlog(ML_ERROR, "unhandled error=%d!\n", tmpret); 17316714d8e8SKurt Hackel BUG(); 17326714d8e8SKurt Hackel } 17336714d8e8SKurt Hackel /* a node died. finish out the rest of the nodes. */ 17343b3b84a8SKurt Hackel mlog(0, "link to %d went down!\n", to); 17356714d8e8SKurt Hackel /* any nonzero status return will do */ 17366714d8e8SKurt Hackel ret = tmpret; 1737ba2bf218SKurt Hackel r = 0; 17386714d8e8SKurt Hackel } else if (r < 0) { 17396714d8e8SKurt Hackel /* ok, something horribly messed. kill thyself. */ 17406714d8e8SKurt Hackel mlog(ML_ERROR,"during assert master of %.*s to %u, " 17416714d8e8SKurt Hackel "got %d.\n", namelen, lockname, to, r); 1742a9ee4c8aSKurt Hackel spin_lock(&dlm->spinlock); 1743a9ee4c8aSKurt Hackel spin_lock(&dlm->master_lock); 1744a9ee4c8aSKurt Hackel if (dlm_find_mle(dlm, &mle, (char *)lockname, 1745a9ee4c8aSKurt Hackel namelen)) { 1746a9ee4c8aSKurt Hackel dlm_print_one_mle(mle); 1747a9ee4c8aSKurt Hackel __dlm_put_mle(mle); 1748a9ee4c8aSKurt Hackel } 1749a9ee4c8aSKurt Hackel spin_unlock(&dlm->master_lock); 1750a9ee4c8aSKurt Hackel spin_unlock(&dlm->spinlock); 17516714d8e8SKurt Hackel BUG(); 1752ba2bf218SKurt Hackel } 1753ba2bf218SKurt Hackel 1754ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT && 1755ba2bf218SKurt Hackel !(r & DLM_ASSERT_RESPONSE_MASTERY_REF)) { 1756ba2bf218SKurt Hackel mlog(ML_ERROR, "%.*s: very strange, " 1757ba2bf218SKurt Hackel "master MLE but no lockres on %u\n", 1758ba2bf218SKurt Hackel namelen, lockname, to); 1759ba2bf218SKurt Hackel } 1760ba2bf218SKurt Hackel 1761ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT) { 17629c6510a5SKurt Hackel mlog(0, "%.*s: node %u create mles on other " 17639c6510a5SKurt Hackel "nodes and requests a re-assert\n", 17649c6510a5SKurt Hackel namelen, lockname, to); 17659c6510a5SKurt Hackel reassert = 1; 17666714d8e8SKurt Hackel } 1767ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_MASTERY_REF) { 1768ba2bf218SKurt Hackel mlog(0, "%.*s: node %u has a reference to this " 1769ba2bf218SKurt Hackel "lockres, set the bit in the refmap\n", 1770ba2bf218SKurt Hackel namelen, lockname, to); 1771ba2bf218SKurt Hackel spin_lock(&res->spinlock); 17728d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, to); 1773ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 1774ba2bf218SKurt Hackel } 17756714d8e8SKurt Hackel } 17766714d8e8SKurt Hackel 17779c6510a5SKurt Hackel if (reassert) 17789c6510a5SKurt Hackel goto again; 17799c6510a5SKurt Hackel 1780f3f85464SSunil Mushran spin_lock(&res->spinlock); 1781f3f85464SSunil Mushran res->state &= ~DLM_LOCK_RES_SETREF_INPROG; 1782f3f85464SSunil Mushran spin_unlock(&res->spinlock); 1783f3f85464SSunil Mushran wake_up(&res->wq); 1784f3f85464SSunil Mushran 17856714d8e8SKurt Hackel return ret; 17866714d8e8SKurt Hackel } 17876714d8e8SKurt Hackel 17886714d8e8SKurt Hackel /* 17896714d8e8SKurt Hackel * locks that can be taken here: 17906714d8e8SKurt Hackel * dlm->spinlock 17916714d8e8SKurt Hackel * res->spinlock 17926714d8e8SKurt Hackel * mle->spinlock 17936714d8e8SKurt Hackel * dlm->master_list 17946714d8e8SKurt Hackel * 17956714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!! 17966714d8e8SKurt Hackel */ 1797d74c9803SKurt Hackel int dlm_assert_master_handler(struct o2net_msg *msg, u32 len, void *data, 1798d74c9803SKurt Hackel void **ret_data) 17996714d8e8SKurt Hackel { 18006714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 18016714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 18026714d8e8SKurt Hackel struct dlm_assert_master *assert = (struct dlm_assert_master *)msg->buf; 18036714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL; 18046714d8e8SKurt Hackel char *name; 1805a3d33291SMark Fasheh unsigned int namelen, hash; 18066714d8e8SKurt Hackel u32 flags; 1807ba2bf218SKurt Hackel int master_request = 0, have_lockres_ref = 0; 18089c6510a5SKurt Hackel int ret = 0; 18096714d8e8SKurt Hackel 18106714d8e8SKurt Hackel if (!dlm_grab(dlm)) 18116714d8e8SKurt Hackel return 0; 18126714d8e8SKurt Hackel 18136714d8e8SKurt Hackel name = assert->name; 18146714d8e8SKurt Hackel namelen = assert->namelen; 1815a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 18166714d8e8SKurt Hackel flags = be32_to_cpu(assert->flags); 18176714d8e8SKurt Hackel 18186714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 18196714d8e8SKurt Hackel mlog(ML_ERROR, "Invalid name length!"); 18206714d8e8SKurt Hackel goto done; 18216714d8e8SKurt Hackel } 18226714d8e8SKurt Hackel 18236714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 18246714d8e8SKurt Hackel 18256714d8e8SKurt Hackel if (flags) 18266714d8e8SKurt Hackel mlog(0, "assert_master with flags: %u\n", flags); 18276714d8e8SKurt Hackel 18286714d8e8SKurt Hackel /* find the MLE */ 18296714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 18306714d8e8SKurt Hackel if (!dlm_find_mle(dlm, &mle, name, namelen)) { 18316714d8e8SKurt Hackel /* not an error, could be master just re-asserting */ 18326714d8e8SKurt Hackel mlog(0, "just got an assert_master from %u, but no " 18336714d8e8SKurt Hackel "MLE for it! (%.*s)\n", assert->node_idx, 18346714d8e8SKurt Hackel namelen, name); 18356714d8e8SKurt Hackel } else { 18366714d8e8SKurt Hackel int bit = find_next_bit (mle->maybe_map, O2NM_MAX_NODES, 0); 18376714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) { 18386714d8e8SKurt Hackel /* not necessarily an error, though less likely. 18396714d8e8SKurt Hackel * could be master just re-asserting. */ 1840aa852354SKurt Hackel mlog(0, "no bits set in the maybe_map, but %u " 18416714d8e8SKurt Hackel "is asserting! (%.*s)\n", assert->node_idx, 18426714d8e8SKurt Hackel namelen, name); 18436714d8e8SKurt Hackel } else if (bit != assert->node_idx) { 18446714d8e8SKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) { 18456714d8e8SKurt Hackel mlog(0, "master %u was found, %u should " 18466714d8e8SKurt Hackel "back off\n", assert->node_idx, bit); 18476714d8e8SKurt Hackel } else { 18486714d8e8SKurt Hackel /* with the fix for bug 569, a higher node 18496714d8e8SKurt Hackel * number winning the mastery will respond 18506714d8e8SKurt Hackel * YES to mastery requests, but this node 18516714d8e8SKurt Hackel * had no way of knowing. let it pass. */ 1852aa852354SKurt Hackel mlog(0, "%u is the lowest node, " 18536714d8e8SKurt Hackel "%u is asserting. (%.*s) %u must " 18546714d8e8SKurt Hackel "have begun after %u won.\n", bit, 18556714d8e8SKurt Hackel assert->node_idx, namelen, name, bit, 18566714d8e8SKurt Hackel assert->node_idx); 18576714d8e8SKurt Hackel } 18586714d8e8SKurt Hackel } 18592d1a868cSKurt Hackel if (mle->type == DLM_MLE_MIGRATION) { 18602d1a868cSKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) { 18612d1a868cSKurt Hackel mlog(0, "%s:%.*s: got cleanup assert" 18622d1a868cSKurt Hackel " from %u for migration\n", 18632d1a868cSKurt Hackel dlm->name, namelen, name, 18642d1a868cSKurt Hackel assert->node_idx); 18652d1a868cSKurt Hackel } else if (!(flags & DLM_ASSERT_MASTER_FINISH_MIGRATION)) { 18662d1a868cSKurt Hackel mlog(0, "%s:%.*s: got unrelated assert" 18672d1a868cSKurt Hackel " from %u for migration, ignoring\n", 18682d1a868cSKurt Hackel dlm->name, namelen, name, 18692d1a868cSKurt Hackel assert->node_idx); 18702d1a868cSKurt Hackel __dlm_put_mle(mle); 18712d1a868cSKurt Hackel spin_unlock(&dlm->master_lock); 18722d1a868cSKurt Hackel spin_unlock(&dlm->spinlock); 18732d1a868cSKurt Hackel goto done; 18742d1a868cSKurt Hackel } 18752d1a868cSKurt Hackel } 18766714d8e8SKurt Hackel } 18776714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 18786714d8e8SKurt Hackel 18796714d8e8SKurt Hackel /* ok everything checks out with the MLE 18806714d8e8SKurt Hackel * now check to see if there is a lockres */ 1881a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 18826714d8e8SKurt Hackel if (res) { 18836714d8e8SKurt Hackel spin_lock(&res->spinlock); 18846714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) { 18856714d8e8SKurt Hackel mlog(ML_ERROR, "%u asserting but %.*s is " 18866714d8e8SKurt Hackel "RECOVERING!\n", assert->node_idx, namelen, name); 18876714d8e8SKurt Hackel goto kill; 18886714d8e8SKurt Hackel } 18896714d8e8SKurt Hackel if (!mle) { 1890dc2ed195SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN && 1891dc2ed195SKurt Hackel res->owner != assert->node_idx) { 189253ecd25eSSunil Mushran mlog(ML_ERROR, "DIE! Mastery assert from %u, " 189353ecd25eSSunil Mushran "but current owner is %u! (%.*s)\n", 189453ecd25eSSunil Mushran assert->node_idx, res->owner, namelen, 189553ecd25eSSunil Mushran name); 189653ecd25eSSunil Mushran __dlm_print_one_lock_resource(res); 189753ecd25eSSunil Mushran BUG(); 18986714d8e8SKurt Hackel } 18996714d8e8SKurt Hackel } else if (mle->type != DLM_MLE_MIGRATION) { 19006714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 19016714d8e8SKurt Hackel /* owner is just re-asserting */ 19026714d8e8SKurt Hackel if (res->owner == assert->node_idx) { 19036714d8e8SKurt Hackel mlog(0, "owner %u re-asserting on " 19046714d8e8SKurt Hackel "lock %.*s\n", assert->node_idx, 19056714d8e8SKurt Hackel namelen, name); 19066714d8e8SKurt Hackel goto ok; 19076714d8e8SKurt Hackel } 19086714d8e8SKurt Hackel mlog(ML_ERROR, "got assert_master from " 19096714d8e8SKurt Hackel "node %u, but %u is the owner! " 19106714d8e8SKurt Hackel "(%.*s)\n", assert->node_idx, 19116714d8e8SKurt Hackel res->owner, namelen, name); 19126714d8e8SKurt Hackel goto kill; 19136714d8e8SKurt Hackel } 19146714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) { 19156714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but lock " 19166714d8e8SKurt Hackel "with no owner should be " 19176714d8e8SKurt Hackel "in-progress! (%.*s)\n", 19186714d8e8SKurt Hackel assert->node_idx, 19196714d8e8SKurt Hackel namelen, name); 19206714d8e8SKurt Hackel goto kill; 19216714d8e8SKurt Hackel } 19226714d8e8SKurt Hackel } else /* mle->type == DLM_MLE_MIGRATION */ { 19236714d8e8SKurt Hackel /* should only be getting an assert from new master */ 19246714d8e8SKurt Hackel if (assert->node_idx != mle->new_master) { 19256714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but " 19266714d8e8SKurt Hackel "new master is %u, and old master " 19276714d8e8SKurt Hackel "was %u (%.*s)\n", 19286714d8e8SKurt Hackel assert->node_idx, mle->new_master, 19296714d8e8SKurt Hackel mle->master, namelen, name); 19306714d8e8SKurt Hackel goto kill; 19316714d8e8SKurt Hackel } 19326714d8e8SKurt Hackel 19336714d8e8SKurt Hackel } 19346714d8e8SKurt Hackel ok: 19356714d8e8SKurt Hackel spin_unlock(&res->spinlock); 19366714d8e8SKurt Hackel } 19376714d8e8SKurt Hackel 19386714d8e8SKurt Hackel // mlog(0, "woo! got an assert_master from node %u!\n", 19396714d8e8SKurt Hackel // assert->node_idx); 19406714d8e8SKurt Hackel if (mle) { 19419c6510a5SKurt Hackel int extra_ref = 0; 19429c6510a5SKurt Hackel int nn = -1; 1943a2bf0477SKurt Hackel int rr, err = 0; 19446714d8e8SKurt Hackel 19456714d8e8SKurt Hackel spin_lock(&mle->spinlock); 19469c6510a5SKurt Hackel if (mle->type == DLM_MLE_BLOCK || mle->type == DLM_MLE_MIGRATION) 19479c6510a5SKurt Hackel extra_ref = 1; 19489c6510a5SKurt Hackel else { 19499c6510a5SKurt Hackel /* MASTER mle: if any bits set in the response map 19509c6510a5SKurt Hackel * then the calling node needs to re-assert to clear 19519c6510a5SKurt Hackel * up nodes that this node contacted */ 19529c6510a5SKurt Hackel while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES, 19539c6510a5SKurt Hackel nn+1)) < O2NM_MAX_NODES) { 1954728b9805SJunxiao Bi if (nn != dlm->node_num && nn != assert->node_idx) { 19559c6510a5SKurt Hackel master_request = 1; 1956728b9805SJunxiao Bi break; 1957728b9805SJunxiao Bi } 19589c6510a5SKurt Hackel } 19599c6510a5SKurt Hackel } 19606714d8e8SKurt Hackel mle->master = assert->node_idx; 19616714d8e8SKurt Hackel atomic_set(&mle->woken, 1); 19626714d8e8SKurt Hackel wake_up(&mle->wq); 19636714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 19646714d8e8SKurt Hackel 1965a2bf0477SKurt Hackel if (res) { 1966a6fa3640SKurt Hackel int wake = 0; 1967a2bf0477SKurt Hackel spin_lock(&res->spinlock); 1968a2bf0477SKurt Hackel if (mle->type == DLM_MLE_MIGRATION) { 19696714d8e8SKurt Hackel mlog(0, "finishing off migration of lockres %.*s, " 19706714d8e8SKurt Hackel "from %u to %u\n", 19716714d8e8SKurt Hackel res->lockname.len, res->lockname.name, 19726714d8e8SKurt Hackel dlm->node_num, mle->new_master); 19736714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 1974a6fa3640SKurt Hackel wake = 1; 19756714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->new_master); 19766714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DIRTY); 1977a2bf0477SKurt Hackel } else { 1978a2bf0477SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->master); 1979a2bf0477SKurt Hackel } 19806714d8e8SKurt Hackel spin_unlock(&res->spinlock); 1981ba2bf218SKurt Hackel have_lockres_ref = 1; 1982a6fa3640SKurt Hackel if (wake) 1983a6fa3640SKurt Hackel wake_up(&res->wq); 19846714d8e8SKurt Hackel } 19856714d8e8SKurt Hackel 1986a2bf0477SKurt Hackel /* master is known, detach if not already detached. 1987a2bf0477SKurt Hackel * ensures that only one assert_master call will happen 1988a2bf0477SKurt Hackel * on this mle. */ 1989a2bf0477SKurt Hackel spin_lock(&dlm->master_lock); 1990a2bf0477SKurt Hackel 1991a2bf0477SKurt Hackel rr = atomic_read(&mle->mle_refs.refcount); 1992a2bf0477SKurt Hackel if (mle->inuse > 0) { 1993a2bf0477SKurt Hackel if (extra_ref && rr < 3) 1994a2bf0477SKurt Hackel err = 1; 1995a2bf0477SKurt Hackel else if (!extra_ref && rr < 2) 1996a2bf0477SKurt Hackel err = 1; 1997a2bf0477SKurt Hackel } else { 1998a2bf0477SKurt Hackel if (extra_ref && rr < 2) 1999a2bf0477SKurt Hackel err = 1; 2000a2bf0477SKurt Hackel else if (!extra_ref && rr < 1) 2001a2bf0477SKurt Hackel err = 1; 2002a2bf0477SKurt Hackel } 2003a2bf0477SKurt Hackel if (err) { 2004a2bf0477SKurt Hackel mlog(ML_ERROR, "%s:%.*s: got assert master from %u " 2005a2bf0477SKurt Hackel "that will mess up this node, refs=%d, extra=%d, " 2006a2bf0477SKurt Hackel "inuse=%d\n", dlm->name, namelen, name, 2007a2bf0477SKurt Hackel assert->node_idx, rr, extra_ref, mle->inuse); 2008a2bf0477SKurt Hackel dlm_print_one_mle(mle); 2009a2bf0477SKurt Hackel } 20101c084577SSunil Mushran __dlm_unlink_mle(dlm, mle); 2011a2bf0477SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle); 2012a2bf0477SKurt Hackel __dlm_put_mle(mle); 20136714d8e8SKurt Hackel if (extra_ref) { 20146714d8e8SKurt Hackel /* the assert master message now balances the extra 20156714d8e8SKurt Hackel * ref given by the master / migration request message. 20166714d8e8SKurt Hackel * if this is the last put, it will be removed 20176714d8e8SKurt Hackel * from the list. */ 2018a2bf0477SKurt Hackel __dlm_put_mle(mle); 2019a2bf0477SKurt Hackel } 2020a2bf0477SKurt Hackel spin_unlock(&dlm->master_lock); 2021a2bf0477SKurt Hackel } else if (res) { 2022a2bf0477SKurt Hackel if (res->owner != assert->node_idx) { 2023a2bf0477SKurt Hackel mlog(0, "assert_master from %u, but current " 2024a2bf0477SKurt Hackel "owner is %u (%.*s), no mle\n", assert->node_idx, 2025a2bf0477SKurt Hackel res->owner, namelen, name); 20266714d8e8SKurt Hackel } 20276714d8e8SKurt Hackel } 202814741472SSrinivas Eeda spin_unlock(&dlm->spinlock); 20296714d8e8SKurt Hackel 20306714d8e8SKurt Hackel done: 20319c6510a5SKurt Hackel ret = 0; 20323b8118cfSKurt Hackel if (res) { 20333b8118cfSKurt Hackel spin_lock(&res->spinlock); 20343b8118cfSKurt Hackel res->state |= DLM_LOCK_RES_SETREF_INPROG; 20353b8118cfSKurt Hackel spin_unlock(&res->spinlock); 20363b8118cfSKurt Hackel *ret_data = (void *)res; 20373b8118cfSKurt Hackel } 20386714d8e8SKurt Hackel dlm_put(dlm); 20399c6510a5SKurt Hackel if (master_request) { 20409c6510a5SKurt Hackel mlog(0, "need to tell master to reassert\n"); 2041ba2bf218SKurt Hackel /* positive. negative would shoot down the node. */ 2042ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_REASSERT; 2043ba2bf218SKurt Hackel if (!have_lockres_ref) { 2044ba2bf218SKurt Hackel mlog(ML_ERROR, "strange, got assert from %u, MASTER " 2045ba2bf218SKurt Hackel "mle present here for %s:%.*s, but no lockres!\n", 2046ba2bf218SKurt Hackel assert->node_idx, dlm->name, namelen, name); 2047ba2bf218SKurt Hackel } 2048ba2bf218SKurt Hackel } 2049ba2bf218SKurt Hackel if (have_lockres_ref) { 2050ba2bf218SKurt Hackel /* let the master know we have a reference to the lockres */ 2051ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_MASTERY_REF; 2052ba2bf218SKurt Hackel mlog(0, "%s:%.*s: got assert from %u, need a ref\n", 2053ba2bf218SKurt Hackel dlm->name, namelen, name, assert->node_idx); 20549c6510a5SKurt Hackel } 20559c6510a5SKurt Hackel return ret; 20566714d8e8SKurt Hackel 20576714d8e8SKurt Hackel kill: 20586714d8e8SKurt Hackel /* kill the caller! */ 2059a9ee4c8aSKurt Hackel mlog(ML_ERROR, "Bad message received from another node. Dumping state " 2060a9ee4c8aSKurt Hackel "and killing the other node now! This node is OK and can continue.\n"); 2061a9ee4c8aSKurt Hackel __dlm_print_one_lock_resource(res); 20626714d8e8SKurt Hackel spin_unlock(&res->spinlock); 206355dacd22Salex chen spin_lock(&dlm->master_lock); 206455dacd22Salex chen if (mle) 206555dacd22Salex chen __dlm_put_mle(mle); 206655dacd22Salex chen spin_unlock(&dlm->master_lock); 20676714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 20683b8118cfSKurt Hackel *ret_data = (void *)res; 20696714d8e8SKurt Hackel dlm_put(dlm); 20706714d8e8SKurt Hackel return -EINVAL; 20716714d8e8SKurt Hackel } 20726714d8e8SKurt Hackel 20733b8118cfSKurt Hackel void dlm_assert_master_post_handler(int status, void *data, void *ret_data) 20743b8118cfSKurt Hackel { 20753b8118cfSKurt Hackel struct dlm_lock_resource *res = (struct dlm_lock_resource *)ret_data; 20763b8118cfSKurt Hackel 20773b8118cfSKurt Hackel if (ret_data) { 20783b8118cfSKurt Hackel spin_lock(&res->spinlock); 20793b8118cfSKurt Hackel res->state &= ~DLM_LOCK_RES_SETREF_INPROG; 20803b8118cfSKurt Hackel spin_unlock(&res->spinlock); 20813b8118cfSKurt Hackel wake_up(&res->wq); 20823b8118cfSKurt Hackel dlm_lockres_put(res); 20833b8118cfSKurt Hackel } 20843b8118cfSKurt Hackel return; 20853b8118cfSKurt Hackel } 20863b8118cfSKurt Hackel 20876714d8e8SKurt Hackel int dlm_dispatch_assert_master(struct dlm_ctxt *dlm, 20886714d8e8SKurt Hackel struct dlm_lock_resource *res, 20896714d8e8SKurt Hackel int ignore_higher, u8 request_from, u32 flags) 20906714d8e8SKurt Hackel { 20916714d8e8SKurt Hackel struct dlm_work_item *item; 2092b24ae0b5SDan Carpenter item = kzalloc(sizeof(*item), GFP_ATOMIC); 20936714d8e8SKurt Hackel if (!item) 20946714d8e8SKurt Hackel return -ENOMEM; 20956714d8e8SKurt Hackel 20966714d8e8SKurt Hackel 20976714d8e8SKurt Hackel /* queue up work for dlm_assert_master_worker */ 20986714d8e8SKurt Hackel dlm_init_work_item(dlm, item, dlm_assert_master_worker, NULL); 20996714d8e8SKurt Hackel item->u.am.lockres = res; /* already have a ref */ 21006714d8e8SKurt Hackel /* can optionally ignore node numbers higher than this node */ 21016714d8e8SKurt Hackel item->u.am.ignore_higher = ignore_higher; 21026714d8e8SKurt Hackel item->u.am.request_from = request_from; 21036714d8e8SKurt Hackel item->u.am.flags = flags; 21046714d8e8SKurt Hackel 21059c6510a5SKurt Hackel if (ignore_higher) 21069c6510a5SKurt Hackel mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len, 21079c6510a5SKurt Hackel res->lockname.name); 21089c6510a5SKurt Hackel 21096714d8e8SKurt Hackel spin_lock(&dlm->work_lock); 21106714d8e8SKurt Hackel list_add_tail(&item->list, &dlm->work_list); 21116714d8e8SKurt Hackel spin_unlock(&dlm->work_lock); 21126714d8e8SKurt Hackel 21133156d267SKurt Hackel queue_work(dlm->dlm_worker, &dlm->dispatched_work); 21146714d8e8SKurt Hackel return 0; 21156714d8e8SKurt Hackel } 21166714d8e8SKurt Hackel 21176714d8e8SKurt Hackel static void dlm_assert_master_worker(struct dlm_work_item *item, void *data) 21186714d8e8SKurt Hackel { 21196714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 21206714d8e8SKurt Hackel int ret = 0; 21216714d8e8SKurt Hackel struct dlm_lock_resource *res; 21226714d8e8SKurt Hackel unsigned long nodemap[BITS_TO_LONGS(O2NM_MAX_NODES)]; 21236714d8e8SKurt Hackel int ignore_higher; 21246714d8e8SKurt Hackel int bit; 21256714d8e8SKurt Hackel u8 request_from; 21266714d8e8SKurt Hackel u32 flags; 21276714d8e8SKurt Hackel 21286714d8e8SKurt Hackel dlm = item->dlm; 21296714d8e8SKurt Hackel res = item->u.am.lockres; 21306714d8e8SKurt Hackel ignore_higher = item->u.am.ignore_higher; 21316714d8e8SKurt Hackel request_from = item->u.am.request_from; 21326714d8e8SKurt Hackel flags = item->u.am.flags; 21336714d8e8SKurt Hackel 21346714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 21356714d8e8SKurt Hackel memcpy(nodemap, dlm->domain_map, sizeof(nodemap)); 21366714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 21376714d8e8SKurt Hackel 21386714d8e8SKurt Hackel clear_bit(dlm->node_num, nodemap); 21396714d8e8SKurt Hackel if (ignore_higher) { 21406714d8e8SKurt Hackel /* if is this just to clear up mles for nodes below 21416714d8e8SKurt Hackel * this node, do not send the message to the original 21426714d8e8SKurt Hackel * caller or any node number higher than this */ 21436714d8e8SKurt Hackel clear_bit(request_from, nodemap); 21446714d8e8SKurt Hackel bit = dlm->node_num; 21456714d8e8SKurt Hackel while (1) { 21466714d8e8SKurt Hackel bit = find_next_bit(nodemap, O2NM_MAX_NODES, 21476714d8e8SKurt Hackel bit+1); 21486714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) 21496714d8e8SKurt Hackel break; 21506714d8e8SKurt Hackel clear_bit(bit, nodemap); 21516714d8e8SKurt Hackel } 21526714d8e8SKurt Hackel } 21536714d8e8SKurt Hackel 215436407488SKurt Hackel /* 215536407488SKurt Hackel * If we're migrating this lock to someone else, we are no 215636407488SKurt Hackel * longer allowed to assert out own mastery. OTOH, we need to 215736407488SKurt Hackel * prevent migration from starting while we're still asserting 215836407488SKurt Hackel * our dominance. The reserved ast delays migration. 215936407488SKurt Hackel */ 216036407488SKurt Hackel spin_lock(&res->spinlock); 216136407488SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) { 216236407488SKurt Hackel mlog(0, "Someone asked us to assert mastery, but we're " 216336407488SKurt Hackel "in the middle of migration. Skipping assert, " 216436407488SKurt Hackel "the new master will handle that.\n"); 216536407488SKurt Hackel spin_unlock(&res->spinlock); 216636407488SKurt Hackel goto put; 216736407488SKurt Hackel } else 216836407488SKurt Hackel __dlm_lockres_reserve_ast(res); 216936407488SKurt Hackel spin_unlock(&res->spinlock); 217036407488SKurt Hackel 21716714d8e8SKurt Hackel /* this call now finishes out the nodemap 21726714d8e8SKurt Hackel * even if one or more nodes die */ 21736714d8e8SKurt Hackel mlog(0, "worker about to master %.*s here, this=%u\n", 21746714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num); 2175ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, nodemap, flags); 21766714d8e8SKurt Hackel if (ret < 0) { 21776714d8e8SKurt Hackel /* no need to restart, we are done */ 21783b3b84a8SKurt Hackel if (!dlm_is_host_down(ret)) 21796714d8e8SKurt Hackel mlog_errno(ret); 21806714d8e8SKurt Hackel } 21816714d8e8SKurt Hackel 218236407488SKurt Hackel /* Ok, we've asserted ourselves. Let's let migration start. */ 218336407488SKurt Hackel dlm_lockres_release_ast(dlm, res); 218436407488SKurt Hackel 218536407488SKurt Hackel put: 2186ac4fef4dSXue jiufei dlm_lockres_drop_inflight_worker(dlm, res); 2187ac4fef4dSXue jiufei 21886714d8e8SKurt Hackel dlm_lockres_put(res); 21896714d8e8SKurt Hackel 21906714d8e8SKurt Hackel mlog(0, "finished with dlm_assert_master_worker\n"); 21916714d8e8SKurt Hackel } 21926714d8e8SKurt Hackel 2193c03872f5SKurt Hackel /* SPECIAL CASE for the $RECOVERY lock used by the recovery thread. 2194c03872f5SKurt Hackel * We cannot wait for node recovery to complete to begin mastering this 2195c03872f5SKurt Hackel * lockres because this lockres is used to kick off recovery! ;-) 2196c03872f5SKurt Hackel * So, do a pre-check on all living nodes to see if any of those nodes 2197c03872f5SKurt Hackel * think that $RECOVERY is currently mastered by a dead node. If so, 2198c03872f5SKurt Hackel * we wait a short time to allow that node to get notified by its own 2199c03872f5SKurt Hackel * heartbeat stack, then check again. All $RECOVERY lock resources 2200c03872f5SKurt Hackel * mastered by dead nodes are purged when the hearbeat callback is 2201c03872f5SKurt Hackel * fired, so we can know for sure that it is safe to continue once 2202c03872f5SKurt Hackel * the node returns a live node or no node. */ 2203c03872f5SKurt Hackel static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, 2204c03872f5SKurt Hackel struct dlm_lock_resource *res) 2205c03872f5SKurt Hackel { 2206c03872f5SKurt Hackel struct dlm_node_iter iter; 2207c03872f5SKurt Hackel int nodenum; 2208c03872f5SKurt Hackel int ret = 0; 2209c03872f5SKurt Hackel u8 master = DLM_LOCK_RES_OWNER_UNKNOWN; 2210c03872f5SKurt Hackel 2211c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 2212c03872f5SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter); 2213c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 2214c03872f5SKurt Hackel 2215c03872f5SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) { 2216c03872f5SKurt Hackel /* do not send to self */ 2217c03872f5SKurt Hackel if (nodenum == dlm->node_num) 2218c03872f5SKurt Hackel continue; 2219c03872f5SKurt Hackel ret = dlm_do_master_requery(dlm, res, nodenum, &master); 2220c03872f5SKurt Hackel if (ret < 0) { 2221c03872f5SKurt Hackel mlog_errno(ret); 2222c03872f5SKurt Hackel if (!dlm_is_host_down(ret)) 2223c03872f5SKurt Hackel BUG(); 2224c03872f5SKurt Hackel /* host is down, so answer for that node would be 2225c03872f5SKurt Hackel * DLM_LOCK_RES_OWNER_UNKNOWN. continue. */ 2226f42a100bSKurt Hackel ret = 0; 2227c03872f5SKurt Hackel } 2228c03872f5SKurt Hackel 2229c03872f5SKurt Hackel if (master != DLM_LOCK_RES_OWNER_UNKNOWN) { 2230c03872f5SKurt Hackel /* check to see if this master is in the recovery map */ 2231c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 2232c03872f5SKurt Hackel if (test_bit(master, dlm->recovery_map)) { 2233c03872f5SKurt Hackel mlog(ML_NOTICE, "%s: node %u has not seen " 2234c03872f5SKurt Hackel "node %u go down yet, and thinks the " 2235c03872f5SKurt Hackel "dead node is mastering the recovery " 2236c03872f5SKurt Hackel "lock. must wait.\n", dlm->name, 2237c03872f5SKurt Hackel nodenum, master); 2238c03872f5SKurt Hackel ret = -EAGAIN; 2239c03872f5SKurt Hackel } 2240c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 2241c03872f5SKurt Hackel mlog(0, "%s: reco lock master is %u\n", dlm->name, 2242c03872f5SKurt Hackel master); 2243c03872f5SKurt Hackel break; 2244c03872f5SKurt Hackel } 2245c03872f5SKurt Hackel } 2246c03872f5SKurt Hackel return ret; 2247c03872f5SKurt Hackel } 2248c03872f5SKurt Hackel 2249ba2bf218SKurt Hackel /* 2250ba2bf218SKurt Hackel * DLM_DEREF_LOCKRES_MSG 2251ba2bf218SKurt Hackel */ 2252ba2bf218SKurt Hackel 2253ba2bf218SKurt Hackel int dlm_drop_lockres_ref(struct dlm_ctxt *dlm, struct dlm_lock_resource *res) 2254ba2bf218SKurt Hackel { 2255ba2bf218SKurt Hackel struct dlm_deref_lockres deref; 2256ba2bf218SKurt Hackel int ret = 0, r; 2257ba2bf218SKurt Hackel const char *lockname; 2258ba2bf218SKurt Hackel unsigned int namelen; 2259ba2bf218SKurt Hackel 2260ba2bf218SKurt Hackel lockname = res->lockname.name; 2261ba2bf218SKurt Hackel namelen = res->lockname.len; 2262ba2bf218SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN); 2263ba2bf218SKurt Hackel 2264ba2bf218SKurt Hackel memset(&deref, 0, sizeof(deref)); 2265ba2bf218SKurt Hackel deref.node_idx = dlm->node_num; 2266ba2bf218SKurt Hackel deref.namelen = namelen; 2267ba2bf218SKurt Hackel memcpy(deref.name, lockname, namelen); 2268ba2bf218SKurt Hackel 2269ba2bf218SKurt Hackel ret = o2net_send_message(DLM_DEREF_LOCKRES_MSG, dlm->key, 2270ba2bf218SKurt Hackel &deref, sizeof(deref), res->owner, &r); 2271ba2bf218SKurt Hackel if (ret < 0) 22728decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, error %d send DEREF to node %u\n", 22738decab3cSSunil Mushran dlm->name, namelen, lockname, ret, res->owner); 2274ba2bf218SKurt Hackel else if (r < 0) { 2275ba2bf218SKurt Hackel /* BAD. other node says I did not have a ref. */ 22768decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, DEREF to node %u got %d\n", 22778decab3cSSunil Mushran dlm->name, namelen, lockname, res->owner, r); 2278ba2bf218SKurt Hackel dlm_print_one_lock_resource(res); 2279ba2bf218SKurt Hackel BUG(); 2280ba2bf218SKurt Hackel } 2281842b90b6Sxuejiufei return ret ? ret : r; 2282ba2bf218SKurt Hackel } 2283ba2bf218SKurt Hackel 2284d74c9803SKurt Hackel int dlm_deref_lockres_handler(struct o2net_msg *msg, u32 len, void *data, 2285d74c9803SKurt Hackel void **ret_data) 2286ba2bf218SKurt Hackel { 2287ba2bf218SKurt Hackel struct dlm_ctxt *dlm = data; 2288ba2bf218SKurt Hackel struct dlm_deref_lockres *deref = (struct dlm_deref_lockres *)msg->buf; 2289ba2bf218SKurt Hackel struct dlm_lock_resource *res = NULL; 2290ba2bf218SKurt Hackel char *name; 2291ba2bf218SKurt Hackel unsigned int namelen; 2292ba2bf218SKurt Hackel int ret = -EINVAL; 2293ba2bf218SKurt Hackel u8 node; 2294ba2bf218SKurt Hackel unsigned int hash; 2295f3f85464SSunil Mushran struct dlm_work_item *item; 2296f3f85464SSunil Mushran int cleared = 0; 2297f3f85464SSunil Mushran int dispatch = 0; 2298ba2bf218SKurt Hackel 2299ba2bf218SKurt Hackel if (!dlm_grab(dlm)) 2300ba2bf218SKurt Hackel return 0; 2301ba2bf218SKurt Hackel 2302ba2bf218SKurt Hackel name = deref->name; 2303ba2bf218SKurt Hackel namelen = deref->namelen; 2304ba2bf218SKurt Hackel node = deref->node_idx; 2305ba2bf218SKurt Hackel 2306ba2bf218SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 2307ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid name length!"); 2308ba2bf218SKurt Hackel goto done; 2309ba2bf218SKurt Hackel } 2310ba2bf218SKurt Hackel if (deref->node_idx >= O2NM_MAX_NODES) { 2311ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid node number: %u\n", node); 2312ba2bf218SKurt Hackel goto done; 2313ba2bf218SKurt Hackel } 2314ba2bf218SKurt Hackel 2315ba2bf218SKurt Hackel hash = dlm_lockid_hash(name, namelen); 2316ba2bf218SKurt Hackel 2317ba2bf218SKurt Hackel spin_lock(&dlm->spinlock); 2318ba2bf218SKurt Hackel res = __dlm_lookup_lockres_full(dlm, name, namelen, hash); 2319ba2bf218SKurt Hackel if (!res) { 2320ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2321ba2bf218SKurt Hackel mlog(ML_ERROR, "%s:%.*s: bad lockres name\n", 2322ba2bf218SKurt Hackel dlm->name, namelen, name); 2323ba2bf218SKurt Hackel goto done; 2324ba2bf218SKurt Hackel } 2325ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2326ba2bf218SKurt Hackel 2327ba2bf218SKurt Hackel spin_lock(&res->spinlock); 2328f3f85464SSunil Mushran if (res->state & DLM_LOCK_RES_SETREF_INPROG) 2329f3f85464SSunil Mushran dispatch = 1; 2330f3f85464SSunil Mushran else { 2331ba2bf218SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF); 2332ba2bf218SKurt Hackel if (test_bit(node, res->refmap)) { 23338d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, node); 2334f3f85464SSunil Mushran cleared = 1; 2335f3f85464SSunil Mushran } 2336ba2bf218SKurt Hackel } 2337ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 2338ba2bf218SKurt Hackel 2339f3f85464SSunil Mushran if (!dispatch) { 2340f3f85464SSunil Mushran if (cleared) 2341ba2bf218SKurt Hackel dlm_lockres_calc_usage(dlm, res); 2342f3f85464SSunil Mushran else { 2343f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref " 2344f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name, 2345f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node); 23462af37ce8STao Ma dlm_print_one_lock_resource(res); 2347f3f85464SSunil Mushran } 2348842b90b6Sxuejiufei ret = DLM_DEREF_RESPONSE_DONE; 2349f3f85464SSunil Mushran goto done; 2350f3f85464SSunil Mushran } 2351f3f85464SSunil Mushran 2352f3f85464SSunil Mushran item = kzalloc(sizeof(*item), GFP_NOFS); 2353f3f85464SSunil Mushran if (!item) { 2354f3f85464SSunil Mushran ret = -ENOMEM; 2355f3f85464SSunil Mushran mlog_errno(ret); 2356f3f85464SSunil Mushran goto done; 2357f3f85464SSunil Mushran } 2358f3f85464SSunil Mushran 2359f3f85464SSunil Mushran dlm_init_work_item(dlm, item, dlm_deref_lockres_worker, NULL); 2360f3f85464SSunil Mushran item->u.dl.deref_res = res; 2361f3f85464SSunil Mushran item->u.dl.deref_node = node; 2362f3f85464SSunil Mushran 2363f3f85464SSunil Mushran spin_lock(&dlm->work_lock); 2364f3f85464SSunil Mushran list_add_tail(&item->list, &dlm->work_list); 2365f3f85464SSunil Mushran spin_unlock(&dlm->work_lock); 2366f3f85464SSunil Mushran 2367f3f85464SSunil Mushran queue_work(dlm->dlm_worker, &dlm->dispatched_work); 2368842b90b6Sxuejiufei return DLM_DEREF_RESPONSE_INPROG; 2369f3f85464SSunil Mushran 2370ba2bf218SKurt Hackel done: 2371ba2bf218SKurt Hackel if (res) 2372ba2bf218SKurt Hackel dlm_lockres_put(res); 2373ba2bf218SKurt Hackel dlm_put(dlm); 2374f3f85464SSunil Mushran 2375ba2bf218SKurt Hackel return ret; 2376ba2bf218SKurt Hackel } 2377ba2bf218SKurt Hackel 237860d663cbSxuejiufei int dlm_deref_lockres_done_handler(struct o2net_msg *msg, u32 len, void *data, 237960d663cbSxuejiufei void **ret_data) 238060d663cbSxuejiufei { 238160d663cbSxuejiufei struct dlm_ctxt *dlm = data; 238260d663cbSxuejiufei struct dlm_deref_lockres_done *deref 238360d663cbSxuejiufei = (struct dlm_deref_lockres_done *)msg->buf; 238460d663cbSxuejiufei struct dlm_lock_resource *res = NULL; 238560d663cbSxuejiufei char *name; 238660d663cbSxuejiufei unsigned int namelen; 238760d663cbSxuejiufei int ret = -EINVAL; 238860d663cbSxuejiufei u8 node; 238960d663cbSxuejiufei unsigned int hash; 239060d663cbSxuejiufei 239160d663cbSxuejiufei if (!dlm_grab(dlm)) 239260d663cbSxuejiufei return 0; 239360d663cbSxuejiufei 239460d663cbSxuejiufei name = deref->name; 239560d663cbSxuejiufei namelen = deref->namelen; 239660d663cbSxuejiufei node = deref->node_idx; 239760d663cbSxuejiufei 239860d663cbSxuejiufei if (namelen > DLM_LOCKID_NAME_MAX) { 239960d663cbSxuejiufei mlog(ML_ERROR, "Invalid name length!"); 240060d663cbSxuejiufei goto done; 240160d663cbSxuejiufei } 240260d663cbSxuejiufei if (deref->node_idx >= O2NM_MAX_NODES) { 240360d663cbSxuejiufei mlog(ML_ERROR, "Invalid node number: %u\n", node); 240460d663cbSxuejiufei goto done; 240560d663cbSxuejiufei } 240660d663cbSxuejiufei 240760d663cbSxuejiufei hash = dlm_lockid_hash(name, namelen); 240860d663cbSxuejiufei 240960d663cbSxuejiufei spin_lock(&dlm->spinlock); 241060d663cbSxuejiufei res = __dlm_lookup_lockres_full(dlm, name, namelen, hash); 241160d663cbSxuejiufei if (!res) { 241260d663cbSxuejiufei spin_unlock(&dlm->spinlock); 241360d663cbSxuejiufei mlog(ML_ERROR, "%s:%.*s: bad lockres name\n", 241460d663cbSxuejiufei dlm->name, namelen, name); 241560d663cbSxuejiufei goto done; 241660d663cbSxuejiufei } 241760d663cbSxuejiufei 241860d663cbSxuejiufei spin_lock(&res->spinlock); 241960d663cbSxuejiufei BUG_ON(!(res->state & DLM_LOCK_RES_DROPPING_REF)); 242060d663cbSxuejiufei if (!list_empty(&res->purge)) { 242160d663cbSxuejiufei mlog(0, "%s: Removing res %.*s from purgelist\n", 242260d663cbSxuejiufei dlm->name, res->lockname.len, res->lockname.name); 242360d663cbSxuejiufei list_del_init(&res->purge); 242460d663cbSxuejiufei dlm_lockres_put(res); 242560d663cbSxuejiufei dlm->purge_count--; 242660d663cbSxuejiufei } 242760d663cbSxuejiufei 242860d663cbSxuejiufei if (!__dlm_lockres_unused(res)) { 242960d663cbSxuejiufei mlog(ML_ERROR, "%s: res %.*s in use after deref\n", 243060d663cbSxuejiufei dlm->name, res->lockname.len, res->lockname.name); 243160d663cbSxuejiufei __dlm_print_one_lock_resource(res); 243260d663cbSxuejiufei BUG(); 243360d663cbSxuejiufei } 243460d663cbSxuejiufei 243560d663cbSxuejiufei __dlm_unhash_lockres(dlm, res); 243660d663cbSxuejiufei 243760d663cbSxuejiufei spin_lock(&dlm->track_lock); 243860d663cbSxuejiufei if (!list_empty(&res->tracking)) 243960d663cbSxuejiufei list_del_init(&res->tracking); 244060d663cbSxuejiufei else { 244160d663cbSxuejiufei mlog(ML_ERROR, "%s: Resource %.*s not on the Tracking list\n", 244260d663cbSxuejiufei dlm->name, res->lockname.len, res->lockname.name); 244360d663cbSxuejiufei __dlm_print_one_lock_resource(res); 244460d663cbSxuejiufei } 244560d663cbSxuejiufei spin_unlock(&dlm->track_lock); 244660d663cbSxuejiufei 244760d663cbSxuejiufei /* lockres is not in the hash now. drop the flag and wake up 244860d663cbSxuejiufei * any processes waiting in dlm_get_lock_resource. 244960d663cbSxuejiufei */ 245060d663cbSxuejiufei res->state &= ~DLM_LOCK_RES_DROPPING_REF; 245160d663cbSxuejiufei spin_unlock(&res->spinlock); 245260d663cbSxuejiufei wake_up(&res->wq); 245360d663cbSxuejiufei 245460d663cbSxuejiufei dlm_lockres_put(res); 245560d663cbSxuejiufei 245660d663cbSxuejiufei spin_unlock(&dlm->spinlock); 245760d663cbSxuejiufei 245860d663cbSxuejiufei done: 245960d663cbSxuejiufei dlm_put(dlm); 246060d663cbSxuejiufei return ret; 246160d663cbSxuejiufei } 246260d663cbSxuejiufei 246360d663cbSxuejiufei static void dlm_drop_lockres_ref_done(struct dlm_ctxt *dlm, 246460d663cbSxuejiufei struct dlm_lock_resource *res, u8 node) 246560d663cbSxuejiufei { 246660d663cbSxuejiufei struct dlm_deref_lockres_done deref; 246760d663cbSxuejiufei int ret = 0, r; 246860d663cbSxuejiufei const char *lockname; 246960d663cbSxuejiufei unsigned int namelen; 247060d663cbSxuejiufei 247160d663cbSxuejiufei lockname = res->lockname.name; 247260d663cbSxuejiufei namelen = res->lockname.len; 247360d663cbSxuejiufei BUG_ON(namelen > O2NM_MAX_NAME_LEN); 247460d663cbSxuejiufei 247560d663cbSxuejiufei memset(&deref, 0, sizeof(deref)); 247660d663cbSxuejiufei deref.node_idx = dlm->node_num; 247760d663cbSxuejiufei deref.namelen = namelen; 247860d663cbSxuejiufei memcpy(deref.name, lockname, namelen); 247960d663cbSxuejiufei 248060d663cbSxuejiufei ret = o2net_send_message(DLM_DEREF_LOCKRES_DONE, dlm->key, 248160d663cbSxuejiufei &deref, sizeof(deref), node, &r); 248260d663cbSxuejiufei if (ret < 0) { 248360d663cbSxuejiufei mlog(ML_ERROR, "%s: res %.*s, error %d send DEREF DONE " 248460d663cbSxuejiufei " to node %u\n", dlm->name, namelen, 248560d663cbSxuejiufei lockname, ret, node); 248660d663cbSxuejiufei } else if (r < 0) { 248760d663cbSxuejiufei /* ignore the error */ 248860d663cbSxuejiufei mlog(ML_ERROR, "%s: res %.*s, DEREF to node %u got %d\n", 248960d663cbSxuejiufei dlm->name, namelen, lockname, node, r); 249060d663cbSxuejiufei dlm_print_one_lock_resource(res); 249160d663cbSxuejiufei } 249260d663cbSxuejiufei } 249360d663cbSxuejiufei 2494f3f85464SSunil Mushran static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data) 2495f3f85464SSunil Mushran { 2496f3f85464SSunil Mushran struct dlm_ctxt *dlm; 2497f3f85464SSunil Mushran struct dlm_lock_resource *res; 2498f3f85464SSunil Mushran u8 node; 2499f3f85464SSunil Mushran u8 cleared = 0; 2500f3f85464SSunil Mushran 2501f3f85464SSunil Mushran dlm = item->dlm; 2502f3f85464SSunil Mushran res = item->u.dl.deref_res; 2503f3f85464SSunil Mushran node = item->u.dl.deref_node; 2504f3f85464SSunil Mushran 2505f3f85464SSunil Mushran spin_lock(&res->spinlock); 2506f3f85464SSunil Mushran BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF); 2507f3f85464SSunil Mushran __dlm_wait_on_lockres_flags(res, DLM_LOCK_RES_SETREF_INPROG); 2508b5560143Sjiangyiwen if (test_bit(node, res->refmap)) { 25098d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, node); 2510f3f85464SSunil Mushran cleared = 1; 2511f3f85464SSunil Mushran } 2512f3f85464SSunil Mushran spin_unlock(&res->spinlock); 2513f3f85464SSunil Mushran 2514842b90b6Sxuejiufei dlm_drop_lockres_ref_done(dlm, res, node); 2515842b90b6Sxuejiufei 2516f3f85464SSunil Mushran if (cleared) { 2517f3f85464SSunil Mushran mlog(0, "%s:%.*s node %u ref dropped in dispatch\n", 2518f3f85464SSunil Mushran dlm->name, res->lockname.len, res->lockname.name, node); 2519f3f85464SSunil Mushran dlm_lockres_calc_usage(dlm, res); 2520f3f85464SSunil Mushran } else { 2521f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref " 2522f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name, 2523f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node); 25242af37ce8STao Ma dlm_print_one_lock_resource(res); 2525f3f85464SSunil Mushran } 2526f3f85464SSunil Mushran 2527f3f85464SSunil Mushran dlm_lockres_put(res); 2528f3f85464SSunil Mushran } 2529f3f85464SSunil Mushran 25309f62e960SSunil Mushran /* 25319f62e960SSunil Mushran * A migrateable resource is one that is : 25329f62e960SSunil Mushran * 1. locally mastered, and, 25339f62e960SSunil Mushran * 2. zero local locks, and, 25349f62e960SSunil Mushran * 3. one or more non-local locks, or, one or more references 25359f62e960SSunil Mushran * Returns 1 if yes, 0 if not. 25362f5bf1f2SSunil Mushran */ 25372f5bf1f2SSunil Mushran static int dlm_is_lockres_migrateable(struct dlm_ctxt *dlm, 25389f62e960SSunil Mushran struct dlm_lock_resource *res) 25392f5bf1f2SSunil Mushran { 25409f62e960SSunil Mushran enum dlm_lockres_list idx; 25419f62e960SSunil Mushran int nonlocal = 0, node_ref; 2542800deef3SChristoph Hellwig struct list_head *queue; 25432f5bf1f2SSunil Mushran struct dlm_lock *lock; 25449f62e960SSunil Mushran u64 cookie; 25452f5bf1f2SSunil Mushran 25462f5bf1f2SSunil Mushran assert_spin_locked(&res->spinlock); 25472f5bf1f2SSunil Mushran 2548fae477b6SXue jiufei /* delay migration when the lockres is in MIGRATING state */ 2549fae477b6SXue jiufei if (res->state & DLM_LOCK_RES_MIGRATING) 2550fae477b6SXue jiufei return 0; 2551fae477b6SXue jiufei 2552bba1cb17STariq Saeed /* delay migration when the lockres is in RECOCERING state */ 2553bba1cb17STariq Saeed if (res->state & DLM_LOCK_RES_RECOVERING) 2554bba1cb17STariq Saeed return 0; 2555bba1cb17STariq Saeed 25569f62e960SSunil Mushran if (res->owner != dlm->node_num) 25579f62e960SSunil Mushran return 0; 2558388c4bcbSSunil Mushran 25599f62e960SSunil Mushran for (idx = DLM_GRANTED_LIST; idx <= DLM_BLOCKED_LIST; idx++) { 25609f62e960SSunil Mushran queue = dlm_list_idx_to_ptr(res, idx); 2561800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) { 25629f62e960SSunil Mushran if (lock->ml.node != dlm->node_num) { 25639f62e960SSunil Mushran nonlocal++; 25649f62e960SSunil Mushran continue; 25659f62e960SSunil Mushran } 25669f62e960SSunil Mushran cookie = be64_to_cpu(lock->ml.cookie); 25679f62e960SSunil Mushran mlog(0, "%s: Not migrateable res %.*s, lock %u:%llu on " 25689f62e960SSunil Mushran "%s list\n", dlm->name, res->lockname.len, 25699f62e960SSunil Mushran res->lockname.name, 25709f62e960SSunil Mushran dlm_get_lock_cookie_node(cookie), 25719f62e960SSunil Mushran dlm_get_lock_cookie_seq(cookie), 25729f62e960SSunil Mushran dlm_list_in_text(idx)); 25739f62e960SSunil Mushran return 0; 25742f5bf1f2SSunil Mushran } 25752f5bf1f2SSunil Mushran } 25769f62e960SSunil Mushran 25779f62e960SSunil Mushran if (!nonlocal) { 25789f62e960SSunil Mushran node_ref = find_next_bit(res->refmap, O2NM_MAX_NODES, 0); 25799f62e960SSunil Mushran if (node_ref >= O2NM_MAX_NODES) 25809f62e960SSunil Mushran return 0; 25812f5bf1f2SSunil Mushran } 25822f5bf1f2SSunil Mushran 25839f62e960SSunil Mushran mlog(0, "%s: res %.*s, Migrateable\n", dlm->name, res->lockname.len, 25849f62e960SSunil Mushran res->lockname.name); 2585388c4bcbSSunil Mushran 25869f62e960SSunil Mushran return 1; 25872f5bf1f2SSunil Mushran } 25886714d8e8SKurt Hackel 25896714d8e8SKurt Hackel /* 25906714d8e8SKurt Hackel * DLM_MIGRATE_LOCKRES 25916714d8e8SKurt Hackel */ 25926714d8e8SKurt Hackel 25936714d8e8SKurt Hackel 2594faf0ec9fSAdrian Bunk static int dlm_migrate_lockres(struct dlm_ctxt *dlm, 259566effd3cSSunil Mushran struct dlm_lock_resource *res, u8 target) 25966714d8e8SKurt Hackel { 25976714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 25986714d8e8SKurt Hackel struct dlm_master_list_entry *oldmle = NULL; 25996714d8e8SKurt Hackel struct dlm_migratable_lockres *mres = NULL; 26002f5bf1f2SSunil Mushran int ret = 0; 26016714d8e8SKurt Hackel const char *name; 26026714d8e8SKurt Hackel unsigned int namelen; 26036714d8e8SKurt Hackel int mle_added = 0; 26042f5bf1f2SSunil Mushran int wake = 0; 26056714d8e8SKurt Hackel 26066714d8e8SKurt Hackel if (!dlm_grab(dlm)) 26076714d8e8SKurt Hackel return -EINVAL; 26086714d8e8SKurt Hackel 260966effd3cSSunil Mushran BUG_ON(target == O2NM_MAX_NODES); 261066effd3cSSunil Mushran 26116714d8e8SKurt Hackel name = res->lockname.name; 26126714d8e8SKurt Hackel namelen = res->lockname.len; 26136714d8e8SKurt Hackel 261466effd3cSSunil Mushran mlog(0, "%s: Migrating %.*s to node %u\n", dlm->name, namelen, name, 261566effd3cSSunil Mushran target); 26166714d8e8SKurt Hackel 261766effd3cSSunil Mushran /* preallocate up front. if this fails, abort */ 26186714d8e8SKurt Hackel ret = -ENOMEM; 2619ad8100e0SKurt Hackel mres = (struct dlm_migratable_lockres *) __get_free_page(GFP_NOFS); 26206714d8e8SKurt Hackel if (!mres) { 26216714d8e8SKurt Hackel mlog_errno(ret); 26226714d8e8SKurt Hackel goto leave; 26236714d8e8SKurt Hackel } 26246714d8e8SKurt Hackel 26253914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 26266714d8e8SKurt Hackel if (!mle) { 26276714d8e8SKurt Hackel mlog_errno(ret); 26286714d8e8SKurt Hackel goto leave; 26296714d8e8SKurt Hackel } 26306714d8e8SKurt Hackel ret = 0; 26316714d8e8SKurt Hackel 26326714d8e8SKurt Hackel /* 26336714d8e8SKurt Hackel * clear any existing master requests and 26346714d8e8SKurt Hackel * add the migration mle to the list 26356714d8e8SKurt Hackel */ 263666effd3cSSunil Mushran spin_lock(&dlm->spinlock); 26376714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 26386714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, name, 26396714d8e8SKurt Hackel namelen, target, dlm->node_num); 2640bef5502dSxuejiufei /* get an extra reference on the mle. 2641bef5502dSxuejiufei * otherwise the assert_master from the new 2642bef5502dSxuejiufei * master will destroy this. 2643bef5502dSxuejiufei */ 2644bef5502dSxuejiufei dlm_get_mle_inuse(mle); 26456714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 26466714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 26476714d8e8SKurt Hackel 26486714d8e8SKurt Hackel if (ret == -EEXIST) { 26496714d8e8SKurt Hackel mlog(0, "another process is already migrating it\n"); 26506714d8e8SKurt Hackel goto fail; 26516714d8e8SKurt Hackel } 26526714d8e8SKurt Hackel mle_added = 1; 26536714d8e8SKurt Hackel 26546714d8e8SKurt Hackel /* 26556714d8e8SKurt Hackel * set the MIGRATING flag and flush asts 26566714d8e8SKurt Hackel * if we fail after this we need to re-dirty the lockres 26576714d8e8SKurt Hackel */ 26586714d8e8SKurt Hackel if (dlm_mark_lockres_migrating(dlm, res, target) < 0) { 26596714d8e8SKurt Hackel mlog(ML_ERROR, "tried to migrate %.*s to %u, but " 26606714d8e8SKurt Hackel "the target went down.\n", res->lockname.len, 26616714d8e8SKurt Hackel res->lockname.name, target); 26626714d8e8SKurt Hackel spin_lock(&res->spinlock); 26636714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2664a6fa3640SKurt Hackel wake = 1; 26656714d8e8SKurt Hackel spin_unlock(&res->spinlock); 26666714d8e8SKurt Hackel ret = -EINVAL; 26676714d8e8SKurt Hackel } 26686714d8e8SKurt Hackel 26696714d8e8SKurt Hackel fail: 267032e49326Sxuejiufei if (ret != -EEXIST && oldmle) { 26716714d8e8SKurt Hackel /* master is known, detach if not already detached */ 26726714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle); 26736714d8e8SKurt Hackel dlm_put_mle(oldmle); 26746714d8e8SKurt Hackel } 26756714d8e8SKurt Hackel 26766714d8e8SKurt Hackel if (ret < 0) { 26776714d8e8SKurt Hackel if (mle_added) { 26786714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 26796714d8e8SKurt Hackel dlm_put_mle(mle); 2680bef5502dSxuejiufei dlm_put_mle_inuse(mle); 26816714d8e8SKurt Hackel } else if (mle) { 26826714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 268366effd3cSSunil Mushran mle = NULL; 26846714d8e8SKurt Hackel } 26856714d8e8SKurt Hackel goto leave; 26866714d8e8SKurt Hackel } 26876714d8e8SKurt Hackel 26886714d8e8SKurt Hackel /* 26896714d8e8SKurt Hackel * at this point, we have a migration target, an mle 26906714d8e8SKurt Hackel * in the master list, and the MIGRATING flag set on 26916714d8e8SKurt Hackel * the lockres 26926714d8e8SKurt Hackel */ 26936714d8e8SKurt Hackel 26941cd04dbeSKurt Hackel /* now that remote nodes are spinning on the MIGRATING flag, 26951cd04dbeSKurt Hackel * ensure that all assert_master work is flushed. */ 26961cd04dbeSKurt Hackel flush_workqueue(dlm->dlm_worker); 26976714d8e8SKurt Hackel 26986714d8e8SKurt Hackel /* notify new node and send all lock state */ 26996714d8e8SKurt Hackel /* call send_one_lockres with migration flag. 27006714d8e8SKurt Hackel * this serves as notice to the target node that a 27016714d8e8SKurt Hackel * migration is starting. */ 27026714d8e8SKurt Hackel ret = dlm_send_one_lockres(dlm, res, mres, target, 27036714d8e8SKurt Hackel DLM_MRES_MIGRATION); 27046714d8e8SKurt Hackel 27056714d8e8SKurt Hackel if (ret < 0) { 27066714d8e8SKurt Hackel mlog(0, "migration to node %u failed with %d\n", 27076714d8e8SKurt Hackel target, ret); 27086714d8e8SKurt Hackel /* migration failed, detach and clean up mle */ 27096714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 27106714d8e8SKurt Hackel dlm_put_mle(mle); 2711a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 2712a2bf0477SKurt Hackel spin_lock(&res->spinlock); 2713a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2714a6fa3640SKurt Hackel wake = 1; 2715a2bf0477SKurt Hackel spin_unlock(&res->spinlock); 2716df016c66SSunil Mushran if (dlm_is_host_down(ret)) 2717df016c66SSunil Mushran dlm_wait_for_node_death(dlm, target, 2718df016c66SSunil Mushran DLM_NODE_DEATH_WAIT_MAX); 27196714d8e8SKurt Hackel goto leave; 27206714d8e8SKurt Hackel } 27216714d8e8SKurt Hackel 27226714d8e8SKurt Hackel /* at this point, the target sends a message to all nodes, 27236714d8e8SKurt Hackel * (using dlm_do_migrate_request). this node is skipped since 27246714d8e8SKurt Hackel * we had to put an mle in the list to begin the process. this 27256714d8e8SKurt Hackel * node now waits for target to do an assert master. this node 27266714d8e8SKurt Hackel * will be the last one notified, ensuring that the migration 27276714d8e8SKurt Hackel * is complete everywhere. if the target dies while this is 27286714d8e8SKurt Hackel * going on, some nodes could potentially see the target as the 27296714d8e8SKurt Hackel * master, so it is important that my recovery finds the migration 2730af901ca1SAndré Goddard Rosa * mle and sets the master to UNKNOWN. */ 27316714d8e8SKurt Hackel 27326714d8e8SKurt Hackel 27336714d8e8SKurt Hackel /* wait for new node to assert master */ 27346714d8e8SKurt Hackel while (1) { 27356714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(mle->wq, 27366714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1), 27376714d8e8SKurt Hackel msecs_to_jiffies(5000)); 27386714d8e8SKurt Hackel 27396714d8e8SKurt Hackel if (ret >= 0) { 27406714d8e8SKurt Hackel if (atomic_read(&mle->woken) == 1 || 27416714d8e8SKurt Hackel res->owner == target) 27426714d8e8SKurt Hackel break; 27436714d8e8SKurt Hackel 27441cd04dbeSKurt Hackel mlog(0, "%s:%.*s: timed out during migration\n", 27451cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 2746e2faea4cSKurt Hackel /* avoid hang during shutdown when migrating lockres 2747e2faea4cSKurt Hackel * to a node which also goes down */ 2748e2faea4cSKurt Hackel if (dlm_is_node_dead(dlm, target)) { 2749aa852354SKurt Hackel mlog(0, "%s:%.*s: expected migration " 2750aa852354SKurt Hackel "target %u is no longer up, restarting\n", 2751e2faea4cSKurt Hackel dlm->name, res->lockname.len, 2752e2faea4cSKurt Hackel res->lockname.name, target); 27531cd04dbeSKurt Hackel ret = -EINVAL; 27546714d8e8SKurt Hackel /* migration failed, detach and clean up mle */ 27556714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 27566714d8e8SKurt Hackel dlm_put_mle(mle); 2757a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 2758a2bf0477SKurt Hackel spin_lock(&res->spinlock); 2759a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2760a6fa3640SKurt Hackel wake = 1; 2761a2bf0477SKurt Hackel spin_unlock(&res->spinlock); 27626714d8e8SKurt Hackel goto leave; 27636714d8e8SKurt Hackel } 27641cd04dbeSKurt Hackel } else 27651cd04dbeSKurt Hackel mlog(0, "%s:%.*s: caught signal during migration\n", 27661cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 27676714d8e8SKurt Hackel } 27686714d8e8SKurt Hackel 27696714d8e8SKurt Hackel /* all done, set the owner, clear the flag */ 27706714d8e8SKurt Hackel spin_lock(&res->spinlock); 27716714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, target); 27726714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 27736714d8e8SKurt Hackel dlm_remove_nonlocal_locks(dlm, res); 27746714d8e8SKurt Hackel spin_unlock(&res->spinlock); 27756714d8e8SKurt Hackel wake_up(&res->wq); 27766714d8e8SKurt Hackel 27776714d8e8SKurt Hackel /* master is known, detach if not already detached */ 27786714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 2779a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 27806714d8e8SKurt Hackel ret = 0; 27816714d8e8SKurt Hackel 27826714d8e8SKurt Hackel dlm_lockres_calc_usage(dlm, res); 27836714d8e8SKurt Hackel 27846714d8e8SKurt Hackel leave: 27856714d8e8SKurt Hackel /* re-dirty the lockres if we failed */ 27866714d8e8SKurt Hackel if (ret < 0) 27876714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 27886714d8e8SKurt Hackel 2789a6fa3640SKurt Hackel /* wake up waiters if the MIGRATING flag got set 2790a6fa3640SKurt Hackel * but migration failed */ 2791a6fa3640SKurt Hackel if (wake) 2792a6fa3640SKurt Hackel wake_up(&res->wq); 2793a6fa3640SKurt Hackel 27946714d8e8SKurt Hackel if (mres) 27956714d8e8SKurt Hackel free_page((unsigned long)mres); 27966714d8e8SKurt Hackel 27976714d8e8SKurt Hackel dlm_put(dlm); 27986714d8e8SKurt Hackel 27999f62e960SSunil Mushran mlog(0, "%s: Migrating %.*s to %u, returns %d\n", dlm->name, namelen, 28009f62e960SSunil Mushran name, target, ret); 28016714d8e8SKurt Hackel return ret; 28026714d8e8SKurt Hackel } 28036714d8e8SKurt Hackel 2804ba2bf218SKurt Hackel #define DLM_MIGRATION_RETRY_MS 100 2805ba2bf218SKurt Hackel 28069f62e960SSunil Mushran /* 28079f62e960SSunil Mushran * Should be called only after beginning the domain leave process. 2808ba2bf218SKurt Hackel * There should not be any remaining locks on nonlocal lock resources, 2809ba2bf218SKurt Hackel * and there should be no local locks left on locally mastered resources. 2810ba2bf218SKurt Hackel * 2811ba2bf218SKurt Hackel * Called with the dlm spinlock held, may drop it to do migration, but 2812ba2bf218SKurt Hackel * will re-acquire before exit. 2813ba2bf218SKurt Hackel * 28149f62e960SSunil Mushran * Returns: 1 if dlm->spinlock was dropped/retaken, 0 if never dropped 28159f62e960SSunil Mushran */ 2816ba2bf218SKurt Hackel int dlm_empty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res) 2817ba2bf218SKurt Hackel { 281866effd3cSSunil Mushran int ret; 2819ba2bf218SKurt Hackel int lock_dropped = 0; 282066effd3cSSunil Mushran u8 target = O2NM_MAX_NODES; 28219f62e960SSunil Mushran 28229f62e960SSunil Mushran assert_spin_locked(&dlm->spinlock); 2823ba2bf218SKurt Hackel 2824b36c3f84SSunil Mushran spin_lock(&res->spinlock); 282566effd3cSSunil Mushran if (dlm_is_lockres_migrateable(dlm, res)) 282666effd3cSSunil Mushran target = dlm_pick_migration_target(dlm, res); 2827b36c3f84SSunil Mushran spin_unlock(&res->spinlock); 282866effd3cSSunil Mushran 282966effd3cSSunil Mushran if (target == O2NM_MAX_NODES) 2830ba2bf218SKurt Hackel goto leave; 2831ba2bf218SKurt Hackel 2832ba2bf218SKurt Hackel /* Wheee! Migrate lockres here! Will sleep so drop spinlock. */ 2833ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2834ba2bf218SKurt Hackel lock_dropped = 1; 283566effd3cSSunil Mushran ret = dlm_migrate_lockres(dlm, res, target); 283666effd3cSSunil Mushran if (ret) 283766effd3cSSunil Mushran mlog(0, "%s: res %.*s, Migrate to node %u failed with %d\n", 283866effd3cSSunil Mushran dlm->name, res->lockname.len, res->lockname.name, 283966effd3cSSunil Mushran target, ret); 2840ba2bf218SKurt Hackel spin_lock(&dlm->spinlock); 2841ba2bf218SKurt Hackel leave: 2842ba2bf218SKurt Hackel return lock_dropped; 2843ba2bf218SKurt Hackel } 2844ba2bf218SKurt Hackel 28456714d8e8SKurt Hackel int dlm_lock_basts_flushed(struct dlm_ctxt *dlm, struct dlm_lock *lock) 28466714d8e8SKurt Hackel { 28476714d8e8SKurt Hackel int ret; 28486714d8e8SKurt Hackel spin_lock(&dlm->ast_lock); 28496714d8e8SKurt Hackel spin_lock(&lock->spinlock); 28506714d8e8SKurt Hackel ret = (list_empty(&lock->bast_list) && !lock->bast_pending); 28516714d8e8SKurt Hackel spin_unlock(&lock->spinlock); 28526714d8e8SKurt Hackel spin_unlock(&dlm->ast_lock); 28536714d8e8SKurt Hackel return ret; 28546714d8e8SKurt Hackel } 28556714d8e8SKurt Hackel 28566714d8e8SKurt Hackel static int dlm_migration_can_proceed(struct dlm_ctxt *dlm, 28576714d8e8SKurt Hackel struct dlm_lock_resource *res, 28586714d8e8SKurt Hackel u8 mig_target) 28596714d8e8SKurt Hackel { 28606714d8e8SKurt Hackel int can_proceed; 28616714d8e8SKurt Hackel spin_lock(&res->spinlock); 28626714d8e8SKurt Hackel can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING); 28636714d8e8SKurt Hackel spin_unlock(&res->spinlock); 28646714d8e8SKurt Hackel 28656714d8e8SKurt Hackel /* target has died, so make the caller break out of the 28666714d8e8SKurt Hackel * wait_event, but caller must recheck the domain_map */ 28676714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 28686714d8e8SKurt Hackel if (!test_bit(mig_target, dlm->domain_map)) 28696714d8e8SKurt Hackel can_proceed = 1; 28706714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 28716714d8e8SKurt Hackel return can_proceed; 28726714d8e8SKurt Hackel } 28736714d8e8SKurt Hackel 2874faf0ec9fSAdrian Bunk static int dlm_lockres_is_dirty(struct dlm_ctxt *dlm, 2875faf0ec9fSAdrian Bunk struct dlm_lock_resource *res) 28766714d8e8SKurt Hackel { 28776714d8e8SKurt Hackel int ret; 28786714d8e8SKurt Hackel spin_lock(&res->spinlock); 28796714d8e8SKurt Hackel ret = !!(res->state & DLM_LOCK_RES_DIRTY); 28806714d8e8SKurt Hackel spin_unlock(&res->spinlock); 28816714d8e8SKurt Hackel return ret; 28826714d8e8SKurt Hackel } 28836714d8e8SKurt Hackel 28846714d8e8SKurt Hackel 28856714d8e8SKurt Hackel static int dlm_mark_lockres_migrating(struct dlm_ctxt *dlm, 28866714d8e8SKurt Hackel struct dlm_lock_resource *res, 28876714d8e8SKurt Hackel u8 target) 28886714d8e8SKurt Hackel { 28896714d8e8SKurt Hackel int ret = 0; 28906714d8e8SKurt Hackel 28916714d8e8SKurt Hackel mlog(0, "dlm_mark_lockres_migrating: %.*s, from %u to %u\n", 28926714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num, 28936714d8e8SKurt Hackel target); 28946714d8e8SKurt Hackel /* need to set MIGRATING flag on lockres. this is done by 28956714d8e8SKurt Hackel * ensuring that all asts have been flushed for this lockres. */ 28966714d8e8SKurt Hackel spin_lock(&res->spinlock); 28976714d8e8SKurt Hackel BUG_ON(res->migration_pending); 28986714d8e8SKurt Hackel res->migration_pending = 1; 28996714d8e8SKurt Hackel /* strategy is to reserve an extra ast then release 29006714d8e8SKurt Hackel * it below, letting the release do all of the work */ 29016714d8e8SKurt Hackel __dlm_lockres_reserve_ast(res); 29026714d8e8SKurt Hackel spin_unlock(&res->spinlock); 29036714d8e8SKurt Hackel 2904ddc09c8dSKurt Hackel /* now flush all the pending asts */ 29056714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 2906ddc09c8dSKurt Hackel /* before waiting on DIRTY, block processes which may 2907ddc09c8dSKurt Hackel * try to dirty the lockres before MIGRATING is set */ 2908ddc09c8dSKurt Hackel spin_lock(&res->spinlock); 2909ddc09c8dSKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_BLOCK_DIRTY); 2910ddc09c8dSKurt Hackel res->state |= DLM_LOCK_RES_BLOCK_DIRTY; 2911ddc09c8dSKurt Hackel spin_unlock(&res->spinlock); 2912ddc09c8dSKurt Hackel /* now wait on any pending asts and the DIRTY state */ 29136714d8e8SKurt Hackel wait_event(dlm->ast_wq, !dlm_lockres_is_dirty(dlm, res)); 29146714d8e8SKurt Hackel dlm_lockres_release_ast(dlm, res); 29156714d8e8SKurt Hackel 29166714d8e8SKurt Hackel mlog(0, "about to wait on migration_wq, dirty=%s\n", 29176714d8e8SKurt Hackel res->state & DLM_LOCK_RES_DIRTY ? "yes" : "no"); 29186714d8e8SKurt Hackel /* if the extra ref we just put was the final one, this 29196714d8e8SKurt Hackel * will pass thru immediately. otherwise, we need to wait 29206714d8e8SKurt Hackel * for the last ast to finish. */ 29216714d8e8SKurt Hackel again: 29226714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(dlm->migration_wq, 29236714d8e8SKurt Hackel dlm_migration_can_proceed(dlm, res, target), 29246714d8e8SKurt Hackel msecs_to_jiffies(1000)); 29256714d8e8SKurt Hackel if (ret < 0) { 29266714d8e8SKurt Hackel mlog(0, "woken again: migrating? %s, dead? %s\n", 29276714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no", 29286714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes"); 29296714d8e8SKurt Hackel } else { 29306714d8e8SKurt Hackel mlog(0, "all is well: migrating? %s, dead? %s\n", 29316714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no", 29326714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes"); 29336714d8e8SKurt Hackel } 29346714d8e8SKurt Hackel if (!dlm_migration_can_proceed(dlm, res, target)) { 29356714d8e8SKurt Hackel mlog(0, "trying again...\n"); 29366714d8e8SKurt Hackel goto again; 29376714d8e8SKurt Hackel } 29386714d8e8SKurt Hackel 2939a39953ddSWengang Wang ret = 0; 29406714d8e8SKurt Hackel /* did the target go down or die? */ 29416714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 29426714d8e8SKurt Hackel if (!test_bit(target, dlm->domain_map)) { 29436714d8e8SKurt Hackel mlog(ML_ERROR, "aha. migration target %u just went down\n", 29446714d8e8SKurt Hackel target); 29456714d8e8SKurt Hackel ret = -EHOSTDOWN; 29466714d8e8SKurt Hackel } 29476714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 29486714d8e8SKurt Hackel 29496714d8e8SKurt Hackel /* 2950a39953ddSWengang Wang * if target is down, we need to clear DLM_LOCK_RES_BLOCK_DIRTY for 2951a39953ddSWengang Wang * another try; otherwise, we are sure the MIGRATING state is there, 2952a39953ddSWengang Wang * drop the unneded state which blocked threads trying to DIRTY 2953a39953ddSWengang Wang */ 2954a39953ddSWengang Wang spin_lock(&res->spinlock); 2955a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_BLOCK_DIRTY)); 2956a39953ddSWengang Wang res->state &= ~DLM_LOCK_RES_BLOCK_DIRTY; 2957a39953ddSWengang Wang if (!ret) 2958a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_MIGRATING)); 2959cc28d6d8Sxuejiufei else 2960cc28d6d8Sxuejiufei res->migration_pending = 0; 2961a39953ddSWengang Wang spin_unlock(&res->spinlock); 2962a39953ddSWengang Wang 2963a39953ddSWengang Wang /* 29646714d8e8SKurt Hackel * at this point: 29656714d8e8SKurt Hackel * 2966a39953ddSWengang Wang * o the DLM_LOCK_RES_MIGRATING flag is set if target not down 29676714d8e8SKurt Hackel * o there are no pending asts on this lockres 29686714d8e8SKurt Hackel * o all processes trying to reserve an ast on this 29696714d8e8SKurt Hackel * lockres must wait for the MIGRATING flag to clear 29706714d8e8SKurt Hackel */ 29716714d8e8SKurt Hackel return ret; 29726714d8e8SKurt Hackel } 29736714d8e8SKurt Hackel 29746714d8e8SKurt Hackel /* last step in the migration process. 29756714d8e8SKurt Hackel * original master calls this to free all of the dlm_lock 29766714d8e8SKurt Hackel * structures that used to be for other nodes. */ 29776714d8e8SKurt Hackel static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm, 29786714d8e8SKurt Hackel struct dlm_lock_resource *res) 29796714d8e8SKurt Hackel { 29806714d8e8SKurt Hackel struct list_head *queue = &res->granted; 2981ba2bf218SKurt Hackel int i, bit; 2982800deef3SChristoph Hellwig struct dlm_lock *lock, *next; 29836714d8e8SKurt Hackel 29846714d8e8SKurt Hackel assert_spin_locked(&res->spinlock); 29856714d8e8SKurt Hackel 29866714d8e8SKurt Hackel BUG_ON(res->owner == dlm->node_num); 29876714d8e8SKurt Hackel 29886714d8e8SKurt Hackel for (i=0; i<3; i++) { 2989800deef3SChristoph Hellwig list_for_each_entry_safe(lock, next, queue, list) { 29906714d8e8SKurt Hackel if (lock->ml.node != dlm->node_num) { 29916714d8e8SKurt Hackel mlog(0, "putting lock for node %u\n", 29926714d8e8SKurt Hackel lock->ml.node); 29936714d8e8SKurt Hackel /* be extra careful */ 29946714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->ast_list)); 29956714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->bast_list)); 29966714d8e8SKurt Hackel BUG_ON(lock->ast_pending); 29976714d8e8SKurt Hackel BUG_ON(lock->bast_pending); 29988d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, 29998d400b81SSunil Mushran lock->ml.node); 30006714d8e8SKurt Hackel list_del_init(&lock->list); 30016714d8e8SKurt Hackel dlm_lock_put(lock); 30022c5c54acSSunil Mushran /* In a normal unlock, we would have added a 30032c5c54acSSunil Mushran * DLM_UNLOCK_FREE_LOCK action. Force it. */ 30042c5c54acSSunil Mushran dlm_lock_put(lock); 30056714d8e8SKurt Hackel } 30066714d8e8SKurt Hackel } 30076714d8e8SKurt Hackel queue++; 30086714d8e8SKurt Hackel } 3009ba2bf218SKurt Hackel bit = 0; 3010ba2bf218SKurt Hackel while (1) { 3011ba2bf218SKurt Hackel bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit); 3012ba2bf218SKurt Hackel if (bit >= O2NM_MAX_NODES) 3013ba2bf218SKurt Hackel break; 3014ba2bf218SKurt Hackel /* do not clear the local node reference, if there is a 3015ba2bf218SKurt Hackel * process holding this, let it drop the ref itself */ 3016ba2bf218SKurt Hackel if (bit != dlm->node_num) { 3017ba2bf218SKurt Hackel mlog(0, "%s:%.*s: node %u had a ref to this " 3018ba2bf218SKurt Hackel "migrating lockres, clearing\n", dlm->name, 3019ba2bf218SKurt Hackel res->lockname.len, res->lockname.name, bit); 30208d400b81SSunil Mushran dlm_lockres_clear_refmap_bit(dlm, res, bit); 3021ba2bf218SKurt Hackel } 3022ba2bf218SKurt Hackel bit++; 3023ba2bf218SKurt Hackel } 30246714d8e8SKurt Hackel } 30256714d8e8SKurt Hackel 302666effd3cSSunil Mushran /* 302766effd3cSSunil Mushran * Pick a node to migrate the lock resource to. This function selects a 302866effd3cSSunil Mushran * potential target based first on the locks and then on refmap. It skips 302966effd3cSSunil Mushran * nodes that are in the process of exiting the domain. 303066effd3cSSunil Mushran */ 30316714d8e8SKurt Hackel static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm, 30326714d8e8SKurt Hackel struct dlm_lock_resource *res) 30336714d8e8SKurt Hackel { 303466effd3cSSunil Mushran enum dlm_lockres_list idx; 30356714d8e8SKurt Hackel struct list_head *queue = &res->granted; 30366714d8e8SKurt Hackel struct dlm_lock *lock; 303766effd3cSSunil Mushran int noderef; 303866effd3cSSunil Mushran u8 nodenum = O2NM_MAX_NODES; 30396714d8e8SKurt Hackel 30406714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 304166effd3cSSunil Mushran assert_spin_locked(&res->spinlock); 30426714d8e8SKurt Hackel 304366effd3cSSunil Mushran /* Go through all the locks */ 304466effd3cSSunil Mushran for (idx = DLM_GRANTED_LIST; idx <= DLM_BLOCKED_LIST; idx++) { 304566effd3cSSunil Mushran queue = dlm_list_idx_to_ptr(res, idx); 3046800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) { 304766effd3cSSunil Mushran if (lock->ml.node == dlm->node_num) 304866effd3cSSunil Mushran continue; 304966effd3cSSunil Mushran if (test_bit(lock->ml.node, dlm->exit_domain_map)) 305066effd3cSSunil Mushran continue; 305166effd3cSSunil Mushran nodenum = lock->ml.node; 305266effd3cSSunil Mushran goto bail; 30536714d8e8SKurt Hackel } 30546714d8e8SKurt Hackel } 3055388c4bcbSSunil Mushran 305666effd3cSSunil Mushran /* Go thru the refmap */ 305766effd3cSSunil Mushran noderef = -1; 30586714d8e8SKurt Hackel while (1) { 305966effd3cSSunil Mushran noderef = find_next_bit(res->refmap, O2NM_MAX_NODES, 306066effd3cSSunil Mushran noderef + 1); 306166effd3cSSunil Mushran if (noderef >= O2NM_MAX_NODES) 30626714d8e8SKurt Hackel break; 306366effd3cSSunil Mushran if (noderef == dlm->node_num) 306466effd3cSSunil Mushran continue; 306566effd3cSSunil Mushran if (test_bit(noderef, dlm->exit_domain_map)) 306666effd3cSSunil Mushran continue; 306766effd3cSSunil Mushran nodenum = noderef; 306866effd3cSSunil Mushran goto bail; 306966effd3cSSunil Mushran } 307066effd3cSSunil Mushran 307166effd3cSSunil Mushran bail: 30726714d8e8SKurt Hackel return nodenum; 30736714d8e8SKurt Hackel } 30746714d8e8SKurt Hackel 30756714d8e8SKurt Hackel /* this is called by the new master once all lockres 30766714d8e8SKurt Hackel * data has been received */ 30776714d8e8SKurt Hackel static int dlm_do_migrate_request(struct dlm_ctxt *dlm, 30786714d8e8SKurt Hackel struct dlm_lock_resource *res, 30796714d8e8SKurt Hackel u8 master, u8 new_master, 30806714d8e8SKurt Hackel struct dlm_node_iter *iter) 30816714d8e8SKurt Hackel { 30826714d8e8SKurt Hackel struct dlm_migrate_request migrate; 30832b832564SSunil Mushran int ret, skip, status = 0; 30846714d8e8SKurt Hackel int nodenum; 30856714d8e8SKurt Hackel 30866714d8e8SKurt Hackel memset(&migrate, 0, sizeof(migrate)); 30876714d8e8SKurt Hackel migrate.namelen = res->lockname.len; 30886714d8e8SKurt Hackel memcpy(migrate.name, res->lockname.name, migrate.namelen); 30896714d8e8SKurt Hackel migrate.new_master = new_master; 30906714d8e8SKurt Hackel migrate.master = master; 30916714d8e8SKurt Hackel 30926714d8e8SKurt Hackel ret = 0; 30936714d8e8SKurt Hackel 30946714d8e8SKurt Hackel /* send message to all nodes, except the master and myself */ 30956714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(iter)) >= 0) { 30966714d8e8SKurt Hackel if (nodenum == master || 30976714d8e8SKurt Hackel nodenum == new_master) 30986714d8e8SKurt Hackel continue; 30996714d8e8SKurt Hackel 31002b832564SSunil Mushran /* We could race exit domain. If exited, skip. */ 31012b832564SSunil Mushran spin_lock(&dlm->spinlock); 31022b832564SSunil Mushran skip = (!test_bit(nodenum, dlm->domain_map)); 31032b832564SSunil Mushran spin_unlock(&dlm->spinlock); 31042b832564SSunil Mushran if (skip) { 31052b832564SSunil Mushran clear_bit(nodenum, iter->node_map); 31062b832564SSunil Mushran continue; 31072b832564SSunil Mushran } 31082b832564SSunil Mushran 31096714d8e8SKurt Hackel ret = o2net_send_message(DLM_MIGRATE_REQUEST_MSG, dlm->key, 31106714d8e8SKurt Hackel &migrate, sizeof(migrate), nodenum, 31116714d8e8SKurt Hackel &status); 31122b832564SSunil Mushran if (ret < 0) { 31138decab3cSSunil Mushran mlog(ML_ERROR, "%s: res %.*s, Error %d send " 31148decab3cSSunil Mushran "MIGRATE_REQUEST to node %u\n", dlm->name, 31158decab3cSSunil Mushran migrate.namelen, migrate.name, ret, nodenum); 31162b832564SSunil Mushran if (!dlm_is_host_down(ret)) { 31172b832564SSunil Mushran mlog(ML_ERROR, "unhandled error=%d!\n", ret); 31182b832564SSunil Mushran BUG(); 31192b832564SSunil Mushran } 31202b832564SSunil Mushran clear_bit(nodenum, iter->node_map); 31212b832564SSunil Mushran ret = 0; 31222b832564SSunil Mushran } else if (status < 0) { 31236714d8e8SKurt Hackel mlog(0, "migrate request (node %u) returned %d!\n", 31246714d8e8SKurt Hackel nodenum, status); 31256714d8e8SKurt Hackel ret = status; 3126ba2bf218SKurt Hackel } else if (status == DLM_MIGRATE_RESPONSE_MASTERY_REF) { 3127ba2bf218SKurt Hackel /* during the migration request we short-circuited 3128ba2bf218SKurt Hackel * the mastery of the lockres. make sure we have 3129ba2bf218SKurt Hackel * a mastery ref for nodenum */ 3130ba2bf218SKurt Hackel mlog(0, "%s:%.*s: need ref for node %u\n", 3131ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 3132ba2bf218SKurt Hackel nodenum); 3133ba2bf218SKurt Hackel spin_lock(&res->spinlock); 31348d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, nodenum); 3135ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 31366714d8e8SKurt Hackel } 31376714d8e8SKurt Hackel } 31386714d8e8SKurt Hackel 31396714d8e8SKurt Hackel if (ret < 0) 31406714d8e8SKurt Hackel mlog_errno(ret); 31416714d8e8SKurt Hackel 31426714d8e8SKurt Hackel mlog(0, "returning ret=%d\n", ret); 31436714d8e8SKurt Hackel return ret; 31446714d8e8SKurt Hackel } 31456714d8e8SKurt Hackel 31466714d8e8SKurt Hackel 31476714d8e8SKurt Hackel /* if there is an existing mle for this lockres, we now know who the master is. 31486714d8e8SKurt Hackel * (the one who sent us *this* message) we can clear it up right away. 31496714d8e8SKurt Hackel * since the process that put the mle on the list still has a reference to it, 31506714d8e8SKurt Hackel * we can unhash it now, set the master and wake the process. as a result, 31516714d8e8SKurt Hackel * we will have no mle in the list to start with. now we can add an mle for 31526714d8e8SKurt Hackel * the migration and this should be the only one found for those scanning the 31536714d8e8SKurt Hackel * list. */ 3154d74c9803SKurt Hackel int dlm_migrate_request_handler(struct o2net_msg *msg, u32 len, void *data, 3155d74c9803SKurt Hackel void **ret_data) 31566714d8e8SKurt Hackel { 31576714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 31586714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL; 31596714d8e8SKurt Hackel struct dlm_migrate_request *migrate = (struct dlm_migrate_request *) msg->buf; 31606714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *oldmle = NULL; 31616714d8e8SKurt Hackel const char *name; 3162a3d33291SMark Fasheh unsigned int namelen, hash; 31636714d8e8SKurt Hackel int ret = 0; 31646714d8e8SKurt Hackel 31656714d8e8SKurt Hackel if (!dlm_grab(dlm)) 3166c372f219SXue jiufei return 0; 31676714d8e8SKurt Hackel 31686714d8e8SKurt Hackel name = migrate->name; 31696714d8e8SKurt Hackel namelen = migrate->namelen; 3170a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 31716714d8e8SKurt Hackel 31726714d8e8SKurt Hackel /* preallocate.. if this fails, abort */ 31733914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 31746714d8e8SKurt Hackel 31756714d8e8SKurt Hackel if (!mle) { 31766714d8e8SKurt Hackel ret = -ENOMEM; 31776714d8e8SKurt Hackel goto leave; 31786714d8e8SKurt Hackel } 31796714d8e8SKurt Hackel 31806714d8e8SKurt Hackel /* check for pre-existing lock */ 31816714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 3182a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 31836714d8e8SKurt Hackel if (res) { 31846714d8e8SKurt Hackel spin_lock(&res->spinlock); 31856714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) { 31866714d8e8SKurt Hackel /* if all is working ok, this can only mean that we got 31876714d8e8SKurt Hackel * a migrate request from a node that we now see as 31886714d8e8SKurt Hackel * dead. what can we do here? drop it to the floor? */ 31896714d8e8SKurt Hackel spin_unlock(&res->spinlock); 31906714d8e8SKurt Hackel mlog(ML_ERROR, "Got a migrate request, but the " 31916714d8e8SKurt Hackel "lockres is marked as recovering!"); 31926714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 31936714d8e8SKurt Hackel ret = -EINVAL; /* need a better solution */ 31946714d8e8SKurt Hackel goto unlock; 31956714d8e8SKurt Hackel } 31966714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING; 31976714d8e8SKurt Hackel spin_unlock(&res->spinlock); 31986714d8e8SKurt Hackel } 31996714d8e8SKurt Hackel 32006d98c3ccSWengang Wang spin_lock(&dlm->master_lock); 32016714d8e8SKurt Hackel /* ignore status. only nonzero status would BUG. */ 32026714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, 32036714d8e8SKurt Hackel name, namelen, 32046714d8e8SKurt Hackel migrate->new_master, 32056714d8e8SKurt Hackel migrate->master); 32066714d8e8SKurt Hackel 32076714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 32086d98c3ccSWengang Wang unlock: 32096714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 32106714d8e8SKurt Hackel 32116714d8e8SKurt Hackel if (oldmle) { 32126714d8e8SKurt Hackel /* master is known, detach if not already detached */ 32136714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle); 32146714d8e8SKurt Hackel dlm_put_mle(oldmle); 32156714d8e8SKurt Hackel } 32166714d8e8SKurt Hackel 32176714d8e8SKurt Hackel if (res) 32186714d8e8SKurt Hackel dlm_lockres_put(res); 32196714d8e8SKurt Hackel leave: 32206714d8e8SKurt Hackel dlm_put(dlm); 32216714d8e8SKurt Hackel return ret; 32226714d8e8SKurt Hackel } 32236714d8e8SKurt Hackel 32246714d8e8SKurt Hackel /* must be holding dlm->spinlock and dlm->master_lock 32256714d8e8SKurt Hackel * when adding a migration mle, we can clear any other mles 32266714d8e8SKurt Hackel * in the master list because we know with certainty that 32276714d8e8SKurt Hackel * the master is "master". so we remove any old mle from 32286714d8e8SKurt Hackel * the list after setting it's master field, and then add 32296714d8e8SKurt Hackel * the new migration mle. this way we can hold with the rule 32306714d8e8SKurt Hackel * of having only one mle for a given lock name at all times. */ 32316714d8e8SKurt Hackel static int dlm_add_migration_mle(struct dlm_ctxt *dlm, 32326714d8e8SKurt Hackel struct dlm_lock_resource *res, 32336714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 32346714d8e8SKurt Hackel struct dlm_master_list_entry **oldmle, 32356714d8e8SKurt Hackel const char *name, unsigned int namelen, 32366714d8e8SKurt Hackel u8 new_master, u8 master) 32376714d8e8SKurt Hackel { 32386714d8e8SKurt Hackel int found; 32396714d8e8SKurt Hackel int ret = 0; 32406714d8e8SKurt Hackel 32416714d8e8SKurt Hackel *oldmle = NULL; 32426714d8e8SKurt Hackel 32436714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 32446714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 32456714d8e8SKurt Hackel 32466714d8e8SKurt Hackel /* caller is responsible for any ref taken here on oldmle */ 32476714d8e8SKurt Hackel found = dlm_find_mle(dlm, oldmle, (char *)name, namelen); 32486714d8e8SKurt Hackel if (found) { 32496714d8e8SKurt Hackel struct dlm_master_list_entry *tmp = *oldmle; 32506714d8e8SKurt Hackel spin_lock(&tmp->spinlock); 32516714d8e8SKurt Hackel if (tmp->type == DLM_MLE_MIGRATION) { 32526714d8e8SKurt Hackel if (master == dlm->node_num) { 32536714d8e8SKurt Hackel /* ah another process raced me to it */ 32546714d8e8SKurt Hackel mlog(0, "tried to migrate %.*s, but some " 32556714d8e8SKurt Hackel "process beat me to it\n", 32566714d8e8SKurt Hackel namelen, name); 325732e49326Sxuejiufei spin_unlock(&tmp->spinlock); 325832e49326Sxuejiufei return -EEXIST; 32596714d8e8SKurt Hackel } else { 32606714d8e8SKurt Hackel /* bad. 2 NODES are trying to migrate! */ 32616714d8e8SKurt Hackel mlog(ML_ERROR, "migration error mle: " 32626714d8e8SKurt Hackel "master=%u new_master=%u // request: " 32636714d8e8SKurt Hackel "master=%u new_master=%u // " 32646714d8e8SKurt Hackel "lockres=%.*s\n", 32656714d8e8SKurt Hackel tmp->master, tmp->new_master, 32666714d8e8SKurt Hackel master, new_master, 32676714d8e8SKurt Hackel namelen, name); 32686714d8e8SKurt Hackel BUG(); 32696714d8e8SKurt Hackel } 32706714d8e8SKurt Hackel } else { 32716714d8e8SKurt Hackel /* this is essentially what assert_master does */ 32726714d8e8SKurt Hackel tmp->master = master; 32736714d8e8SKurt Hackel atomic_set(&tmp->woken, 1); 32746714d8e8SKurt Hackel wake_up(&tmp->wq); 32751c084577SSunil Mushran /* remove it so that only one mle will be found */ 32761c084577SSunil Mushran __dlm_unlink_mle(dlm, tmp); 3277ba2bf218SKurt Hackel __dlm_mle_detach_hb_events(dlm, tmp); 3278b9aaac5aSjiangyiwen if (tmp->type == DLM_MLE_MASTER) { 3279ba2bf218SKurt Hackel ret = DLM_MIGRATE_RESPONSE_MASTERY_REF; 3280ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master=%u, newmaster=%u, " 3281b9aaac5aSjiangyiwen "telling master to get ref " 3282b9aaac5aSjiangyiwen "for cleared out mle during " 3283b9aaac5aSjiangyiwen "migration\n", dlm->name, 3284b9aaac5aSjiangyiwen namelen, name, master, 3285b9aaac5aSjiangyiwen new_master); 3286b9aaac5aSjiangyiwen } 32876714d8e8SKurt Hackel } 32886714d8e8SKurt Hackel spin_unlock(&tmp->spinlock); 32896714d8e8SKurt Hackel } 32906714d8e8SKurt Hackel 32916714d8e8SKurt Hackel /* now add a migration mle to the tail of the list */ 32926714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MIGRATION, dlm, res, name, namelen); 32936714d8e8SKurt Hackel mle->new_master = new_master; 3294ba2bf218SKurt Hackel /* the new master will be sending an assert master for this. 3295ba2bf218SKurt Hackel * at that point we will get the refmap reference */ 32966714d8e8SKurt Hackel mle->master = master; 32976714d8e8SKurt Hackel /* do this for consistency with other mle types */ 32986714d8e8SKurt Hackel set_bit(new_master, mle->maybe_map); 32991c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 33006714d8e8SKurt Hackel 33016714d8e8SKurt Hackel return ret; 33026714d8e8SKurt Hackel } 33036714d8e8SKurt Hackel 3304c2cd4a44SSunil Mushran /* 3305c2cd4a44SSunil Mushran * Sets the owner of the lockres, associated to the mle, to UNKNOWN 3306c2cd4a44SSunil Mushran */ 3307c2cd4a44SSunil Mushran static struct dlm_lock_resource *dlm_reset_mleres_owner(struct dlm_ctxt *dlm, 3308c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle) 3309c2cd4a44SSunil Mushran { 3310c2cd4a44SSunil Mushran struct dlm_lock_resource *res; 3311c2cd4a44SSunil Mushran 3312c2cd4a44SSunil Mushran /* Find the lockres associated to the mle and set its owner to UNK */ 33137141514bSSunil Mushran res = __dlm_lookup_lockres(dlm, mle->mname, mle->mnamelen, 33147141514bSSunil Mushran mle->mnamehash); 3315c2cd4a44SSunil Mushran if (res) { 3316c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock); 3317c2cd4a44SSunil Mushran 3318c2cd4a44SSunil Mushran /* move lockres onto recovery list */ 3319c2cd4a44SSunil Mushran spin_lock(&res->spinlock); 3320c2cd4a44SSunil Mushran dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN); 3321c2cd4a44SSunil Mushran dlm_move_lockres_to_recovery_list(dlm, res); 3322c2cd4a44SSunil Mushran spin_unlock(&res->spinlock); 3323c2cd4a44SSunil Mushran dlm_lockres_put(res); 3324c2cd4a44SSunil Mushran 3325c2cd4a44SSunil Mushran /* about to get rid of mle, detach from heartbeat */ 3326c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3327c2cd4a44SSunil Mushran 3328c2cd4a44SSunil Mushran /* dump the mle */ 3329c2cd4a44SSunil Mushran spin_lock(&dlm->master_lock); 3330c2cd4a44SSunil Mushran __dlm_put_mle(mle); 3331c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock); 3332c2cd4a44SSunil Mushran } 3333c2cd4a44SSunil Mushran 3334c2cd4a44SSunil Mushran return res; 3335c2cd4a44SSunil Mushran } 3336c2cd4a44SSunil Mushran 3337c2cd4a44SSunil Mushran static void dlm_clean_migration_mle(struct dlm_ctxt *dlm, 3338c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle) 3339c2cd4a44SSunil Mushran { 3340c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3341c2cd4a44SSunil Mushran 3342c2cd4a44SSunil Mushran spin_lock(&mle->spinlock); 3343c2cd4a44SSunil Mushran __dlm_unlink_mle(dlm, mle); 3344c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1); 3345c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3346c2cd4a44SSunil Mushran 3347c2cd4a44SSunil Mushran wake_up(&mle->wq); 3348c2cd4a44SSunil Mushran } 3349c2cd4a44SSunil Mushran 3350c2cd4a44SSunil Mushran static void dlm_clean_block_mle(struct dlm_ctxt *dlm, 3351c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle, u8 dead_node) 3352c2cd4a44SSunil Mushran { 3353c2cd4a44SSunil Mushran int bit; 3354c2cd4a44SSunil Mushran 3355c2cd4a44SSunil Mushran BUG_ON(mle->type != DLM_MLE_BLOCK); 3356c2cd4a44SSunil Mushran 3357c2cd4a44SSunil Mushran spin_lock(&mle->spinlock); 3358c2cd4a44SSunil Mushran bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0); 3359c2cd4a44SSunil Mushran if (bit != dead_node) { 3360c2cd4a44SSunil Mushran mlog(0, "mle found, but dead node %u would not have been " 3361c2cd4a44SSunil Mushran "master\n", dead_node); 3362c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3363c2cd4a44SSunil Mushran } else { 3364c2cd4a44SSunil Mushran /* Must drop the refcount by one since the assert_master will 3365c2cd4a44SSunil Mushran * never arrive. This may result in the mle being unlinked and 3366c2cd4a44SSunil Mushran * freed, but there may still be a process waiting in the 3367c2cd4a44SSunil Mushran * dlmlock path which is fine. */ 3368c2cd4a44SSunil Mushran mlog(0, "node %u was expected master\n", dead_node); 3369c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1); 3370c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3371c2cd4a44SSunil Mushran wake_up(&mle->wq); 3372c2cd4a44SSunil Mushran 3373c2cd4a44SSunil Mushran /* Do not need events any longer, so detach from heartbeat */ 3374c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3375c2cd4a44SSunil Mushran __dlm_put_mle(mle); 3376c2cd4a44SSunil Mushran } 3377c2cd4a44SSunil Mushran } 33786714d8e8SKurt Hackel 33796714d8e8SKurt Hackel void dlm_clean_master_list(struct dlm_ctxt *dlm, u8 dead_node) 33806714d8e8SKurt Hackel { 33812ed6c750SSunil Mushran struct dlm_master_list_entry *mle; 33826714d8e8SKurt Hackel struct dlm_lock_resource *res; 33832ed6c750SSunil Mushran struct hlist_head *bucket; 3384df53cd3bSDong Fang struct hlist_node *tmp; 33852ed6c750SSunil Mushran unsigned int i; 33866714d8e8SKurt Hackel 3387ef6b689bSTao Ma mlog(0, "dlm=%s, dead node=%u\n", dlm->name, dead_node); 33886714d8e8SKurt Hackel top: 33896714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 33906714d8e8SKurt Hackel 33916714d8e8SKurt Hackel /* clean the master list */ 33926714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 33932ed6c750SSunil Mushran for (i = 0; i < DLM_HASH_BUCKETS; i++) { 33942ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, i); 3395df53cd3bSDong Fang hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) { 33966714d8e8SKurt Hackel BUG_ON(mle->type != DLM_MLE_BLOCK && 33976714d8e8SKurt Hackel mle->type != DLM_MLE_MASTER && 33986714d8e8SKurt Hackel mle->type != DLM_MLE_MIGRATION); 33996714d8e8SKurt Hackel 340067ae1f06SSunil Mushran /* MASTER mles are initiated locally. The waiting 340167ae1f06SSunil Mushran * process will notice the node map change shortly. 340267ae1f06SSunil Mushran * Let that happen as normal. */ 34036714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) 34046714d8e8SKurt Hackel continue; 34056714d8e8SKurt Hackel 340667ae1f06SSunil Mushran /* BLOCK mles are initiated by other nodes. Need to 340767ae1f06SSunil Mushran * clean up if the dead node would have been the 340867ae1f06SSunil Mushran * master. */ 34096714d8e8SKurt Hackel if (mle->type == DLM_MLE_BLOCK) { 3410c2cd4a44SSunil Mushran dlm_clean_block_mle(dlm, mle, dead_node); 34116714d8e8SKurt Hackel continue; 34126714d8e8SKurt Hackel } 34136714d8e8SKurt Hackel 341467ae1f06SSunil Mushran /* Everything else is a MIGRATION mle */ 34156714d8e8SKurt Hackel 341667ae1f06SSunil Mushran /* The rule for MIGRATION mles is that the master 341767ae1f06SSunil Mushran * becomes UNKNOWN if *either* the original or the new 341867ae1f06SSunil Mushran * master dies. All UNKNOWN lockres' are sent to 341967ae1f06SSunil Mushran * whichever node becomes the recovery master. The new 342067ae1f06SSunil Mushran * master is responsible for determining if there is 342167ae1f06SSunil Mushran * still a master for this lockres, or if he needs to 342267ae1f06SSunil Mushran * take over mastery. Either way, this node should 342367ae1f06SSunil Mushran * expect another message to resolve this. */ 342467ae1f06SSunil Mushran 34256714d8e8SKurt Hackel if (mle->master != dead_node && 34266714d8e8SKurt Hackel mle->new_master != dead_node) 34276714d8e8SKurt Hackel continue; 34286714d8e8SKurt Hackel 3429bef5502dSxuejiufei if (mle->new_master == dead_node && mle->inuse) { 3430bef5502dSxuejiufei mlog(ML_NOTICE, "%s: target %u died during " 3431bef5502dSxuejiufei "migration from %u, the MLE is " 3432bef5502dSxuejiufei "still keep used, ignore it!\n", 3433bef5502dSxuejiufei dlm->name, dead_node, 3434bef5502dSxuejiufei mle->master); 3435bef5502dSxuejiufei continue; 3436bef5502dSxuejiufei } 3437bef5502dSxuejiufei 343867ae1f06SSunil Mushran /* If we have reached this point, this mle needs to be 343967ae1f06SSunil Mushran * removed from the list and freed. */ 3440c2cd4a44SSunil Mushran dlm_clean_migration_mle(dlm, mle); 34416714d8e8SKurt Hackel 3442aa852354SKurt Hackel mlog(0, "%s: node %u died during migration from " 344367ae1f06SSunil Mushran "%u to %u!\n", dlm->name, dead_node, mle->master, 344467ae1f06SSunil Mushran mle->new_master); 3445c2cd4a44SSunil Mushran 3446c2cd4a44SSunil Mushran /* If we find a lockres associated with the mle, we've 3447c2cd4a44SSunil Mushran * hit this rare case that messes up our lock ordering. 3448c2cd4a44SSunil Mushran * If so, we need to drop the master lock so that we can 3449c2cd4a44SSunil Mushran * take the lockres lock, meaning that we will have to 34506714d8e8SKurt Hackel * restart from the head of list. */ 3451c2cd4a44SSunil Mushran res = dlm_reset_mleres_owner(dlm, mle); 3452c2cd4a44SSunil Mushran if (res) 34536714d8e8SKurt Hackel /* restart */ 34546714d8e8SKurt Hackel goto top; 34556714d8e8SKurt Hackel 345667ae1f06SSunil Mushran /* This may be the last reference */ 34576714d8e8SKurt Hackel __dlm_put_mle(mle); 34586714d8e8SKurt Hackel } 34592ed6c750SSunil Mushran } 34606714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 34616714d8e8SKurt Hackel } 34626714d8e8SKurt Hackel 34636714d8e8SKurt Hackel int dlm_finish_migration(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 34646714d8e8SKurt Hackel u8 old_master) 34656714d8e8SKurt Hackel { 34666714d8e8SKurt Hackel struct dlm_node_iter iter; 34676714d8e8SKurt Hackel int ret = 0; 34686714d8e8SKurt Hackel 34696714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 34706714d8e8SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter); 34716714d8e8SKurt Hackel clear_bit(old_master, iter.node_map); 34726714d8e8SKurt Hackel clear_bit(dlm->node_num, iter.node_map); 34736714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 34746714d8e8SKurt Hackel 3475ba2bf218SKurt Hackel /* ownership of the lockres is changing. account for the 3476ba2bf218SKurt Hackel * mastery reference here since old_master will briefly have 3477ba2bf218SKurt Hackel * a reference after the migration completes */ 3478ba2bf218SKurt Hackel spin_lock(&res->spinlock); 34798d400b81SSunil Mushran dlm_lockres_set_refmap_bit(dlm, res, old_master); 3480ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 3481ba2bf218SKurt Hackel 34826714d8e8SKurt Hackel mlog(0, "now time to do a migrate request to other nodes\n"); 34836714d8e8SKurt Hackel ret = dlm_do_migrate_request(dlm, res, old_master, 34846714d8e8SKurt Hackel dlm->node_num, &iter); 34856714d8e8SKurt Hackel if (ret < 0) { 34866714d8e8SKurt Hackel mlog_errno(ret); 34876714d8e8SKurt Hackel goto leave; 34886714d8e8SKurt Hackel } 34896714d8e8SKurt Hackel 34906714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s to all except the original node\n", 34916714d8e8SKurt Hackel res->lockname.len, res->lockname.name); 34926714d8e8SKurt Hackel /* this call now finishes out the nodemap 34936714d8e8SKurt Hackel * even if one or more nodes die */ 3494ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map, 34956714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION); 34966714d8e8SKurt Hackel if (ret < 0) { 34976714d8e8SKurt Hackel /* no longer need to retry. all living nodes contacted. */ 34986714d8e8SKurt Hackel mlog_errno(ret); 34996714d8e8SKurt Hackel ret = 0; 35006714d8e8SKurt Hackel } 35016714d8e8SKurt Hackel 35026714d8e8SKurt Hackel memset(iter.node_map, 0, sizeof(iter.node_map)); 35036714d8e8SKurt Hackel set_bit(old_master, iter.node_map); 35046714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s back to %u\n", 35056714d8e8SKurt Hackel res->lockname.len, res->lockname.name, old_master); 3506ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map, 35076714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION); 35086714d8e8SKurt Hackel if (ret < 0) { 35096714d8e8SKurt Hackel mlog(0, "assert master to original master failed " 35106714d8e8SKurt Hackel "with %d.\n", ret); 35116714d8e8SKurt Hackel /* the only nonzero status here would be because of 35126714d8e8SKurt Hackel * a dead original node. we're done. */ 35136714d8e8SKurt Hackel ret = 0; 35146714d8e8SKurt Hackel } 35156714d8e8SKurt Hackel 35166714d8e8SKurt Hackel /* all done, set the owner, clear the flag */ 35176714d8e8SKurt Hackel spin_lock(&res->spinlock); 35186714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, dlm->node_num); 35196714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 35206714d8e8SKurt Hackel spin_unlock(&res->spinlock); 35216714d8e8SKurt Hackel /* re-dirty it on the new master */ 35226714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 35236714d8e8SKurt Hackel wake_up(&res->wq); 35246714d8e8SKurt Hackel leave: 35256714d8e8SKurt Hackel return ret; 35266714d8e8SKurt Hackel } 35276714d8e8SKurt Hackel 35286714d8e8SKurt Hackel /* 35296714d8e8SKurt Hackel * LOCKRES AST REFCOUNT 35306714d8e8SKurt Hackel * this is integral to migration 35316714d8e8SKurt Hackel */ 35326714d8e8SKurt Hackel 35336714d8e8SKurt Hackel /* for future intent to call an ast, reserve one ahead of time. 35346714d8e8SKurt Hackel * this should be called only after waiting on the lockres 35356714d8e8SKurt Hackel * with dlm_wait_on_lockres, and while still holding the 35366714d8e8SKurt Hackel * spinlock after the call. */ 35376714d8e8SKurt Hackel void __dlm_lockres_reserve_ast(struct dlm_lock_resource *res) 35386714d8e8SKurt Hackel { 35396714d8e8SKurt Hackel assert_spin_locked(&res->spinlock); 35406714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) { 35416714d8e8SKurt Hackel __dlm_print_one_lock_resource(res); 35426714d8e8SKurt Hackel } 35436714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING); 35446714d8e8SKurt Hackel 35456714d8e8SKurt Hackel atomic_inc(&res->asts_reserved); 35466714d8e8SKurt Hackel } 35476714d8e8SKurt Hackel 35486714d8e8SKurt Hackel /* 35496714d8e8SKurt Hackel * used to drop the reserved ast, either because it went unused, 35506714d8e8SKurt Hackel * or because the ast/bast was actually called. 35516714d8e8SKurt Hackel * 35526714d8e8SKurt Hackel * also, if there is a pending migration on this lockres, 35536714d8e8SKurt Hackel * and this was the last pending ast on the lockres, 35546714d8e8SKurt Hackel * atomically set the MIGRATING flag before we drop the lock. 35556714d8e8SKurt Hackel * this is how we ensure that migration can proceed with no 35566714d8e8SKurt Hackel * asts in progress. note that it is ok if the state of the 35576714d8e8SKurt Hackel * queues is such that a lock should be granted in the future 35586714d8e8SKurt Hackel * or that a bast should be fired, because the new master will 35596714d8e8SKurt Hackel * shuffle the lists on this lockres as soon as it is migrated. 35606714d8e8SKurt Hackel */ 35616714d8e8SKurt Hackel void dlm_lockres_release_ast(struct dlm_ctxt *dlm, 35626714d8e8SKurt Hackel struct dlm_lock_resource *res) 35636714d8e8SKurt Hackel { 35646714d8e8SKurt Hackel if (!atomic_dec_and_lock(&res->asts_reserved, &res->spinlock)) 35656714d8e8SKurt Hackel return; 35666714d8e8SKurt Hackel 35676714d8e8SKurt Hackel if (!res->migration_pending) { 35686714d8e8SKurt Hackel spin_unlock(&res->spinlock); 35696714d8e8SKurt Hackel return; 35706714d8e8SKurt Hackel } 35716714d8e8SKurt Hackel 35726714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING); 35736714d8e8SKurt Hackel res->migration_pending = 0; 35746714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING; 35756714d8e8SKurt Hackel spin_unlock(&res->spinlock); 35766714d8e8SKurt Hackel wake_up(&res->wq); 35776714d8e8SKurt Hackel wake_up(&dlm->migration_wq); 35786714d8e8SKurt Hackel } 35795dad6c39SSrinivas Eeda 35805dad6c39SSrinivas Eeda void dlm_force_free_mles(struct dlm_ctxt *dlm) 35815dad6c39SSrinivas Eeda { 35825dad6c39SSrinivas Eeda int i; 35835dad6c39SSrinivas Eeda struct hlist_head *bucket; 35845dad6c39SSrinivas Eeda struct dlm_master_list_entry *mle; 3585df53cd3bSDong Fang struct hlist_node *tmp; 35865dad6c39SSrinivas Eeda 35875dad6c39SSrinivas Eeda /* 35885dad6c39SSrinivas Eeda * We notified all other nodes that we are exiting the domain and 35895dad6c39SSrinivas Eeda * marked the dlm state to DLM_CTXT_LEAVING. If any mles are still 35905dad6c39SSrinivas Eeda * around we force free them and wake any processes that are waiting 35915dad6c39SSrinivas Eeda * on the mles 35925dad6c39SSrinivas Eeda */ 35935dad6c39SSrinivas Eeda spin_lock(&dlm->spinlock); 35945dad6c39SSrinivas Eeda spin_lock(&dlm->master_lock); 35955dad6c39SSrinivas Eeda 35965dad6c39SSrinivas Eeda BUG_ON(dlm->dlm_state != DLM_CTXT_LEAVING); 35975dad6c39SSrinivas Eeda BUG_ON((find_next_bit(dlm->domain_map, O2NM_MAX_NODES, 0) < O2NM_MAX_NODES)); 35985dad6c39SSrinivas Eeda 35995dad6c39SSrinivas Eeda for (i = 0; i < DLM_HASH_BUCKETS; i++) { 36005dad6c39SSrinivas Eeda bucket = dlm_master_hash(dlm, i); 3601df53cd3bSDong Fang hlist_for_each_entry_safe(mle, tmp, bucket, master_hash_node) { 36025dad6c39SSrinivas Eeda if (mle->type != DLM_MLE_BLOCK) { 36035dad6c39SSrinivas Eeda mlog(ML_ERROR, "bad mle: %p\n", mle); 36045dad6c39SSrinivas Eeda dlm_print_one_mle(mle); 36055dad6c39SSrinivas Eeda } 36065dad6c39SSrinivas Eeda atomic_set(&mle->woken, 1); 36075dad6c39SSrinivas Eeda wake_up(&mle->wq); 36085dad6c39SSrinivas Eeda 36095dad6c39SSrinivas Eeda __dlm_unlink_mle(dlm, mle); 36105dad6c39SSrinivas Eeda __dlm_mle_detach_hb_events(dlm, mle); 36115dad6c39SSrinivas Eeda __dlm_put_mle(mle); 36125dad6c39SSrinivas Eeda } 36135dad6c39SSrinivas Eeda } 36145dad6c39SSrinivas Eeda spin_unlock(&dlm->master_lock); 36155dad6c39SSrinivas Eeda spin_unlock(&dlm->spinlock); 36165dad6c39SSrinivas Eeda } 3617