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 85724bdca9SSunil Mushran static struct kmem_cache *dlm_lockres_cache = NULL; 86724bdca9SSunil Mushran static struct kmem_cache *dlm_lockname_cache = NULL; 87e18b890bSChristoph Lameter static struct kmem_cache *dlm_mle_cache = NULL; 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 struct hlist_node *list; 3462ed6c750SSunil Mushran unsigned int hash; 3476714d8e8SKurt Hackel 3486714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 3496714d8e8SKurt Hackel 3502ed6c750SSunil Mushran hash = dlm_lockid_hash(name, namelen); 3512ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, hash); 3522ed6c750SSunil Mushran hlist_for_each(list, bucket) { 3532ed6c750SSunil Mushran tmpmle = hlist_entry(list, struct dlm_master_list_entry, 3542ed6c750SSunil Mushran master_hash_node); 3556714d8e8SKurt Hackel if (!dlm_mle_equal(dlm, tmpmle, name, namelen)) 3566714d8e8SKurt Hackel continue; 3576714d8e8SKurt Hackel dlm_get_mle(tmpmle); 3586714d8e8SKurt Hackel *mle = tmpmle; 3596714d8e8SKurt Hackel return 1; 3606714d8e8SKurt Hackel } 3616714d8e8SKurt Hackel return 0; 3626714d8e8SKurt Hackel } 3636714d8e8SKurt Hackel 3646714d8e8SKurt Hackel void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up) 3656714d8e8SKurt Hackel { 3666714d8e8SKurt Hackel struct dlm_master_list_entry *mle; 3676714d8e8SKurt Hackel 3686714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 3696714d8e8SKurt Hackel 370800deef3SChristoph Hellwig list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) { 3716714d8e8SKurt Hackel if (node_up) 3726714d8e8SKurt Hackel dlm_mle_node_up(dlm, mle, NULL, idx); 3736714d8e8SKurt Hackel else 3746714d8e8SKurt Hackel dlm_mle_node_down(dlm, mle, NULL, idx); 3756714d8e8SKurt Hackel } 3766714d8e8SKurt Hackel } 3776714d8e8SKurt Hackel 3786714d8e8SKurt Hackel static void dlm_mle_node_down(struct dlm_ctxt *dlm, 3796714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 3806714d8e8SKurt Hackel struct o2nm_node *node, int idx) 3816714d8e8SKurt Hackel { 3826714d8e8SKurt Hackel spin_lock(&mle->spinlock); 3836714d8e8SKurt Hackel 3846714d8e8SKurt Hackel if (!test_bit(idx, mle->node_map)) 3856714d8e8SKurt Hackel mlog(0, "node %u already removed from nodemap!\n", idx); 3866714d8e8SKurt Hackel else 3876714d8e8SKurt Hackel clear_bit(idx, mle->node_map); 3886714d8e8SKurt Hackel 3896714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 3906714d8e8SKurt Hackel } 3916714d8e8SKurt Hackel 3926714d8e8SKurt Hackel static void dlm_mle_node_up(struct dlm_ctxt *dlm, 3936714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 3946714d8e8SKurt Hackel struct o2nm_node *node, int idx) 3956714d8e8SKurt Hackel { 3966714d8e8SKurt Hackel spin_lock(&mle->spinlock); 3976714d8e8SKurt Hackel 3986714d8e8SKurt Hackel if (test_bit(idx, mle->node_map)) 3996714d8e8SKurt Hackel mlog(0, "node %u already in node map!\n", idx); 4006714d8e8SKurt Hackel else 4016714d8e8SKurt Hackel set_bit(idx, mle->node_map); 4026714d8e8SKurt Hackel 4036714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 4046714d8e8SKurt Hackel } 4056714d8e8SKurt Hackel 4066714d8e8SKurt Hackel 4076714d8e8SKurt Hackel int dlm_init_mle_cache(void) 4086714d8e8SKurt Hackel { 40912eb0035SSunil Mushran dlm_mle_cache = kmem_cache_create("o2dlm_mle", 4106714d8e8SKurt Hackel sizeof(struct dlm_master_list_entry), 4116714d8e8SKurt Hackel 0, SLAB_HWCACHE_ALIGN, 41220c2df83SPaul Mundt NULL); 4136714d8e8SKurt Hackel if (dlm_mle_cache == NULL) 4146714d8e8SKurt Hackel return -ENOMEM; 4156714d8e8SKurt Hackel return 0; 4166714d8e8SKurt Hackel } 4176714d8e8SKurt Hackel 4186714d8e8SKurt Hackel void dlm_destroy_mle_cache(void) 4196714d8e8SKurt Hackel { 4206714d8e8SKurt Hackel if (dlm_mle_cache) 4216714d8e8SKurt Hackel kmem_cache_destroy(dlm_mle_cache); 4226714d8e8SKurt Hackel } 4236714d8e8SKurt Hackel 4246714d8e8SKurt Hackel static void dlm_mle_release(struct kref *kref) 4256714d8e8SKurt Hackel { 4266714d8e8SKurt Hackel struct dlm_master_list_entry *mle; 4276714d8e8SKurt Hackel struct dlm_ctxt *dlm; 4286714d8e8SKurt Hackel 4296714d8e8SKurt Hackel mle = container_of(kref, struct dlm_master_list_entry, mle_refs); 4306714d8e8SKurt Hackel dlm = mle->dlm; 4316714d8e8SKurt Hackel 4326714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 4336714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 4346714d8e8SKurt Hackel 4357141514bSSunil Mushran mlog(0, "Releasing mle for %.*s, type %d\n", mle->mnamelen, mle->mname, 4367141514bSSunil Mushran mle->type); 4372ed6c750SSunil Mushran 4386714d8e8SKurt Hackel /* remove from list if not already */ 4391c084577SSunil Mushran __dlm_unlink_mle(dlm, mle); 4406714d8e8SKurt Hackel 4416714d8e8SKurt Hackel /* detach the mle from the domain node up/down events */ 4426714d8e8SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle); 4436714d8e8SKurt Hackel 4442041d8fdSSunil Mushran atomic_dec(&dlm->mle_cur_count[mle->type]); 4452041d8fdSSunil Mushran 4466714d8e8SKurt Hackel /* NOTE: kfree under spinlock here. 4476714d8e8SKurt Hackel * if this is bad, we can move this to a freelist. */ 4486714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 4496714d8e8SKurt Hackel } 4506714d8e8SKurt Hackel 4516714d8e8SKurt Hackel 4526714d8e8SKurt Hackel /* 4536714d8e8SKurt Hackel * LOCK RESOURCE FUNCTIONS 4546714d8e8SKurt Hackel */ 4556714d8e8SKurt Hackel 456724bdca9SSunil Mushran int dlm_init_master_caches(void) 457724bdca9SSunil Mushran { 458724bdca9SSunil Mushran dlm_lockres_cache = kmem_cache_create("o2dlm_lockres", 459724bdca9SSunil Mushran sizeof(struct dlm_lock_resource), 460724bdca9SSunil Mushran 0, SLAB_HWCACHE_ALIGN, NULL); 461724bdca9SSunil Mushran if (!dlm_lockres_cache) 462724bdca9SSunil Mushran goto bail; 463724bdca9SSunil Mushran 464724bdca9SSunil Mushran dlm_lockname_cache = kmem_cache_create("o2dlm_lockname", 465724bdca9SSunil Mushran DLM_LOCKID_NAME_MAX, 0, 466724bdca9SSunil Mushran SLAB_HWCACHE_ALIGN, NULL); 467724bdca9SSunil Mushran if (!dlm_lockname_cache) 468724bdca9SSunil Mushran goto bail; 469724bdca9SSunil Mushran 470724bdca9SSunil Mushran return 0; 471724bdca9SSunil Mushran bail: 472724bdca9SSunil Mushran dlm_destroy_master_caches(); 473724bdca9SSunil Mushran return -ENOMEM; 474724bdca9SSunil Mushran } 475724bdca9SSunil Mushran 476724bdca9SSunil Mushran void dlm_destroy_master_caches(void) 477724bdca9SSunil Mushran { 478724bdca9SSunil Mushran if (dlm_lockname_cache) 479724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockname_cache); 480724bdca9SSunil Mushran 481724bdca9SSunil Mushran if (dlm_lockres_cache) 482724bdca9SSunil Mushran kmem_cache_destroy(dlm_lockres_cache); 483724bdca9SSunil Mushran } 484724bdca9SSunil Mushran 4856714d8e8SKurt Hackel static void dlm_lockres_release(struct kref *kref) 4866714d8e8SKurt Hackel { 4876714d8e8SKurt Hackel struct dlm_lock_resource *res; 488b0d4f817SSunil Mushran struct dlm_ctxt *dlm; 4896714d8e8SKurt Hackel 4906714d8e8SKurt Hackel res = container_of(kref, struct dlm_lock_resource, refs); 491b0d4f817SSunil Mushran dlm = res->dlm; 4926714d8e8SKurt Hackel 4936714d8e8SKurt Hackel /* This should not happen -- all lockres' have a name 4946714d8e8SKurt Hackel * associated with them at init time. */ 4956714d8e8SKurt Hackel BUG_ON(!res->lockname.name); 4966714d8e8SKurt Hackel 4976714d8e8SKurt Hackel mlog(0, "destroying lockres %.*s\n", res->lockname.len, 4986714d8e8SKurt Hackel res->lockname.name); 4996714d8e8SKurt Hackel 500b0d4f817SSunil Mushran spin_lock(&dlm->track_lock); 50129576f8bSSunil Mushran if (!list_empty(&res->tracking)) 50229576f8bSSunil Mushran list_del_init(&res->tracking); 50329576f8bSSunil Mushran else { 50429576f8bSSunil Mushran mlog(ML_ERROR, "Resource %.*s not on the Tracking list\n", 50529576f8bSSunil Mushran res->lockname.len, res->lockname.name); 50629576f8bSSunil Mushran dlm_print_one_lock_resource(res); 50729576f8bSSunil Mushran } 508b0d4f817SSunil Mushran spin_unlock(&dlm->track_lock); 509b0d4f817SSunil Mushran 5106800791aSSunil Mushran atomic_dec(&dlm->res_cur_count); 5116800791aSSunil Mushran 512a7f90d83SKurt Hackel if (!hlist_unhashed(&res->hash_node) || 513a7f90d83SKurt Hackel !list_empty(&res->granted) || 514a7f90d83SKurt Hackel !list_empty(&res->converting) || 515a7f90d83SKurt Hackel !list_empty(&res->blocked) || 516a7f90d83SKurt Hackel !list_empty(&res->dirty) || 517a7f90d83SKurt Hackel !list_empty(&res->recovering) || 518a7f90d83SKurt Hackel !list_empty(&res->purge)) { 519a7f90d83SKurt Hackel mlog(ML_ERROR, 520a7f90d83SKurt Hackel "Going to BUG for resource %.*s." 521a7f90d83SKurt Hackel " We're on a list! [%c%c%c%c%c%c%c]\n", 522a7f90d83SKurt Hackel res->lockname.len, res->lockname.name, 523a7f90d83SKurt Hackel !hlist_unhashed(&res->hash_node) ? 'H' : ' ', 524a7f90d83SKurt Hackel !list_empty(&res->granted) ? 'G' : ' ', 525a7f90d83SKurt Hackel !list_empty(&res->converting) ? 'C' : ' ', 526a7f90d83SKurt Hackel !list_empty(&res->blocked) ? 'B' : ' ', 527a7f90d83SKurt Hackel !list_empty(&res->dirty) ? 'D' : ' ', 528a7f90d83SKurt Hackel !list_empty(&res->recovering) ? 'R' : ' ', 529a7f90d83SKurt Hackel !list_empty(&res->purge) ? 'P' : ' '); 530a7f90d83SKurt Hackel 531a7f90d83SKurt Hackel dlm_print_one_lock_resource(res); 532a7f90d83SKurt Hackel } 533a7f90d83SKurt Hackel 5346714d8e8SKurt Hackel /* By the time we're ready to blow this guy away, we shouldn't 5356714d8e8SKurt Hackel * be on any lists. */ 53681f2094aSMark Fasheh BUG_ON(!hlist_unhashed(&res->hash_node)); 5376714d8e8SKurt Hackel BUG_ON(!list_empty(&res->granted)); 5386714d8e8SKurt Hackel BUG_ON(!list_empty(&res->converting)); 5396714d8e8SKurt Hackel BUG_ON(!list_empty(&res->blocked)); 5406714d8e8SKurt Hackel BUG_ON(!list_empty(&res->dirty)); 5416714d8e8SKurt Hackel BUG_ON(!list_empty(&res->recovering)); 5426714d8e8SKurt Hackel BUG_ON(!list_empty(&res->purge)); 5436714d8e8SKurt Hackel 544724bdca9SSunil Mushran kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name); 5456714d8e8SKurt Hackel 546724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res); 5476714d8e8SKurt Hackel } 5486714d8e8SKurt Hackel 5496714d8e8SKurt Hackel void dlm_lockres_put(struct dlm_lock_resource *res) 5506714d8e8SKurt Hackel { 5516714d8e8SKurt Hackel kref_put(&res->refs, dlm_lockres_release); 5526714d8e8SKurt Hackel } 5536714d8e8SKurt Hackel 5546714d8e8SKurt Hackel static void dlm_init_lockres(struct dlm_ctxt *dlm, 5556714d8e8SKurt Hackel struct dlm_lock_resource *res, 5566714d8e8SKurt Hackel const char *name, unsigned int namelen) 5576714d8e8SKurt Hackel { 5586714d8e8SKurt Hackel char *qname; 5596714d8e8SKurt Hackel 5606714d8e8SKurt Hackel /* If we memset here, we lose our reference to the kmalloc'd 5616714d8e8SKurt Hackel * res->lockname.name, so be sure to init every field 5626714d8e8SKurt Hackel * correctly! */ 5636714d8e8SKurt Hackel 5646714d8e8SKurt Hackel qname = (char *) res->lockname.name; 5656714d8e8SKurt Hackel memcpy(qname, name, namelen); 5666714d8e8SKurt Hackel 5676714d8e8SKurt Hackel res->lockname.len = namelen; 568a3d33291SMark Fasheh res->lockname.hash = dlm_lockid_hash(name, namelen); 5696714d8e8SKurt Hackel 5706714d8e8SKurt Hackel init_waitqueue_head(&res->wq); 5716714d8e8SKurt Hackel spin_lock_init(&res->spinlock); 57281f2094aSMark Fasheh INIT_HLIST_NODE(&res->hash_node); 5736714d8e8SKurt Hackel INIT_LIST_HEAD(&res->granted); 5746714d8e8SKurt Hackel INIT_LIST_HEAD(&res->converting); 5756714d8e8SKurt Hackel INIT_LIST_HEAD(&res->blocked); 5766714d8e8SKurt Hackel INIT_LIST_HEAD(&res->dirty); 5776714d8e8SKurt Hackel INIT_LIST_HEAD(&res->recovering); 5786714d8e8SKurt Hackel INIT_LIST_HEAD(&res->purge); 57929576f8bSSunil Mushran INIT_LIST_HEAD(&res->tracking); 5806714d8e8SKurt Hackel atomic_set(&res->asts_reserved, 0); 5816714d8e8SKurt Hackel res->migration_pending = 0; 582ba2bf218SKurt Hackel res->inflight_locks = 0; 5836714d8e8SKurt Hackel 584b0d4f817SSunil Mushran res->dlm = dlm; 585b0d4f817SSunil Mushran 5866714d8e8SKurt Hackel kref_init(&res->refs); 5876714d8e8SKurt Hackel 5886800791aSSunil Mushran atomic_inc(&dlm->res_tot_count); 5896800791aSSunil Mushran atomic_inc(&dlm->res_cur_count); 5906800791aSSunil Mushran 5916714d8e8SKurt Hackel /* just for consistency */ 5926714d8e8SKurt Hackel spin_lock(&res->spinlock); 5936714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN); 5946714d8e8SKurt Hackel spin_unlock(&res->spinlock); 5956714d8e8SKurt Hackel 5966714d8e8SKurt Hackel res->state = DLM_LOCK_RES_IN_PROGRESS; 5976714d8e8SKurt Hackel 5986714d8e8SKurt Hackel res->last_used = 0; 5996714d8e8SKurt Hackel 60018c6ac38SSunil Mushran spin_lock(&dlm->spinlock); 60129576f8bSSunil Mushran list_add_tail(&res->tracking, &dlm->tracking_list); 60218c6ac38SSunil Mushran spin_unlock(&dlm->spinlock); 60329576f8bSSunil Mushran 6046714d8e8SKurt Hackel memset(res->lvb, 0, DLM_LVB_LEN); 605ba2bf218SKurt Hackel memset(res->refmap, 0, sizeof(res->refmap)); 6066714d8e8SKurt Hackel } 6076714d8e8SKurt Hackel 6086714d8e8SKurt Hackel struct dlm_lock_resource *dlm_new_lockres(struct dlm_ctxt *dlm, 6096714d8e8SKurt Hackel const char *name, 6106714d8e8SKurt Hackel unsigned int namelen) 6116714d8e8SKurt Hackel { 612724bdca9SSunil Mushran struct dlm_lock_resource *res = NULL; 6136714d8e8SKurt Hackel 6143914ed0cSJulia Lawall res = kmem_cache_zalloc(dlm_lockres_cache, GFP_NOFS); 6156714d8e8SKurt Hackel if (!res) 616724bdca9SSunil Mushran goto error; 6176714d8e8SKurt Hackel 6183914ed0cSJulia Lawall res->lockname.name = kmem_cache_zalloc(dlm_lockname_cache, GFP_NOFS); 619724bdca9SSunil Mushran if (!res->lockname.name) 620724bdca9SSunil Mushran goto error; 6216714d8e8SKurt Hackel 6226714d8e8SKurt Hackel dlm_init_lockres(dlm, res, name, namelen); 6236714d8e8SKurt Hackel return res; 624724bdca9SSunil Mushran 625724bdca9SSunil Mushran error: 626724bdca9SSunil Mushran if (res && res->lockname.name) 627724bdca9SSunil Mushran kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name); 628724bdca9SSunil Mushran 629724bdca9SSunil Mushran if (res) 630724bdca9SSunil Mushran kmem_cache_free(dlm_lockres_cache, res); 631724bdca9SSunil Mushran return NULL; 6326714d8e8SKurt Hackel } 6336714d8e8SKurt Hackel 634ba2bf218SKurt Hackel void __dlm_lockres_grab_inflight_ref(struct dlm_ctxt *dlm, 635ba2bf218SKurt Hackel struct dlm_lock_resource *res, 636ba2bf218SKurt Hackel int new_lockres, 637ba2bf218SKurt Hackel const char *file, 638ba2bf218SKurt Hackel int line) 639ba2bf218SKurt Hackel { 640ba2bf218SKurt Hackel if (!new_lockres) 641ba2bf218SKurt Hackel assert_spin_locked(&res->spinlock); 642ba2bf218SKurt Hackel 643ba2bf218SKurt Hackel if (!test_bit(dlm->node_num, res->refmap)) { 644ba2bf218SKurt Hackel BUG_ON(res->inflight_locks != 0); 645ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(dlm->node_num, res); 646ba2bf218SKurt Hackel } 647ba2bf218SKurt Hackel res->inflight_locks++; 648ba2bf218SKurt Hackel mlog(0, "%s:%.*s: inflight++: now %u\n", 649ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 650ba2bf218SKurt Hackel res->inflight_locks); 651ba2bf218SKurt Hackel } 652ba2bf218SKurt Hackel 653ba2bf218SKurt Hackel void __dlm_lockres_drop_inflight_ref(struct dlm_ctxt *dlm, 654ba2bf218SKurt Hackel struct dlm_lock_resource *res, 655ba2bf218SKurt Hackel const char *file, 656ba2bf218SKurt Hackel int line) 657ba2bf218SKurt Hackel { 658ba2bf218SKurt Hackel assert_spin_locked(&res->spinlock); 659ba2bf218SKurt Hackel 660ba2bf218SKurt Hackel BUG_ON(res->inflight_locks == 0); 661ba2bf218SKurt Hackel res->inflight_locks--; 662ba2bf218SKurt Hackel mlog(0, "%s:%.*s: inflight--: now %u\n", 663ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 664ba2bf218SKurt Hackel res->inflight_locks); 665ba2bf218SKurt Hackel if (res->inflight_locks == 0) 666ba2bf218SKurt Hackel dlm_lockres_clear_refmap_bit(dlm->node_num, res); 667ba2bf218SKurt Hackel wake_up(&res->wq); 668ba2bf218SKurt Hackel } 669ba2bf218SKurt Hackel 6706714d8e8SKurt Hackel /* 6716714d8e8SKurt Hackel * lookup a lock resource by name. 6726714d8e8SKurt Hackel * may already exist in the hashtable. 6736714d8e8SKurt Hackel * lockid is null terminated 6746714d8e8SKurt Hackel * 6756714d8e8SKurt Hackel * if not, allocate enough for the lockres and for 6766714d8e8SKurt Hackel * the temporary structure used in doing the mastering. 6776714d8e8SKurt Hackel * 6786714d8e8SKurt Hackel * also, do a lookup in the dlm->master_list to see 6796714d8e8SKurt Hackel * if another node has begun mastering the same lock. 6806714d8e8SKurt Hackel * if so, there should be a block entry in there 6816714d8e8SKurt Hackel * for this name, and we should *not* attempt to master 6826714d8e8SKurt Hackel * the lock here. need to wait around for that node 6836714d8e8SKurt Hackel * to assert_master (or die). 6846714d8e8SKurt Hackel * 6856714d8e8SKurt Hackel */ 6866714d8e8SKurt Hackel struct dlm_lock_resource * dlm_get_lock_resource(struct dlm_ctxt *dlm, 6876714d8e8SKurt Hackel const char *lockid, 6883384f3dfSMark Fasheh int namelen, 6896714d8e8SKurt Hackel int flags) 6906714d8e8SKurt Hackel { 6916714d8e8SKurt Hackel struct dlm_lock_resource *tmpres=NULL, *res=NULL; 6926714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 6936714d8e8SKurt Hackel struct dlm_master_list_entry *alloc_mle = NULL; 6946714d8e8SKurt Hackel int blocked = 0; 6956714d8e8SKurt Hackel int ret, nodenum; 6966714d8e8SKurt Hackel struct dlm_node_iter iter; 6973384f3dfSMark Fasheh unsigned int hash; 6986714d8e8SKurt Hackel int tries = 0; 699c03872f5SKurt Hackel int bit, wait_on_recovery = 0; 700ba2bf218SKurt Hackel int drop_inflight_if_nonlocal = 0; 7016714d8e8SKurt Hackel 7026714d8e8SKurt Hackel BUG_ON(!lockid); 7036714d8e8SKurt Hackel 704a3d33291SMark Fasheh hash = dlm_lockid_hash(lockid, namelen); 7056714d8e8SKurt Hackel 7066714d8e8SKurt Hackel mlog(0, "get lockres %s (len %d)\n", lockid, namelen); 7076714d8e8SKurt Hackel 7086714d8e8SKurt Hackel lookup: 7096714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 710ba2bf218SKurt Hackel tmpres = __dlm_lookup_lockres_full(dlm, lockid, namelen, hash); 7116714d8e8SKurt Hackel if (tmpres) { 712ba2bf218SKurt Hackel int dropping_ref = 0; 713ba2bf218SKurt Hackel 7147b791d68SSunil Mushran spin_unlock(&dlm->spinlock); 7157b791d68SSunil Mushran 716ba2bf218SKurt Hackel spin_lock(&tmpres->spinlock); 7177b791d68SSunil Mushran /* We wait for the other thread that is mastering the resource */ 7187b791d68SSunil Mushran if (tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN) { 7197b791d68SSunil Mushran __dlm_wait_on_lockres(tmpres); 7207b791d68SSunil Mushran BUG_ON(tmpres->owner == DLM_LOCK_RES_OWNER_UNKNOWN); 7217b791d68SSunil Mushran } 7227b791d68SSunil Mushran 723ba2bf218SKurt Hackel if (tmpres->owner == dlm->node_num) { 724ba2bf218SKurt Hackel BUG_ON(tmpres->state & DLM_LOCK_RES_DROPPING_REF); 725ba2bf218SKurt Hackel dlm_lockres_grab_inflight_ref(dlm, tmpres); 726ba2bf218SKurt Hackel } else if (tmpres->state & DLM_LOCK_RES_DROPPING_REF) 727ba2bf218SKurt Hackel dropping_ref = 1; 728ba2bf218SKurt Hackel spin_unlock(&tmpres->spinlock); 729ba2bf218SKurt Hackel 730ba2bf218SKurt Hackel /* wait until done messaging the master, drop our ref to allow 731ba2bf218SKurt Hackel * the lockres to be purged, start over. */ 732ba2bf218SKurt Hackel if (dropping_ref) { 733ba2bf218SKurt Hackel spin_lock(&tmpres->spinlock); 734ba2bf218SKurt Hackel __dlm_wait_on_lockres_flags(tmpres, DLM_LOCK_RES_DROPPING_REF); 735ba2bf218SKurt Hackel spin_unlock(&tmpres->spinlock); 736ba2bf218SKurt Hackel dlm_lockres_put(tmpres); 737ba2bf218SKurt Hackel tmpres = NULL; 738ba2bf218SKurt Hackel goto lookup; 739ba2bf218SKurt Hackel } 740ba2bf218SKurt Hackel 7416714d8e8SKurt Hackel mlog(0, "found in hash!\n"); 7426714d8e8SKurt Hackel if (res) 7436714d8e8SKurt Hackel dlm_lockres_put(res); 7446714d8e8SKurt Hackel res = tmpres; 7456714d8e8SKurt Hackel goto leave; 7466714d8e8SKurt Hackel } 7476714d8e8SKurt Hackel 7486714d8e8SKurt Hackel if (!res) { 7496714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 7506714d8e8SKurt Hackel mlog(0, "allocating a new resource\n"); 7516714d8e8SKurt Hackel /* nothing found and we need to allocate one. */ 7523914ed0cSJulia Lawall alloc_mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 7536714d8e8SKurt Hackel if (!alloc_mle) 7546714d8e8SKurt Hackel goto leave; 7556714d8e8SKurt Hackel res = dlm_new_lockres(dlm, lockid, namelen); 7566714d8e8SKurt Hackel if (!res) 7576714d8e8SKurt Hackel goto leave; 7586714d8e8SKurt Hackel goto lookup; 7596714d8e8SKurt Hackel } 7606714d8e8SKurt Hackel 7616714d8e8SKurt Hackel mlog(0, "no lockres found, allocated our own: %p\n", res); 7626714d8e8SKurt Hackel 7636714d8e8SKurt Hackel if (flags & LKM_LOCAL) { 7646714d8e8SKurt Hackel /* caller knows it's safe to assume it's not mastered elsewhere 7656714d8e8SKurt Hackel * DONE! return right away */ 7666714d8e8SKurt Hackel spin_lock(&res->spinlock); 7676714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, dlm->node_num); 7686714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res); 769ba2bf218SKurt Hackel dlm_lockres_grab_inflight_ref(dlm, res); 7706714d8e8SKurt Hackel spin_unlock(&res->spinlock); 7716714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 7726714d8e8SKurt Hackel /* lockres still marked IN_PROGRESS */ 7736714d8e8SKurt Hackel goto wake_waiters; 7746714d8e8SKurt Hackel } 7756714d8e8SKurt Hackel 7766714d8e8SKurt Hackel /* check master list to see if another node has started mastering it */ 7776714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 7786714d8e8SKurt Hackel 7796714d8e8SKurt Hackel /* if we found a block, wait for lock to be mastered by another node */ 7806714d8e8SKurt Hackel blocked = dlm_find_mle(dlm, &mle, (char *)lockid, namelen); 7816714d8e8SKurt Hackel if (blocked) { 782ba2bf218SKurt Hackel int mig; 7836714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) { 7846714d8e8SKurt Hackel mlog(ML_ERROR, "master entry for nonexistent lock!\n"); 7856714d8e8SKurt Hackel BUG(); 786ba2bf218SKurt Hackel } 787ba2bf218SKurt Hackel mig = (mle->type == DLM_MLE_MIGRATION); 788ba2bf218SKurt Hackel /* if there is a migration in progress, let the migration 789ba2bf218SKurt Hackel * finish before continuing. we can wait for the absence 790ba2bf218SKurt Hackel * of the MIGRATION mle: either the migrate finished or 791ba2bf218SKurt Hackel * one of the nodes died and the mle was cleaned up. 792ba2bf218SKurt Hackel * if there is a BLOCK here, but it already has a master 793ba2bf218SKurt Hackel * set, we are too late. the master does not have a ref 794ba2bf218SKurt Hackel * for us in the refmap. detach the mle and drop it. 795ba2bf218SKurt Hackel * either way, go back to the top and start over. */ 796ba2bf218SKurt Hackel if (mig || mle->master != O2NM_MAX_NODES) { 797ba2bf218SKurt Hackel BUG_ON(mig && mle->master == dlm->node_num); 798ba2bf218SKurt Hackel /* we arrived too late. the master does not 799ba2bf218SKurt Hackel * have a ref for us. retry. */ 800ba2bf218SKurt Hackel mlog(0, "%s:%.*s: late on %s\n", 801ba2bf218SKurt Hackel dlm->name, namelen, lockid, 802ba2bf218SKurt Hackel mig ? "MIGRATION" : "BLOCK"); 8036714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 8046714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 8056714d8e8SKurt Hackel 8066714d8e8SKurt Hackel /* master is known, detach */ 807ba2bf218SKurt Hackel if (!mig) 8086714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 8096714d8e8SKurt Hackel dlm_put_mle(mle); 8106714d8e8SKurt Hackel mle = NULL; 81125985edcSLucas De Marchi /* this is lame, but we can't wait on either 812ba2bf218SKurt Hackel * the mle or lockres waitqueue here */ 813ba2bf218SKurt Hackel if (mig) 814ba2bf218SKurt Hackel msleep(100); 815ba2bf218SKurt Hackel goto lookup; 8166714d8e8SKurt Hackel } 8176714d8e8SKurt Hackel } else { 8186714d8e8SKurt Hackel /* go ahead and try to master lock on this node */ 8196714d8e8SKurt Hackel mle = alloc_mle; 8206714d8e8SKurt Hackel /* make sure this does not get freed below */ 8216714d8e8SKurt Hackel alloc_mle = NULL; 8226714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MASTER, dlm, res, NULL, 0); 8236714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map); 8241c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 825c03872f5SKurt Hackel 826c03872f5SKurt Hackel /* still holding the dlm spinlock, check the recovery map 827c03872f5SKurt Hackel * to see if there are any nodes that still need to be 828c03872f5SKurt Hackel * considered. these will not appear in the mle nodemap 829c03872f5SKurt Hackel * but they might own this lockres. wait on them. */ 830c03872f5SKurt Hackel bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); 831c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) { 832c03872f5SKurt Hackel mlog(ML_NOTICE, "%s:%.*s: at least one node (%d) to " 833c03872f5SKurt Hackel "recover before lock mastery can begin\n", 834c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit); 835c03872f5SKurt Hackel wait_on_recovery = 1; 836c03872f5SKurt Hackel } 8376714d8e8SKurt Hackel } 8386714d8e8SKurt Hackel 8396714d8e8SKurt Hackel /* at this point there is either a DLM_MLE_BLOCK or a 8406714d8e8SKurt Hackel * DLM_MLE_MASTER on the master list, so it's safe to add the 8416714d8e8SKurt Hackel * lockres to the hashtable. anyone who finds the lock will 8426714d8e8SKurt Hackel * still have to wait on the IN_PROGRESS. */ 8436714d8e8SKurt Hackel 8446714d8e8SKurt Hackel /* finally add the lockres to its hash bucket */ 8456714d8e8SKurt Hackel __dlm_insert_lockres(dlm, res); 84625985edcSLucas De Marchi /* since this lockres is new it doesn't not require the spinlock */ 847ba2bf218SKurt Hackel dlm_lockres_grab_inflight_ref_new(dlm, res); 848ba2bf218SKurt Hackel 849ba2bf218SKurt Hackel /* if this node does not become the master make sure to drop 850ba2bf218SKurt Hackel * this inflight reference below */ 851ba2bf218SKurt Hackel drop_inflight_if_nonlocal = 1; 852ba2bf218SKurt Hackel 8536714d8e8SKurt Hackel /* get an extra ref on the mle in case this is a BLOCK 8546714d8e8SKurt Hackel * if so, the creator of the BLOCK may try to put the last 8556714d8e8SKurt Hackel * ref at this time in the assert master handler, so we 8566714d8e8SKurt Hackel * need an extra one to keep from a bad ptr deref. */ 857a2bf0477SKurt Hackel dlm_get_mle_inuse(mle); 8586714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 8596714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 8606714d8e8SKurt Hackel 861e7e69eb3SKurt Hackel redo_request: 862c03872f5SKurt Hackel while (wait_on_recovery) { 863c03872f5SKurt Hackel /* any cluster changes that occurred after dropping the 864c03872f5SKurt Hackel * dlm spinlock would be detectable be a change on the mle, 865c03872f5SKurt Hackel * so we only need to clear out the recovery map once. */ 866c03872f5SKurt Hackel if (dlm_is_recovery_lock(lockid, namelen)) { 867c03872f5SKurt Hackel mlog(ML_NOTICE, "%s: recovery map is not empty, but " 868c03872f5SKurt Hackel "must master $RECOVERY lock now\n", dlm->name); 869c03872f5SKurt Hackel if (!dlm_pre_master_reco_lockres(dlm, res)) 870c03872f5SKurt Hackel wait_on_recovery = 0; 871c03872f5SKurt Hackel else { 872c03872f5SKurt Hackel mlog(0, "%s: waiting 500ms for heartbeat state " 873c03872f5SKurt Hackel "change\n", dlm->name); 874c03872f5SKurt Hackel msleep(500); 875c03872f5SKurt Hackel } 876c03872f5SKurt Hackel continue; 877c03872f5SKurt Hackel } 878c03872f5SKurt Hackel 879c03872f5SKurt Hackel dlm_kick_recovery_thread(dlm); 880aa087b84SKurt Hackel msleep(1000); 881c03872f5SKurt Hackel dlm_wait_for_recovery(dlm); 882c03872f5SKurt Hackel 883c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 884c03872f5SKurt Hackel bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0); 885c03872f5SKurt Hackel if (bit < O2NM_MAX_NODES) { 886c03872f5SKurt Hackel mlog(ML_NOTICE, "%s:%.*s: at least one node (%d) to " 887c03872f5SKurt Hackel "recover before lock mastery can begin\n", 888c03872f5SKurt Hackel dlm->name, namelen, (char *)lockid, bit); 889c03872f5SKurt Hackel wait_on_recovery = 1; 890c03872f5SKurt Hackel } else 891c03872f5SKurt Hackel wait_on_recovery = 0; 892c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 893b7084ab5SKurt Hackel 894b7084ab5SKurt Hackel if (wait_on_recovery) 895b7084ab5SKurt Hackel dlm_wait_for_node_recovery(dlm, bit, 10000); 896c03872f5SKurt Hackel } 897c03872f5SKurt Hackel 8986714d8e8SKurt Hackel /* must wait for lock to be mastered elsewhere */ 8996714d8e8SKurt Hackel if (blocked) 9006714d8e8SKurt Hackel goto wait; 9016714d8e8SKurt Hackel 9026714d8e8SKurt Hackel ret = -EINVAL; 9036714d8e8SKurt Hackel dlm_node_iter_init(mle->vote_map, &iter); 9046714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) { 905ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, nodenum); 9066714d8e8SKurt Hackel if (ret < 0) 9076714d8e8SKurt Hackel mlog_errno(ret); 9086714d8e8SKurt Hackel if (mle->master != O2NM_MAX_NODES) { 9096714d8e8SKurt Hackel /* found a master ! */ 9109c6510a5SKurt Hackel if (mle->master <= nodenum) 9116714d8e8SKurt Hackel break; 9129c6510a5SKurt Hackel /* if our master request has not reached the master 9139c6510a5SKurt Hackel * yet, keep going until it does. this is how the 9149c6510a5SKurt Hackel * master will know that asserts are needed back to 9159c6510a5SKurt Hackel * the lower nodes. */ 9169c6510a5SKurt Hackel mlog(0, "%s:%.*s: requests only up to %u but master " 9179c6510a5SKurt Hackel "is %u, keep going\n", dlm->name, namelen, 9189c6510a5SKurt Hackel lockid, nodenum, mle->master); 9196714d8e8SKurt Hackel } 9206714d8e8SKurt Hackel } 9216714d8e8SKurt Hackel 9226714d8e8SKurt Hackel wait: 9236714d8e8SKurt Hackel /* keep going until the response map includes all nodes */ 9246714d8e8SKurt Hackel ret = dlm_wait_for_lock_mastery(dlm, res, mle, &blocked); 9256714d8e8SKurt Hackel if (ret < 0) { 926e7e69eb3SKurt Hackel wait_on_recovery = 1; 9276714d8e8SKurt Hackel mlog(0, "%s:%.*s: node map changed, redo the " 9286714d8e8SKurt Hackel "master request now, blocked=%d\n", 9296714d8e8SKurt Hackel dlm->name, res->lockname.len, 9306714d8e8SKurt Hackel res->lockname.name, blocked); 9316714d8e8SKurt Hackel if (++tries > 20) { 9326714d8e8SKurt Hackel mlog(ML_ERROR, "%s:%.*s: spinning on " 9336714d8e8SKurt Hackel "dlm_wait_for_lock_mastery, blocked=%d\n", 9346714d8e8SKurt Hackel dlm->name, res->lockname.len, 9356714d8e8SKurt Hackel res->lockname.name, blocked); 9366714d8e8SKurt Hackel dlm_print_one_lock_resource(res); 9378a9343faSMark Fasheh dlm_print_one_mle(mle); 9386714d8e8SKurt Hackel tries = 0; 9396714d8e8SKurt Hackel } 9406714d8e8SKurt Hackel goto redo_request; 9416714d8e8SKurt Hackel } 9426714d8e8SKurt Hackel 9436714d8e8SKurt Hackel mlog(0, "lockres mastered by %u\n", res->owner); 9446714d8e8SKurt Hackel /* make sure we never continue without this */ 9456714d8e8SKurt Hackel BUG_ON(res->owner == O2NM_MAX_NODES); 9466714d8e8SKurt Hackel 9476714d8e8SKurt Hackel /* master is known, detach if not already detached */ 9486714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 9496714d8e8SKurt Hackel dlm_put_mle(mle); 9506714d8e8SKurt Hackel /* put the extra ref */ 951a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 9526714d8e8SKurt Hackel 9536714d8e8SKurt Hackel wake_waiters: 9546714d8e8SKurt Hackel spin_lock(&res->spinlock); 955ba2bf218SKurt Hackel if (res->owner != dlm->node_num && drop_inflight_if_nonlocal) 956ba2bf218SKurt Hackel dlm_lockres_drop_inflight_ref(dlm, res); 9576714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_IN_PROGRESS; 9586714d8e8SKurt Hackel spin_unlock(&res->spinlock); 9596714d8e8SKurt Hackel wake_up(&res->wq); 9606714d8e8SKurt Hackel 9616714d8e8SKurt Hackel leave: 9626714d8e8SKurt Hackel /* need to free the unused mle */ 9636714d8e8SKurt Hackel if (alloc_mle) 9646714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, alloc_mle); 9656714d8e8SKurt Hackel 9666714d8e8SKurt Hackel return res; 9676714d8e8SKurt Hackel } 9686714d8e8SKurt Hackel 9696714d8e8SKurt Hackel 9706714d8e8SKurt Hackel #define DLM_MASTERY_TIMEOUT_MS 5000 9716714d8e8SKurt Hackel 9726714d8e8SKurt Hackel static int dlm_wait_for_lock_mastery(struct dlm_ctxt *dlm, 9736714d8e8SKurt Hackel struct dlm_lock_resource *res, 9746714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 9756714d8e8SKurt Hackel int *blocked) 9766714d8e8SKurt Hackel { 9776714d8e8SKurt Hackel u8 m; 9786714d8e8SKurt Hackel int ret, bit; 9796714d8e8SKurt Hackel int map_changed, voting_done; 9806714d8e8SKurt Hackel int assert, sleep; 9816714d8e8SKurt Hackel 9826714d8e8SKurt Hackel recheck: 9836714d8e8SKurt Hackel ret = 0; 9846714d8e8SKurt Hackel assert = 0; 9856714d8e8SKurt Hackel 9866714d8e8SKurt Hackel /* check if another node has already become the owner */ 9876714d8e8SKurt Hackel spin_lock(&res->spinlock); 9886714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 9899c6510a5SKurt Hackel mlog(0, "%s:%.*s: owner is suddenly %u\n", dlm->name, 9909c6510a5SKurt Hackel res->lockname.len, res->lockname.name, res->owner); 9916714d8e8SKurt Hackel spin_unlock(&res->spinlock); 9929c6510a5SKurt Hackel /* this will cause the master to re-assert across 9939c6510a5SKurt Hackel * the whole cluster, freeing up mles */ 994588e0090SKurt Hackel if (res->owner != dlm->node_num) { 995ba2bf218SKurt Hackel ret = dlm_do_master_request(res, mle, res->owner); 9969c6510a5SKurt Hackel if (ret < 0) { 9979c6510a5SKurt Hackel /* give recovery a chance to run */ 9989c6510a5SKurt Hackel mlog(ML_ERROR, "link to %u went down?: %d\n", res->owner, ret); 9999c6510a5SKurt Hackel msleep(500); 10009c6510a5SKurt Hackel goto recheck; 10019c6510a5SKurt Hackel } 1002588e0090SKurt Hackel } 10039c6510a5SKurt Hackel ret = 0; 10046714d8e8SKurt Hackel goto leave; 10056714d8e8SKurt Hackel } 10066714d8e8SKurt Hackel spin_unlock(&res->spinlock); 10076714d8e8SKurt Hackel 10086714d8e8SKurt Hackel spin_lock(&mle->spinlock); 10096714d8e8SKurt Hackel m = mle->master; 10106714d8e8SKurt Hackel map_changed = (memcmp(mle->vote_map, mle->node_map, 10116714d8e8SKurt Hackel sizeof(mle->vote_map)) != 0); 10126714d8e8SKurt Hackel voting_done = (memcmp(mle->vote_map, mle->response_map, 10136714d8e8SKurt Hackel sizeof(mle->vote_map)) == 0); 10146714d8e8SKurt Hackel 10156714d8e8SKurt Hackel /* restart if we hit any errors */ 10166714d8e8SKurt Hackel if (map_changed) { 10176714d8e8SKurt Hackel int b; 10186714d8e8SKurt Hackel mlog(0, "%s: %.*s: node map changed, restarting\n", 10196714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 10206714d8e8SKurt Hackel ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked); 10216714d8e8SKurt Hackel b = (mle->type == DLM_MLE_BLOCK); 10226714d8e8SKurt Hackel if ((*blocked && !b) || (!*blocked && b)) { 10236714d8e8SKurt Hackel mlog(0, "%s:%.*s: status change: old=%d new=%d\n", 10246714d8e8SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 10256714d8e8SKurt Hackel *blocked, b); 10266714d8e8SKurt Hackel *blocked = b; 10276714d8e8SKurt Hackel } 10286714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 10296714d8e8SKurt Hackel if (ret < 0) { 10306714d8e8SKurt Hackel mlog_errno(ret); 10316714d8e8SKurt Hackel goto leave; 10326714d8e8SKurt Hackel } 10336714d8e8SKurt Hackel mlog(0, "%s:%.*s: restart lock mastery succeeded, " 10346714d8e8SKurt Hackel "rechecking now\n", dlm->name, res->lockname.len, 10356714d8e8SKurt Hackel res->lockname.name); 10366714d8e8SKurt Hackel goto recheck; 1037aa852354SKurt Hackel } else { 1038aa852354SKurt Hackel if (!voting_done) { 1039aa852354SKurt Hackel mlog(0, "map not changed and voting not done " 1040aa852354SKurt Hackel "for %s:%.*s\n", dlm->name, res->lockname.len, 1041aa852354SKurt Hackel res->lockname.name); 1042aa852354SKurt Hackel } 10436714d8e8SKurt Hackel } 10446714d8e8SKurt Hackel 10456714d8e8SKurt Hackel if (m != O2NM_MAX_NODES) { 10466714d8e8SKurt Hackel /* another node has done an assert! 10476714d8e8SKurt Hackel * all done! */ 10486714d8e8SKurt Hackel sleep = 0; 10496714d8e8SKurt Hackel } else { 10506714d8e8SKurt Hackel sleep = 1; 10516714d8e8SKurt Hackel /* have all nodes responded? */ 10526714d8e8SKurt Hackel if (voting_done && !*blocked) { 10536714d8e8SKurt Hackel bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0); 10546714d8e8SKurt Hackel if (dlm->node_num <= bit) { 10556714d8e8SKurt Hackel /* my node number is lowest. 10566714d8e8SKurt Hackel * now tell other nodes that I am 10576714d8e8SKurt Hackel * mastering this. */ 10586714d8e8SKurt Hackel mle->master = dlm->node_num; 1059ba2bf218SKurt Hackel /* ref was grabbed in get_lock_resource 1060ba2bf218SKurt Hackel * will be dropped in dlmlock_master */ 10616714d8e8SKurt Hackel assert = 1; 10626714d8e8SKurt Hackel sleep = 0; 10636714d8e8SKurt Hackel } 10646714d8e8SKurt Hackel /* if voting is done, but we have not received 10656714d8e8SKurt Hackel * an assert master yet, we must sleep */ 10666714d8e8SKurt Hackel } 10676714d8e8SKurt Hackel } 10686714d8e8SKurt Hackel 10696714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 10706714d8e8SKurt Hackel 10716714d8e8SKurt Hackel /* sleep if we haven't finished voting yet */ 10726714d8e8SKurt Hackel if (sleep) { 10736714d8e8SKurt Hackel unsigned long timeo = msecs_to_jiffies(DLM_MASTERY_TIMEOUT_MS); 10746714d8e8SKurt Hackel 10756714d8e8SKurt Hackel /* 10766714d8e8SKurt Hackel if (atomic_read(&mle->mle_refs.refcount) < 2) 10776714d8e8SKurt Hackel mlog(ML_ERROR, "mle (%p) refs=%d, name=%.*s\n", mle, 10786714d8e8SKurt Hackel atomic_read(&mle->mle_refs.refcount), 10796714d8e8SKurt Hackel res->lockname.len, res->lockname.name); 10806714d8e8SKurt Hackel */ 10816714d8e8SKurt Hackel atomic_set(&mle->woken, 0); 10826714d8e8SKurt Hackel (void)wait_event_timeout(mle->wq, 10836714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1), 10846714d8e8SKurt Hackel timeo); 10856714d8e8SKurt Hackel if (res->owner == O2NM_MAX_NODES) { 1086ba2bf218SKurt Hackel mlog(0, "%s:%.*s: waiting again\n", dlm->name, 1087ba2bf218SKurt Hackel res->lockname.len, res->lockname.name); 10886714d8e8SKurt Hackel goto recheck; 10896714d8e8SKurt Hackel } 10906714d8e8SKurt Hackel mlog(0, "done waiting, master is %u\n", res->owner); 10916714d8e8SKurt Hackel ret = 0; 10926714d8e8SKurt Hackel goto leave; 10936714d8e8SKurt Hackel } 10946714d8e8SKurt Hackel 10956714d8e8SKurt Hackel ret = 0; /* done */ 10966714d8e8SKurt Hackel if (assert) { 10976714d8e8SKurt Hackel m = dlm->node_num; 10986714d8e8SKurt Hackel mlog(0, "about to master %.*s here, this=%u\n", 10996714d8e8SKurt Hackel res->lockname.len, res->lockname.name, m); 1100ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, mle->vote_map, 0); 11016714d8e8SKurt Hackel if (ret) { 11026714d8e8SKurt Hackel /* This is a failure in the network path, 11036714d8e8SKurt Hackel * not in the response to the assert_master 11046714d8e8SKurt Hackel * (any nonzero response is a BUG on this node). 11056714d8e8SKurt Hackel * Most likely a socket just got disconnected 11066714d8e8SKurt Hackel * due to node death. */ 11076714d8e8SKurt Hackel mlog_errno(ret); 11086714d8e8SKurt Hackel } 11096714d8e8SKurt Hackel /* no longer need to restart lock mastery. 11106714d8e8SKurt Hackel * all living nodes have been contacted. */ 11116714d8e8SKurt Hackel ret = 0; 11126714d8e8SKurt Hackel } 11136714d8e8SKurt Hackel 11146714d8e8SKurt Hackel /* set the lockres owner */ 11156714d8e8SKurt Hackel spin_lock(&res->spinlock); 1116ba2bf218SKurt Hackel /* mastery reference obtained either during 1117ba2bf218SKurt Hackel * assert_master_handler or in get_lock_resource */ 11186714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, m); 11196714d8e8SKurt Hackel spin_unlock(&res->spinlock); 11206714d8e8SKurt Hackel 11216714d8e8SKurt Hackel leave: 11226714d8e8SKurt Hackel return ret; 11236714d8e8SKurt Hackel } 11246714d8e8SKurt Hackel 11256714d8e8SKurt Hackel struct dlm_bitmap_diff_iter 11266714d8e8SKurt Hackel { 11276714d8e8SKurt Hackel int curnode; 11286714d8e8SKurt Hackel unsigned long *orig_bm; 11296714d8e8SKurt Hackel unsigned long *cur_bm; 11306714d8e8SKurt Hackel unsigned long diff_bm[BITS_TO_LONGS(O2NM_MAX_NODES)]; 11316714d8e8SKurt Hackel }; 11326714d8e8SKurt Hackel 11336714d8e8SKurt Hackel enum dlm_node_state_change 11346714d8e8SKurt Hackel { 11356714d8e8SKurt Hackel NODE_DOWN = -1, 11366714d8e8SKurt Hackel NODE_NO_CHANGE = 0, 11376714d8e8SKurt Hackel NODE_UP 11386714d8e8SKurt Hackel }; 11396714d8e8SKurt Hackel 11406714d8e8SKurt Hackel static void dlm_bitmap_diff_iter_init(struct dlm_bitmap_diff_iter *iter, 11416714d8e8SKurt Hackel unsigned long *orig_bm, 11426714d8e8SKurt Hackel unsigned long *cur_bm) 11436714d8e8SKurt Hackel { 11446714d8e8SKurt Hackel unsigned long p1, p2; 11456714d8e8SKurt Hackel int i; 11466714d8e8SKurt Hackel 11476714d8e8SKurt Hackel iter->curnode = -1; 11486714d8e8SKurt Hackel iter->orig_bm = orig_bm; 11496714d8e8SKurt Hackel iter->cur_bm = cur_bm; 11506714d8e8SKurt Hackel 11516714d8e8SKurt Hackel for (i = 0; i < BITS_TO_LONGS(O2NM_MAX_NODES); i++) { 11526714d8e8SKurt Hackel p1 = *(iter->orig_bm + i); 11536714d8e8SKurt Hackel p2 = *(iter->cur_bm + i); 11546714d8e8SKurt Hackel iter->diff_bm[i] = (p1 & ~p2) | (p2 & ~p1); 11556714d8e8SKurt Hackel } 11566714d8e8SKurt Hackel } 11576714d8e8SKurt Hackel 11586714d8e8SKurt Hackel static int dlm_bitmap_diff_iter_next(struct dlm_bitmap_diff_iter *iter, 11596714d8e8SKurt Hackel enum dlm_node_state_change *state) 11606714d8e8SKurt Hackel { 11616714d8e8SKurt Hackel int bit; 11626714d8e8SKurt Hackel 11636714d8e8SKurt Hackel if (iter->curnode >= O2NM_MAX_NODES) 11646714d8e8SKurt Hackel return -ENOENT; 11656714d8e8SKurt Hackel 11666714d8e8SKurt Hackel bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES, 11676714d8e8SKurt Hackel iter->curnode+1); 11686714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) { 11696714d8e8SKurt Hackel iter->curnode = O2NM_MAX_NODES; 11706714d8e8SKurt Hackel return -ENOENT; 11716714d8e8SKurt Hackel } 11726714d8e8SKurt Hackel 11736714d8e8SKurt Hackel /* if it was there in the original then this node died */ 11746714d8e8SKurt Hackel if (test_bit(bit, iter->orig_bm)) 11756714d8e8SKurt Hackel *state = NODE_DOWN; 11766714d8e8SKurt Hackel else 11776714d8e8SKurt Hackel *state = NODE_UP; 11786714d8e8SKurt Hackel 11796714d8e8SKurt Hackel iter->curnode = bit; 11806714d8e8SKurt Hackel return bit; 11816714d8e8SKurt Hackel } 11826714d8e8SKurt Hackel 11836714d8e8SKurt Hackel 11846714d8e8SKurt Hackel static int dlm_restart_lock_mastery(struct dlm_ctxt *dlm, 11856714d8e8SKurt Hackel struct dlm_lock_resource *res, 11866714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 11876714d8e8SKurt Hackel int blocked) 11886714d8e8SKurt Hackel { 11896714d8e8SKurt Hackel struct dlm_bitmap_diff_iter bdi; 11906714d8e8SKurt Hackel enum dlm_node_state_change sc; 11916714d8e8SKurt Hackel int node; 11926714d8e8SKurt Hackel int ret = 0; 11936714d8e8SKurt Hackel 11946714d8e8SKurt Hackel mlog(0, "something happened such that the " 11956714d8e8SKurt Hackel "master process may need to be restarted!\n"); 11966714d8e8SKurt Hackel 11976714d8e8SKurt Hackel assert_spin_locked(&mle->spinlock); 11986714d8e8SKurt Hackel 11996714d8e8SKurt Hackel dlm_bitmap_diff_iter_init(&bdi, mle->vote_map, mle->node_map); 12006714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc); 12016714d8e8SKurt Hackel while (node >= 0) { 12026714d8e8SKurt Hackel if (sc == NODE_UP) { 1203e2faea4cSKurt Hackel /* a node came up. clear any old vote from 1204e2faea4cSKurt Hackel * the response map and set it in the vote map 1205e2faea4cSKurt Hackel * then restart the mastery. */ 1206e2faea4cSKurt Hackel mlog(ML_NOTICE, "node %d up while restarting\n", node); 12076714d8e8SKurt Hackel 12086714d8e8SKurt Hackel /* redo the master request, but only for the new node */ 12096714d8e8SKurt Hackel mlog(0, "sending request to new node\n"); 12106714d8e8SKurt Hackel clear_bit(node, mle->response_map); 12116714d8e8SKurt Hackel set_bit(node, mle->vote_map); 12126714d8e8SKurt Hackel } else { 12136714d8e8SKurt Hackel mlog(ML_ERROR, "node down! %d\n", node); 12146714d8e8SKurt Hackel if (blocked) { 12156714d8e8SKurt Hackel int lowest = find_next_bit(mle->maybe_map, 12166714d8e8SKurt Hackel O2NM_MAX_NODES, 0); 12176714d8e8SKurt Hackel 12186714d8e8SKurt Hackel /* act like it was never there */ 12196714d8e8SKurt Hackel clear_bit(node, mle->maybe_map); 12206714d8e8SKurt Hackel 1221e7e69eb3SKurt Hackel if (node == lowest) { 1222e7e69eb3SKurt Hackel mlog(0, "expected master %u died" 1223e7e69eb3SKurt Hackel " while this node was blocked " 1224e7e69eb3SKurt Hackel "waiting on it!\n", node); 12256714d8e8SKurt Hackel lowest = find_next_bit(mle->maybe_map, 12266714d8e8SKurt Hackel O2NM_MAX_NODES, 12276714d8e8SKurt Hackel lowest+1); 12286714d8e8SKurt Hackel if (lowest < O2NM_MAX_NODES) { 1229e7e69eb3SKurt Hackel mlog(0, "%s:%.*s:still " 1230e7e69eb3SKurt Hackel "blocked. waiting on %u " 1231e7e69eb3SKurt Hackel "now\n", dlm->name, 1232e7e69eb3SKurt Hackel res->lockname.len, 1233e7e69eb3SKurt Hackel res->lockname.name, 1234e7e69eb3SKurt Hackel lowest); 1235e7e69eb3SKurt Hackel } else { 1236e7e69eb3SKurt Hackel /* mle is an MLE_BLOCK, but 1237e7e69eb3SKurt Hackel * there is now nothing left to 1238e7e69eb3SKurt Hackel * block on. we need to return 1239e7e69eb3SKurt Hackel * all the way back out and try 1240e7e69eb3SKurt Hackel * again with an MLE_MASTER. 1241e7e69eb3SKurt Hackel * dlm_do_local_recovery_cleanup 1242e7e69eb3SKurt Hackel * has already run, so the mle 1243e7e69eb3SKurt Hackel * refcount is ok */ 1244e7e69eb3SKurt Hackel mlog(0, "%s:%.*s: no " 1245e7e69eb3SKurt Hackel "longer blocking. try to " 1246e7e69eb3SKurt Hackel "master this here\n", 1247e7e69eb3SKurt Hackel dlm->name, 1248e7e69eb3SKurt Hackel res->lockname.len, 1249e7e69eb3SKurt Hackel res->lockname.name); 1250e7e69eb3SKurt Hackel mle->type = DLM_MLE_MASTER; 12517141514bSSunil Mushran mle->mleres = res; 1252e7e69eb3SKurt Hackel } 1253e7e69eb3SKurt Hackel } 12546714d8e8SKurt Hackel } 12556714d8e8SKurt Hackel 1256e7e69eb3SKurt Hackel /* now blank out everything, as if we had never 1257e7e69eb3SKurt Hackel * contacted anyone */ 1258e7e69eb3SKurt Hackel memset(mle->maybe_map, 0, sizeof(mle->maybe_map)); 1259e7e69eb3SKurt Hackel memset(mle->response_map, 0, sizeof(mle->response_map)); 1260e7e69eb3SKurt Hackel /* reset the vote_map to the current node_map */ 12616714d8e8SKurt Hackel memcpy(mle->vote_map, mle->node_map, 12626714d8e8SKurt Hackel sizeof(mle->node_map)); 1263e7e69eb3SKurt Hackel /* put myself into the maybe map */ 1264e7e69eb3SKurt Hackel if (mle->type != DLM_MLE_BLOCK) 12656714d8e8SKurt Hackel set_bit(dlm->node_num, mle->maybe_map); 12666714d8e8SKurt Hackel } 12676714d8e8SKurt Hackel ret = -EAGAIN; 12686714d8e8SKurt Hackel node = dlm_bitmap_diff_iter_next(&bdi, &sc); 12696714d8e8SKurt Hackel } 12706714d8e8SKurt Hackel return ret; 12716714d8e8SKurt Hackel } 12726714d8e8SKurt Hackel 12736714d8e8SKurt Hackel 12746714d8e8SKurt Hackel /* 12756714d8e8SKurt Hackel * DLM_MASTER_REQUEST_MSG 12766714d8e8SKurt Hackel * 12776714d8e8SKurt Hackel * returns: 0 on success, 12786714d8e8SKurt Hackel * -errno on a network error 12796714d8e8SKurt Hackel * 12806714d8e8SKurt Hackel * on error, the caller should assume the target node is "dead" 12816714d8e8SKurt Hackel * 12826714d8e8SKurt Hackel */ 12836714d8e8SKurt Hackel 1284ba2bf218SKurt Hackel static int dlm_do_master_request(struct dlm_lock_resource *res, 1285ba2bf218SKurt Hackel struct dlm_master_list_entry *mle, int to) 12866714d8e8SKurt Hackel { 12876714d8e8SKurt Hackel struct dlm_ctxt *dlm = mle->dlm; 12886714d8e8SKurt Hackel struct dlm_master_request request; 12896714d8e8SKurt Hackel int ret, response=0, resend; 12906714d8e8SKurt Hackel 12916714d8e8SKurt Hackel memset(&request, 0, sizeof(request)); 12926714d8e8SKurt Hackel request.node_idx = dlm->node_num; 12936714d8e8SKurt Hackel 12946714d8e8SKurt Hackel BUG_ON(mle->type == DLM_MLE_MIGRATION); 12956714d8e8SKurt Hackel 12967141514bSSunil Mushran request.namelen = (u8)mle->mnamelen; 12977141514bSSunil Mushran memcpy(request.name, mle->mname, request.namelen); 12986714d8e8SKurt Hackel 12996714d8e8SKurt Hackel again: 13006714d8e8SKurt Hackel ret = o2net_send_message(DLM_MASTER_REQUEST_MSG, dlm->key, &request, 13016714d8e8SKurt Hackel sizeof(request), to, &response); 13026714d8e8SKurt Hackel if (ret < 0) { 13036714d8e8SKurt Hackel if (ret == -ESRCH) { 13046714d8e8SKurt Hackel /* should never happen */ 13056714d8e8SKurt Hackel mlog(ML_ERROR, "TCP stack not ready!\n"); 13066714d8e8SKurt Hackel BUG(); 13076714d8e8SKurt Hackel } else if (ret == -EINVAL) { 13086714d8e8SKurt Hackel mlog(ML_ERROR, "bad args passed to o2net!\n"); 13096714d8e8SKurt Hackel BUG(); 13106714d8e8SKurt Hackel } else if (ret == -ENOMEM) { 13116714d8e8SKurt Hackel mlog(ML_ERROR, "out of memory while trying to send " 13126714d8e8SKurt Hackel "network message! retrying\n"); 13136714d8e8SKurt Hackel /* this is totally crude */ 13146714d8e8SKurt Hackel msleep(50); 13156714d8e8SKurt Hackel goto again; 13166714d8e8SKurt Hackel } else if (!dlm_is_host_down(ret)) { 13176714d8e8SKurt Hackel /* not a network error. bad. */ 13186714d8e8SKurt Hackel mlog_errno(ret); 13196714d8e8SKurt Hackel mlog(ML_ERROR, "unhandled error!"); 13206714d8e8SKurt Hackel BUG(); 13216714d8e8SKurt Hackel } 13226714d8e8SKurt Hackel /* all other errors should be network errors, 13236714d8e8SKurt Hackel * and likely indicate node death */ 13246714d8e8SKurt Hackel mlog(ML_ERROR, "link to %d went down!\n", to); 13256714d8e8SKurt Hackel goto out; 13266714d8e8SKurt Hackel } 13276714d8e8SKurt Hackel 13286714d8e8SKurt Hackel ret = 0; 13296714d8e8SKurt Hackel resend = 0; 13306714d8e8SKurt Hackel spin_lock(&mle->spinlock); 13316714d8e8SKurt Hackel switch (response) { 13326714d8e8SKurt Hackel case DLM_MASTER_RESP_YES: 13336714d8e8SKurt Hackel set_bit(to, mle->response_map); 13346714d8e8SKurt Hackel mlog(0, "node %u is the master, response=YES\n", to); 1335ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master node %u now knows I have a " 1336ba2bf218SKurt Hackel "reference\n", dlm->name, res->lockname.len, 1337ba2bf218SKurt Hackel res->lockname.name, to); 13386714d8e8SKurt Hackel mle->master = to; 13396714d8e8SKurt Hackel break; 13406714d8e8SKurt Hackel case DLM_MASTER_RESP_NO: 13416714d8e8SKurt Hackel mlog(0, "node %u not master, response=NO\n", to); 13426714d8e8SKurt Hackel set_bit(to, mle->response_map); 13436714d8e8SKurt Hackel break; 13446714d8e8SKurt Hackel case DLM_MASTER_RESP_MAYBE: 13456714d8e8SKurt Hackel mlog(0, "node %u not master, response=MAYBE\n", to); 13466714d8e8SKurt Hackel set_bit(to, mle->response_map); 13476714d8e8SKurt Hackel set_bit(to, mle->maybe_map); 13486714d8e8SKurt Hackel break; 13496714d8e8SKurt Hackel case DLM_MASTER_RESP_ERROR: 13506714d8e8SKurt Hackel mlog(0, "node %u hit an error, resending\n", to); 13516714d8e8SKurt Hackel resend = 1; 13526714d8e8SKurt Hackel response = 0; 13536714d8e8SKurt Hackel break; 13546714d8e8SKurt Hackel default: 13556714d8e8SKurt Hackel mlog(ML_ERROR, "bad response! %u\n", response); 13566714d8e8SKurt Hackel BUG(); 13576714d8e8SKurt Hackel } 13586714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 13596714d8e8SKurt Hackel if (resend) { 13606714d8e8SKurt Hackel /* this is also totally crude */ 13616714d8e8SKurt Hackel msleep(50); 13626714d8e8SKurt Hackel goto again; 13636714d8e8SKurt Hackel } 13646714d8e8SKurt Hackel 13656714d8e8SKurt Hackel out: 13666714d8e8SKurt Hackel return ret; 13676714d8e8SKurt Hackel } 13686714d8e8SKurt Hackel 13696714d8e8SKurt Hackel /* 13706714d8e8SKurt Hackel * locks that can be taken here: 13716714d8e8SKurt Hackel * dlm->spinlock 13726714d8e8SKurt Hackel * res->spinlock 13736714d8e8SKurt Hackel * mle->spinlock 13746714d8e8SKurt Hackel * dlm->master_list 13756714d8e8SKurt Hackel * 13766714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!! 13776714d8e8SKurt Hackel */ 1378d74c9803SKurt Hackel int dlm_master_request_handler(struct o2net_msg *msg, u32 len, void *data, 1379d74c9803SKurt Hackel void **ret_data) 13806714d8e8SKurt Hackel { 13816714d8e8SKurt Hackel u8 response = DLM_MASTER_RESP_MAYBE; 13826714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 13839c6510a5SKurt Hackel struct dlm_lock_resource *res = NULL; 13846714d8e8SKurt Hackel struct dlm_master_request *request = (struct dlm_master_request *) msg->buf; 13856714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *tmpmle = NULL; 13866714d8e8SKurt Hackel char *name; 1387a3d33291SMark Fasheh unsigned int namelen, hash; 13886714d8e8SKurt Hackel int found, ret; 13896714d8e8SKurt Hackel int set_maybe; 13909c6510a5SKurt Hackel int dispatch_assert = 0; 13916714d8e8SKurt Hackel 13926714d8e8SKurt Hackel if (!dlm_grab(dlm)) 13936714d8e8SKurt Hackel return DLM_MASTER_RESP_NO; 13946714d8e8SKurt Hackel 13956714d8e8SKurt Hackel if (!dlm_domain_fully_joined(dlm)) { 13966714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 13976714d8e8SKurt Hackel goto send_response; 13986714d8e8SKurt Hackel } 13996714d8e8SKurt Hackel 14006714d8e8SKurt Hackel name = request->name; 14016714d8e8SKurt Hackel namelen = request->namelen; 1402a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 14036714d8e8SKurt Hackel 14046714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 14056714d8e8SKurt Hackel response = DLM_IVBUFLEN; 14066714d8e8SKurt Hackel goto send_response; 14076714d8e8SKurt Hackel } 14086714d8e8SKurt Hackel 14096714d8e8SKurt Hackel way_up_top: 14106714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 1411a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 14126714d8e8SKurt Hackel if (res) { 14136714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 14146714d8e8SKurt Hackel 14156714d8e8SKurt Hackel /* take care of the easy cases up front */ 14166714d8e8SKurt Hackel spin_lock(&res->spinlock); 14171cd04dbeSKurt Hackel if (res->state & (DLM_LOCK_RES_RECOVERING| 14181cd04dbeSKurt Hackel DLM_LOCK_RES_MIGRATING)) { 14196714d8e8SKurt Hackel spin_unlock(&res->spinlock); 14206714d8e8SKurt Hackel mlog(0, "returning DLM_MASTER_RESP_ERROR since res is " 14211cd04dbeSKurt Hackel "being recovered/migrated\n"); 14226714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR; 14236714d8e8SKurt Hackel if (mle) 14246714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 14256714d8e8SKurt Hackel goto send_response; 14266714d8e8SKurt Hackel } 14276714d8e8SKurt Hackel 14286714d8e8SKurt Hackel if (res->owner == dlm->node_num) { 1429ba2bf218SKurt Hackel mlog(0, "%s:%.*s: setting bit %u in refmap\n", 1430ba2bf218SKurt Hackel dlm->name, namelen, name, request->node_idx); 1431ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(request->node_idx, res); 14326714d8e8SKurt Hackel spin_unlock(&res->spinlock); 14336714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES; 14346714d8e8SKurt Hackel if (mle) 14356714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 14366714d8e8SKurt Hackel 14376714d8e8SKurt Hackel /* this node is the owner. 14386714d8e8SKurt Hackel * there is some extra work that needs to 14396714d8e8SKurt Hackel * happen now. the requesting node has 14406714d8e8SKurt Hackel * caused all nodes up to this one to 14416714d8e8SKurt Hackel * create mles. this node now needs to 14426714d8e8SKurt Hackel * go back and clean those up. */ 14439c6510a5SKurt Hackel dispatch_assert = 1; 14446714d8e8SKurt Hackel goto send_response; 14456714d8e8SKurt Hackel } else if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 14466714d8e8SKurt Hackel spin_unlock(&res->spinlock); 14476714d8e8SKurt Hackel // mlog(0, "node %u is the master\n", res->owner); 14486714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 14496714d8e8SKurt Hackel if (mle) 14506714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 14516714d8e8SKurt Hackel goto send_response; 14526714d8e8SKurt Hackel } 14536714d8e8SKurt Hackel 14546714d8e8SKurt Hackel /* ok, there is no owner. either this node is 14556714d8e8SKurt Hackel * being blocked, or it is actively trying to 14566714d8e8SKurt Hackel * master this lock. */ 14576714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) { 14586714d8e8SKurt Hackel mlog(ML_ERROR, "lock with no owner should be " 14596714d8e8SKurt Hackel "in-progress!\n"); 14606714d8e8SKurt Hackel BUG(); 14616714d8e8SKurt Hackel } 14626714d8e8SKurt Hackel 14636714d8e8SKurt Hackel // mlog(0, "lockres is in progress...\n"); 14646714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 14656714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen); 14666714d8e8SKurt Hackel if (!found) { 14676714d8e8SKurt Hackel mlog(ML_ERROR, "no mle found for this lock!\n"); 14686714d8e8SKurt Hackel BUG(); 14696714d8e8SKurt Hackel } 14706714d8e8SKurt Hackel set_maybe = 1; 14716714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock); 14726714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK) { 14736714d8e8SKurt Hackel // mlog(0, "this node is waiting for " 14746714d8e8SKurt Hackel // "lockres to be mastered\n"); 14756714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 14766714d8e8SKurt Hackel } else if (tmpmle->type == DLM_MLE_MIGRATION) { 14776714d8e8SKurt Hackel mlog(0, "node %u is master, but trying to migrate to " 14786714d8e8SKurt Hackel "node %u.\n", tmpmle->master, tmpmle->new_master); 14796714d8e8SKurt Hackel if (tmpmle->master == dlm->node_num) { 14806714d8e8SKurt Hackel mlog(ML_ERROR, "no owner on lockres, but this " 14816714d8e8SKurt Hackel "node is trying to migrate it to %u?!\n", 14826714d8e8SKurt Hackel tmpmle->new_master); 14836714d8e8SKurt Hackel BUG(); 14846714d8e8SKurt Hackel } else { 14856714d8e8SKurt Hackel /* the real master can respond on its own */ 14866714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 14876714d8e8SKurt Hackel } 14886714d8e8SKurt Hackel } else if (tmpmle->master != DLM_LOCK_RES_OWNER_UNKNOWN) { 14896714d8e8SKurt Hackel set_maybe = 0; 14909c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) { 14916714d8e8SKurt Hackel response = DLM_MASTER_RESP_YES; 14929c6510a5SKurt Hackel /* this node will be the owner. 14939c6510a5SKurt Hackel * go back and clean the mles on any 14949c6510a5SKurt Hackel * other nodes */ 14959c6510a5SKurt Hackel dispatch_assert = 1; 1496ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(request->node_idx, res); 1497ba2bf218SKurt Hackel mlog(0, "%s:%.*s: setting bit %u in refmap\n", 1498ba2bf218SKurt Hackel dlm->name, namelen, name, 1499ba2bf218SKurt Hackel request->node_idx); 15009c6510a5SKurt Hackel } else 15016714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15026714d8e8SKurt Hackel } else { 15036714d8e8SKurt Hackel // mlog(0, "this node is attempting to " 15046714d8e8SKurt Hackel // "master lockres\n"); 15056714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE; 15066714d8e8SKurt Hackel } 15076714d8e8SKurt Hackel if (set_maybe) 15086714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map); 15096714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock); 15106714d8e8SKurt Hackel 15116714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 15126714d8e8SKurt Hackel spin_unlock(&res->spinlock); 15136714d8e8SKurt Hackel 15146714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */ 15156714d8e8SKurt Hackel dlm_put_mle(tmpmle); 15166714d8e8SKurt Hackel if (mle) 15176714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 15186714d8e8SKurt Hackel goto send_response; 15196714d8e8SKurt Hackel } 15206714d8e8SKurt Hackel 15216714d8e8SKurt Hackel /* 15226714d8e8SKurt Hackel * lockres doesn't exist on this node 15236714d8e8SKurt Hackel * if there is an MLE_BLOCK, return NO 15246714d8e8SKurt Hackel * if there is an MLE_MASTER, return MAYBE 15256714d8e8SKurt Hackel * otherwise, add an MLE_BLOCK, return NO 15266714d8e8SKurt Hackel */ 15276714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 15286714d8e8SKurt Hackel found = dlm_find_mle(dlm, &tmpmle, name, namelen); 15296714d8e8SKurt Hackel if (!found) { 15306714d8e8SKurt Hackel /* this lockid has never been seen on this node yet */ 15316714d8e8SKurt Hackel // mlog(0, "no mle found\n"); 15326714d8e8SKurt Hackel if (!mle) { 15336714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 15346714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 15356714d8e8SKurt Hackel 15363914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 15376714d8e8SKurt Hackel if (!mle) { 15386714d8e8SKurt Hackel response = DLM_MASTER_RESP_ERROR; 15399c6510a5SKurt Hackel mlog_errno(-ENOMEM); 15406714d8e8SKurt Hackel goto send_response; 15416714d8e8SKurt Hackel } 15426714d8e8SKurt Hackel goto way_up_top; 15436714d8e8SKurt Hackel } 15446714d8e8SKurt Hackel 15456714d8e8SKurt Hackel // mlog(0, "this is second time thru, already allocated, " 15466714d8e8SKurt Hackel // "add the block.\n"); 154741b8c8a1SKurt Hackel dlm_init_mle(mle, DLM_MLE_BLOCK, dlm, NULL, name, namelen); 15486714d8e8SKurt Hackel set_bit(request->node_idx, mle->maybe_map); 15491c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 15506714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15516714d8e8SKurt Hackel } else { 15526714d8e8SKurt Hackel // mlog(0, "mle was found\n"); 15536714d8e8SKurt Hackel set_maybe = 1; 15546714d8e8SKurt Hackel spin_lock(&tmpmle->spinlock); 15559c6510a5SKurt Hackel if (tmpmle->master == dlm->node_num) { 15569c6510a5SKurt Hackel mlog(ML_ERROR, "no lockres, but an mle with this node as master!\n"); 15579c6510a5SKurt Hackel BUG(); 15589c6510a5SKurt Hackel } 15596714d8e8SKurt Hackel if (tmpmle->type == DLM_MLE_BLOCK) 15606714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15616714d8e8SKurt Hackel else if (tmpmle->type == DLM_MLE_MIGRATION) { 15626714d8e8SKurt Hackel mlog(0, "migration mle was found (%u->%u)\n", 15636714d8e8SKurt Hackel tmpmle->master, tmpmle->new_master); 15646714d8e8SKurt Hackel /* real master can respond on its own */ 15656714d8e8SKurt Hackel response = DLM_MASTER_RESP_NO; 15666714d8e8SKurt Hackel } else 15676714d8e8SKurt Hackel response = DLM_MASTER_RESP_MAYBE; 15686714d8e8SKurt Hackel if (set_maybe) 15696714d8e8SKurt Hackel set_bit(request->node_idx, tmpmle->maybe_map); 15706714d8e8SKurt Hackel spin_unlock(&tmpmle->spinlock); 15716714d8e8SKurt Hackel } 15726714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 15736714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 15746714d8e8SKurt Hackel 15756714d8e8SKurt Hackel if (found) { 15766714d8e8SKurt Hackel /* keep the mle attached to heartbeat events */ 15776714d8e8SKurt Hackel dlm_put_mle(tmpmle); 15786714d8e8SKurt Hackel } 15796714d8e8SKurt Hackel send_response: 1580b31cfc02SSunil Mushran /* 1581b31cfc02SSunil Mushran * __dlm_lookup_lockres() grabbed a reference to this lockres. 1582b31cfc02SSunil Mushran * The reference is released by dlm_assert_master_worker() under 1583b31cfc02SSunil Mushran * the call to dlm_dispatch_assert_master(). If 1584b31cfc02SSunil Mushran * dlm_assert_master_worker() isn't called, we drop it here. 1585b31cfc02SSunil Mushran */ 15869c6510a5SKurt Hackel if (dispatch_assert) { 15879c6510a5SKurt Hackel if (response != DLM_MASTER_RESP_YES) 15889c6510a5SKurt Hackel mlog(ML_ERROR, "invalid response %d\n", response); 15899c6510a5SKurt Hackel if (!res) { 15909c6510a5SKurt Hackel mlog(ML_ERROR, "bad lockres while trying to assert!\n"); 15919c6510a5SKurt Hackel BUG(); 15929c6510a5SKurt Hackel } 15939c6510a5SKurt Hackel mlog(0, "%u is the owner of %.*s, cleaning everyone else\n", 15949c6510a5SKurt Hackel dlm->node_num, res->lockname.len, res->lockname.name); 15959c6510a5SKurt Hackel ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx, 15969c6510a5SKurt Hackel DLM_ASSERT_MASTER_MLE_CLEANUP); 15979c6510a5SKurt Hackel if (ret < 0) { 15989c6510a5SKurt Hackel mlog(ML_ERROR, "failed to dispatch assert master work\n"); 15999c6510a5SKurt Hackel response = DLM_MASTER_RESP_ERROR; 1600b31cfc02SSunil Mushran dlm_lockres_put(res); 16019c6510a5SKurt Hackel } 1602b31cfc02SSunil Mushran } else { 1603b31cfc02SSunil Mushran if (res) 1604b31cfc02SSunil Mushran dlm_lockres_put(res); 16059c6510a5SKurt Hackel } 16069c6510a5SKurt Hackel 16076714d8e8SKurt Hackel dlm_put(dlm); 16086714d8e8SKurt Hackel return response; 16096714d8e8SKurt Hackel } 16106714d8e8SKurt Hackel 16116714d8e8SKurt Hackel /* 16126714d8e8SKurt Hackel * DLM_ASSERT_MASTER_MSG 16136714d8e8SKurt Hackel */ 16146714d8e8SKurt Hackel 16156714d8e8SKurt Hackel 16166714d8e8SKurt Hackel /* 16176714d8e8SKurt Hackel * NOTE: this can be used for debugging 16186714d8e8SKurt Hackel * can periodically run all locks owned by this node 16196714d8e8SKurt Hackel * and re-assert across the cluster... 16206714d8e8SKurt Hackel */ 162105488bbeSAdrian Bunk static int dlm_do_assert_master(struct dlm_ctxt *dlm, 1622ba2bf218SKurt Hackel struct dlm_lock_resource *res, 1623ba2bf218SKurt Hackel void *nodemap, u32 flags) 16246714d8e8SKurt Hackel { 16256714d8e8SKurt Hackel struct dlm_assert_master assert; 16266714d8e8SKurt Hackel int to, tmpret; 16276714d8e8SKurt Hackel struct dlm_node_iter iter; 16286714d8e8SKurt Hackel int ret = 0; 16299c6510a5SKurt Hackel int reassert; 1630ba2bf218SKurt Hackel const char *lockname = res->lockname.name; 1631ba2bf218SKurt Hackel unsigned int namelen = res->lockname.len; 16326714d8e8SKurt Hackel 16336714d8e8SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN); 1634f3f85464SSunil Mushran 1635f3f85464SSunil Mushran spin_lock(&res->spinlock); 1636f3f85464SSunil Mushran res->state |= DLM_LOCK_RES_SETREF_INPROG; 1637f3f85464SSunil Mushran spin_unlock(&res->spinlock); 1638f3f85464SSunil Mushran 16399c6510a5SKurt Hackel again: 16409c6510a5SKurt Hackel reassert = 0; 16416714d8e8SKurt Hackel 16426714d8e8SKurt Hackel /* note that if this nodemap is empty, it returns 0 */ 16436714d8e8SKurt Hackel dlm_node_iter_init(nodemap, &iter); 16446714d8e8SKurt Hackel while ((to = dlm_node_iter_next(&iter)) >= 0) { 16456714d8e8SKurt Hackel int r = 0; 1646a9ee4c8aSKurt Hackel struct dlm_master_list_entry *mle = NULL; 1647a9ee4c8aSKurt Hackel 16486714d8e8SKurt Hackel mlog(0, "sending assert master to %d (%.*s)\n", to, 16496714d8e8SKurt Hackel namelen, lockname); 16506714d8e8SKurt Hackel memset(&assert, 0, sizeof(assert)); 16516714d8e8SKurt Hackel assert.node_idx = dlm->node_num; 16526714d8e8SKurt Hackel assert.namelen = namelen; 16536714d8e8SKurt Hackel memcpy(assert.name, lockname, namelen); 16546714d8e8SKurt Hackel assert.flags = cpu_to_be32(flags); 16556714d8e8SKurt Hackel 16566714d8e8SKurt Hackel tmpret = o2net_send_message(DLM_ASSERT_MASTER_MSG, dlm->key, 16576714d8e8SKurt Hackel &assert, sizeof(assert), to, &r); 16586714d8e8SKurt Hackel if (tmpret < 0) { 1659a5196ec5SWengang Wang mlog(ML_ERROR, "Error %d when sending message %u (key " 1660a5196ec5SWengang Wang "0x%x) to node %u\n", tmpret, 1661a5196ec5SWengang Wang DLM_ASSERT_MASTER_MSG, dlm->key, to); 16626714d8e8SKurt Hackel if (!dlm_is_host_down(tmpret)) { 16633b3b84a8SKurt Hackel mlog(ML_ERROR, "unhandled error=%d!\n", tmpret); 16646714d8e8SKurt Hackel BUG(); 16656714d8e8SKurt Hackel } 16666714d8e8SKurt Hackel /* a node died. finish out the rest of the nodes. */ 16673b3b84a8SKurt Hackel mlog(0, "link to %d went down!\n", to); 16686714d8e8SKurt Hackel /* any nonzero status return will do */ 16696714d8e8SKurt Hackel ret = tmpret; 1670ba2bf218SKurt Hackel r = 0; 16716714d8e8SKurt Hackel } else if (r < 0) { 16726714d8e8SKurt Hackel /* ok, something horribly messed. kill thyself. */ 16736714d8e8SKurt Hackel mlog(ML_ERROR,"during assert master of %.*s to %u, " 16746714d8e8SKurt Hackel "got %d.\n", namelen, lockname, to, r); 1675a9ee4c8aSKurt Hackel spin_lock(&dlm->spinlock); 1676a9ee4c8aSKurt Hackel spin_lock(&dlm->master_lock); 1677a9ee4c8aSKurt Hackel if (dlm_find_mle(dlm, &mle, (char *)lockname, 1678a9ee4c8aSKurt Hackel namelen)) { 1679a9ee4c8aSKurt Hackel dlm_print_one_mle(mle); 1680a9ee4c8aSKurt Hackel __dlm_put_mle(mle); 1681a9ee4c8aSKurt Hackel } 1682a9ee4c8aSKurt Hackel spin_unlock(&dlm->master_lock); 1683a9ee4c8aSKurt Hackel spin_unlock(&dlm->spinlock); 16846714d8e8SKurt Hackel BUG(); 1685ba2bf218SKurt Hackel } 1686ba2bf218SKurt Hackel 1687ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT && 1688ba2bf218SKurt Hackel !(r & DLM_ASSERT_RESPONSE_MASTERY_REF)) { 1689ba2bf218SKurt Hackel mlog(ML_ERROR, "%.*s: very strange, " 1690ba2bf218SKurt Hackel "master MLE but no lockres on %u\n", 1691ba2bf218SKurt Hackel namelen, lockname, to); 1692ba2bf218SKurt Hackel } 1693ba2bf218SKurt Hackel 1694ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_REASSERT) { 16959c6510a5SKurt Hackel mlog(0, "%.*s: node %u create mles on other " 16969c6510a5SKurt Hackel "nodes and requests a re-assert\n", 16979c6510a5SKurt Hackel namelen, lockname, to); 16989c6510a5SKurt Hackel reassert = 1; 16996714d8e8SKurt Hackel } 1700ba2bf218SKurt Hackel if (r & DLM_ASSERT_RESPONSE_MASTERY_REF) { 1701ba2bf218SKurt Hackel mlog(0, "%.*s: node %u has a reference to this " 1702ba2bf218SKurt Hackel "lockres, set the bit in the refmap\n", 1703ba2bf218SKurt Hackel namelen, lockname, to); 1704ba2bf218SKurt Hackel spin_lock(&res->spinlock); 1705ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(to, res); 1706ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 1707ba2bf218SKurt Hackel } 17086714d8e8SKurt Hackel } 17096714d8e8SKurt Hackel 17109c6510a5SKurt Hackel if (reassert) 17119c6510a5SKurt Hackel goto again; 17129c6510a5SKurt Hackel 1713f3f85464SSunil Mushran spin_lock(&res->spinlock); 1714f3f85464SSunil Mushran res->state &= ~DLM_LOCK_RES_SETREF_INPROG; 1715f3f85464SSunil Mushran spin_unlock(&res->spinlock); 1716f3f85464SSunil Mushran wake_up(&res->wq); 1717f3f85464SSunil Mushran 17186714d8e8SKurt Hackel return ret; 17196714d8e8SKurt Hackel } 17206714d8e8SKurt Hackel 17216714d8e8SKurt Hackel /* 17226714d8e8SKurt Hackel * locks that can be taken here: 17236714d8e8SKurt Hackel * dlm->spinlock 17246714d8e8SKurt Hackel * res->spinlock 17256714d8e8SKurt Hackel * mle->spinlock 17266714d8e8SKurt Hackel * dlm->master_list 17276714d8e8SKurt Hackel * 17286714d8e8SKurt Hackel * if possible, TRIM THIS DOWN!!! 17296714d8e8SKurt Hackel */ 1730d74c9803SKurt Hackel int dlm_assert_master_handler(struct o2net_msg *msg, u32 len, void *data, 1731d74c9803SKurt Hackel void **ret_data) 17326714d8e8SKurt Hackel { 17336714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 17346714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 17356714d8e8SKurt Hackel struct dlm_assert_master *assert = (struct dlm_assert_master *)msg->buf; 17366714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL; 17376714d8e8SKurt Hackel char *name; 1738a3d33291SMark Fasheh unsigned int namelen, hash; 17396714d8e8SKurt Hackel u32 flags; 1740ba2bf218SKurt Hackel int master_request = 0, have_lockres_ref = 0; 17419c6510a5SKurt Hackel int ret = 0; 17426714d8e8SKurt Hackel 17436714d8e8SKurt Hackel if (!dlm_grab(dlm)) 17446714d8e8SKurt Hackel return 0; 17456714d8e8SKurt Hackel 17466714d8e8SKurt Hackel name = assert->name; 17476714d8e8SKurt Hackel namelen = assert->namelen; 1748a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 17496714d8e8SKurt Hackel flags = be32_to_cpu(assert->flags); 17506714d8e8SKurt Hackel 17516714d8e8SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 17526714d8e8SKurt Hackel mlog(ML_ERROR, "Invalid name length!"); 17536714d8e8SKurt Hackel goto done; 17546714d8e8SKurt Hackel } 17556714d8e8SKurt Hackel 17566714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 17576714d8e8SKurt Hackel 17586714d8e8SKurt Hackel if (flags) 17596714d8e8SKurt Hackel mlog(0, "assert_master with flags: %u\n", flags); 17606714d8e8SKurt Hackel 17616714d8e8SKurt Hackel /* find the MLE */ 17626714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 17636714d8e8SKurt Hackel if (!dlm_find_mle(dlm, &mle, name, namelen)) { 17646714d8e8SKurt Hackel /* not an error, could be master just re-asserting */ 17656714d8e8SKurt Hackel mlog(0, "just got an assert_master from %u, but no " 17666714d8e8SKurt Hackel "MLE for it! (%.*s)\n", assert->node_idx, 17676714d8e8SKurt Hackel namelen, name); 17686714d8e8SKurt Hackel } else { 17696714d8e8SKurt Hackel int bit = find_next_bit (mle->maybe_map, O2NM_MAX_NODES, 0); 17706714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) { 17716714d8e8SKurt Hackel /* not necessarily an error, though less likely. 17726714d8e8SKurt Hackel * could be master just re-asserting. */ 1773aa852354SKurt Hackel mlog(0, "no bits set in the maybe_map, but %u " 17746714d8e8SKurt Hackel "is asserting! (%.*s)\n", assert->node_idx, 17756714d8e8SKurt Hackel namelen, name); 17766714d8e8SKurt Hackel } else if (bit != assert->node_idx) { 17776714d8e8SKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) { 17786714d8e8SKurt Hackel mlog(0, "master %u was found, %u should " 17796714d8e8SKurt Hackel "back off\n", assert->node_idx, bit); 17806714d8e8SKurt Hackel } else { 17816714d8e8SKurt Hackel /* with the fix for bug 569, a higher node 17826714d8e8SKurt Hackel * number winning the mastery will respond 17836714d8e8SKurt Hackel * YES to mastery requests, but this node 17846714d8e8SKurt Hackel * had no way of knowing. let it pass. */ 1785aa852354SKurt Hackel mlog(0, "%u is the lowest node, " 17866714d8e8SKurt Hackel "%u is asserting. (%.*s) %u must " 17876714d8e8SKurt Hackel "have begun after %u won.\n", bit, 17886714d8e8SKurt Hackel assert->node_idx, namelen, name, bit, 17896714d8e8SKurt Hackel assert->node_idx); 17906714d8e8SKurt Hackel } 17916714d8e8SKurt Hackel } 17922d1a868cSKurt Hackel if (mle->type == DLM_MLE_MIGRATION) { 17932d1a868cSKurt Hackel if (flags & DLM_ASSERT_MASTER_MLE_CLEANUP) { 17942d1a868cSKurt Hackel mlog(0, "%s:%.*s: got cleanup assert" 17952d1a868cSKurt Hackel " from %u for migration\n", 17962d1a868cSKurt Hackel dlm->name, namelen, name, 17972d1a868cSKurt Hackel assert->node_idx); 17982d1a868cSKurt Hackel } else if (!(flags & DLM_ASSERT_MASTER_FINISH_MIGRATION)) { 17992d1a868cSKurt Hackel mlog(0, "%s:%.*s: got unrelated assert" 18002d1a868cSKurt Hackel " from %u for migration, ignoring\n", 18012d1a868cSKurt Hackel dlm->name, namelen, name, 18022d1a868cSKurt Hackel assert->node_idx); 18032d1a868cSKurt Hackel __dlm_put_mle(mle); 18042d1a868cSKurt Hackel spin_unlock(&dlm->master_lock); 18052d1a868cSKurt Hackel spin_unlock(&dlm->spinlock); 18062d1a868cSKurt Hackel goto done; 18072d1a868cSKurt Hackel } 18082d1a868cSKurt Hackel } 18096714d8e8SKurt Hackel } 18106714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 18116714d8e8SKurt Hackel 18126714d8e8SKurt Hackel /* ok everything checks out with the MLE 18136714d8e8SKurt Hackel * now check to see if there is a lockres */ 1814a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 18156714d8e8SKurt Hackel if (res) { 18166714d8e8SKurt Hackel spin_lock(&res->spinlock); 18176714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) { 18186714d8e8SKurt Hackel mlog(ML_ERROR, "%u asserting but %.*s is " 18196714d8e8SKurt Hackel "RECOVERING!\n", assert->node_idx, namelen, name); 18206714d8e8SKurt Hackel goto kill; 18216714d8e8SKurt Hackel } 18226714d8e8SKurt Hackel if (!mle) { 1823dc2ed195SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN && 1824dc2ed195SKurt Hackel res->owner != assert->node_idx) { 182553ecd25eSSunil Mushran mlog(ML_ERROR, "DIE! Mastery assert from %u, " 182653ecd25eSSunil Mushran "but current owner is %u! (%.*s)\n", 182753ecd25eSSunil Mushran assert->node_idx, res->owner, namelen, 182853ecd25eSSunil Mushran name); 182953ecd25eSSunil Mushran __dlm_print_one_lock_resource(res); 183053ecd25eSSunil Mushran BUG(); 18316714d8e8SKurt Hackel } 18326714d8e8SKurt Hackel } else if (mle->type != DLM_MLE_MIGRATION) { 18336714d8e8SKurt Hackel if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) { 18346714d8e8SKurt Hackel /* owner is just re-asserting */ 18356714d8e8SKurt Hackel if (res->owner == assert->node_idx) { 18366714d8e8SKurt Hackel mlog(0, "owner %u re-asserting on " 18376714d8e8SKurt Hackel "lock %.*s\n", assert->node_idx, 18386714d8e8SKurt Hackel namelen, name); 18396714d8e8SKurt Hackel goto ok; 18406714d8e8SKurt Hackel } 18416714d8e8SKurt Hackel mlog(ML_ERROR, "got assert_master from " 18426714d8e8SKurt Hackel "node %u, but %u is the owner! " 18436714d8e8SKurt Hackel "(%.*s)\n", assert->node_idx, 18446714d8e8SKurt Hackel res->owner, namelen, name); 18456714d8e8SKurt Hackel goto kill; 18466714d8e8SKurt Hackel } 18476714d8e8SKurt Hackel if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) { 18486714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but lock " 18496714d8e8SKurt Hackel "with no owner should be " 18506714d8e8SKurt Hackel "in-progress! (%.*s)\n", 18516714d8e8SKurt Hackel assert->node_idx, 18526714d8e8SKurt Hackel namelen, name); 18536714d8e8SKurt Hackel goto kill; 18546714d8e8SKurt Hackel } 18556714d8e8SKurt Hackel } else /* mle->type == DLM_MLE_MIGRATION */ { 18566714d8e8SKurt Hackel /* should only be getting an assert from new master */ 18576714d8e8SKurt Hackel if (assert->node_idx != mle->new_master) { 18586714d8e8SKurt Hackel mlog(ML_ERROR, "got assert from %u, but " 18596714d8e8SKurt Hackel "new master is %u, and old master " 18606714d8e8SKurt Hackel "was %u (%.*s)\n", 18616714d8e8SKurt Hackel assert->node_idx, mle->new_master, 18626714d8e8SKurt Hackel mle->master, namelen, name); 18636714d8e8SKurt Hackel goto kill; 18646714d8e8SKurt Hackel } 18656714d8e8SKurt Hackel 18666714d8e8SKurt Hackel } 18676714d8e8SKurt Hackel ok: 18686714d8e8SKurt Hackel spin_unlock(&res->spinlock); 18696714d8e8SKurt Hackel } 18706714d8e8SKurt Hackel 18716714d8e8SKurt Hackel // mlog(0, "woo! got an assert_master from node %u!\n", 18726714d8e8SKurt Hackel // assert->node_idx); 18736714d8e8SKurt Hackel if (mle) { 18749c6510a5SKurt Hackel int extra_ref = 0; 18759c6510a5SKurt Hackel int nn = -1; 1876a2bf0477SKurt Hackel int rr, err = 0; 18776714d8e8SKurt Hackel 18786714d8e8SKurt Hackel spin_lock(&mle->spinlock); 18799c6510a5SKurt Hackel if (mle->type == DLM_MLE_BLOCK || mle->type == DLM_MLE_MIGRATION) 18809c6510a5SKurt Hackel extra_ref = 1; 18819c6510a5SKurt Hackel else { 18829c6510a5SKurt Hackel /* MASTER mle: if any bits set in the response map 18839c6510a5SKurt Hackel * then the calling node needs to re-assert to clear 18849c6510a5SKurt Hackel * up nodes that this node contacted */ 18859c6510a5SKurt Hackel while ((nn = find_next_bit (mle->response_map, O2NM_MAX_NODES, 18869c6510a5SKurt Hackel nn+1)) < O2NM_MAX_NODES) { 18879c6510a5SKurt Hackel if (nn != dlm->node_num && nn != assert->node_idx) 18889c6510a5SKurt Hackel master_request = 1; 18899c6510a5SKurt Hackel } 18909c6510a5SKurt Hackel } 18916714d8e8SKurt Hackel mle->master = assert->node_idx; 18926714d8e8SKurt Hackel atomic_set(&mle->woken, 1); 18936714d8e8SKurt Hackel wake_up(&mle->wq); 18946714d8e8SKurt Hackel spin_unlock(&mle->spinlock); 18956714d8e8SKurt Hackel 1896a2bf0477SKurt Hackel if (res) { 1897a6fa3640SKurt Hackel int wake = 0; 1898a2bf0477SKurt Hackel spin_lock(&res->spinlock); 1899a2bf0477SKurt Hackel if (mle->type == DLM_MLE_MIGRATION) { 19006714d8e8SKurt Hackel mlog(0, "finishing off migration of lockres %.*s, " 19016714d8e8SKurt Hackel "from %u to %u\n", 19026714d8e8SKurt Hackel res->lockname.len, res->lockname.name, 19036714d8e8SKurt Hackel dlm->node_num, mle->new_master); 19046714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 1905a6fa3640SKurt Hackel wake = 1; 19066714d8e8SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->new_master); 19076714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DIRTY); 1908a2bf0477SKurt Hackel } else { 1909a2bf0477SKurt Hackel dlm_change_lockres_owner(dlm, res, mle->master); 1910a2bf0477SKurt Hackel } 19116714d8e8SKurt Hackel spin_unlock(&res->spinlock); 1912ba2bf218SKurt Hackel have_lockres_ref = 1; 1913a6fa3640SKurt Hackel if (wake) 1914a6fa3640SKurt Hackel wake_up(&res->wq); 19156714d8e8SKurt Hackel } 19166714d8e8SKurt Hackel 1917a2bf0477SKurt Hackel /* master is known, detach if not already detached. 1918a2bf0477SKurt Hackel * ensures that only one assert_master call will happen 1919a2bf0477SKurt Hackel * on this mle. */ 1920a2bf0477SKurt Hackel spin_lock(&dlm->master_lock); 1921a2bf0477SKurt Hackel 1922a2bf0477SKurt Hackel rr = atomic_read(&mle->mle_refs.refcount); 1923a2bf0477SKurt Hackel if (mle->inuse > 0) { 1924a2bf0477SKurt Hackel if (extra_ref && rr < 3) 1925a2bf0477SKurt Hackel err = 1; 1926a2bf0477SKurt Hackel else if (!extra_ref && rr < 2) 1927a2bf0477SKurt Hackel err = 1; 1928a2bf0477SKurt Hackel } else { 1929a2bf0477SKurt Hackel if (extra_ref && rr < 2) 1930a2bf0477SKurt Hackel err = 1; 1931a2bf0477SKurt Hackel else if (!extra_ref && rr < 1) 1932a2bf0477SKurt Hackel err = 1; 1933a2bf0477SKurt Hackel } 1934a2bf0477SKurt Hackel if (err) { 1935a2bf0477SKurt Hackel mlog(ML_ERROR, "%s:%.*s: got assert master from %u " 1936a2bf0477SKurt Hackel "that will mess up this node, refs=%d, extra=%d, " 1937a2bf0477SKurt Hackel "inuse=%d\n", dlm->name, namelen, name, 1938a2bf0477SKurt Hackel assert->node_idx, rr, extra_ref, mle->inuse); 1939a2bf0477SKurt Hackel dlm_print_one_mle(mle); 1940a2bf0477SKurt Hackel } 19411c084577SSunil Mushran __dlm_unlink_mle(dlm, mle); 1942a2bf0477SKurt Hackel __dlm_mle_detach_hb_events(dlm, mle); 1943a2bf0477SKurt Hackel __dlm_put_mle(mle); 19446714d8e8SKurt Hackel if (extra_ref) { 19456714d8e8SKurt Hackel /* the assert master message now balances the extra 19466714d8e8SKurt Hackel * ref given by the master / migration request message. 19476714d8e8SKurt Hackel * if this is the last put, it will be removed 19486714d8e8SKurt Hackel * from the list. */ 1949a2bf0477SKurt Hackel __dlm_put_mle(mle); 1950a2bf0477SKurt Hackel } 1951a2bf0477SKurt Hackel spin_unlock(&dlm->master_lock); 1952a2bf0477SKurt Hackel } else if (res) { 1953a2bf0477SKurt Hackel if (res->owner != assert->node_idx) { 1954a2bf0477SKurt Hackel mlog(0, "assert_master from %u, but current " 1955a2bf0477SKurt Hackel "owner is %u (%.*s), no mle\n", assert->node_idx, 1956a2bf0477SKurt Hackel res->owner, namelen, name); 19576714d8e8SKurt Hackel } 19586714d8e8SKurt Hackel } 195914741472SSrinivas Eeda spin_unlock(&dlm->spinlock); 19606714d8e8SKurt Hackel 19616714d8e8SKurt Hackel done: 19629c6510a5SKurt Hackel ret = 0; 19633b8118cfSKurt Hackel if (res) { 19643b8118cfSKurt Hackel spin_lock(&res->spinlock); 19653b8118cfSKurt Hackel res->state |= DLM_LOCK_RES_SETREF_INPROG; 19663b8118cfSKurt Hackel spin_unlock(&res->spinlock); 19673b8118cfSKurt Hackel *ret_data = (void *)res; 19683b8118cfSKurt Hackel } 19696714d8e8SKurt Hackel dlm_put(dlm); 19709c6510a5SKurt Hackel if (master_request) { 19719c6510a5SKurt Hackel mlog(0, "need to tell master to reassert\n"); 1972ba2bf218SKurt Hackel /* positive. negative would shoot down the node. */ 1973ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_REASSERT; 1974ba2bf218SKurt Hackel if (!have_lockres_ref) { 1975ba2bf218SKurt Hackel mlog(ML_ERROR, "strange, got assert from %u, MASTER " 1976ba2bf218SKurt Hackel "mle present here for %s:%.*s, but no lockres!\n", 1977ba2bf218SKurt Hackel assert->node_idx, dlm->name, namelen, name); 1978ba2bf218SKurt Hackel } 1979ba2bf218SKurt Hackel } 1980ba2bf218SKurt Hackel if (have_lockres_ref) { 1981ba2bf218SKurt Hackel /* let the master know we have a reference to the lockres */ 1982ba2bf218SKurt Hackel ret |= DLM_ASSERT_RESPONSE_MASTERY_REF; 1983ba2bf218SKurt Hackel mlog(0, "%s:%.*s: got assert from %u, need a ref\n", 1984ba2bf218SKurt Hackel dlm->name, namelen, name, assert->node_idx); 19859c6510a5SKurt Hackel } 19869c6510a5SKurt Hackel return ret; 19876714d8e8SKurt Hackel 19886714d8e8SKurt Hackel kill: 19896714d8e8SKurt Hackel /* kill the caller! */ 1990a9ee4c8aSKurt Hackel mlog(ML_ERROR, "Bad message received from another node. Dumping state " 1991a9ee4c8aSKurt Hackel "and killing the other node now! This node is OK and can continue.\n"); 1992a9ee4c8aSKurt Hackel __dlm_print_one_lock_resource(res); 19936714d8e8SKurt Hackel spin_unlock(&res->spinlock); 19946714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 19953b8118cfSKurt Hackel *ret_data = (void *)res; 19966714d8e8SKurt Hackel dlm_put(dlm); 19976714d8e8SKurt Hackel return -EINVAL; 19986714d8e8SKurt Hackel } 19996714d8e8SKurt Hackel 20003b8118cfSKurt Hackel void dlm_assert_master_post_handler(int status, void *data, void *ret_data) 20013b8118cfSKurt Hackel { 20023b8118cfSKurt Hackel struct dlm_lock_resource *res = (struct dlm_lock_resource *)ret_data; 20033b8118cfSKurt Hackel 20043b8118cfSKurt Hackel if (ret_data) { 20053b8118cfSKurt Hackel spin_lock(&res->spinlock); 20063b8118cfSKurt Hackel res->state &= ~DLM_LOCK_RES_SETREF_INPROG; 20073b8118cfSKurt Hackel spin_unlock(&res->spinlock); 20083b8118cfSKurt Hackel wake_up(&res->wq); 20093b8118cfSKurt Hackel dlm_lockres_put(res); 20103b8118cfSKurt Hackel } 20113b8118cfSKurt Hackel return; 20123b8118cfSKurt Hackel } 20133b8118cfSKurt Hackel 20146714d8e8SKurt Hackel int dlm_dispatch_assert_master(struct dlm_ctxt *dlm, 20156714d8e8SKurt Hackel struct dlm_lock_resource *res, 20166714d8e8SKurt Hackel int ignore_higher, u8 request_from, u32 flags) 20176714d8e8SKurt Hackel { 20186714d8e8SKurt Hackel struct dlm_work_item *item; 2019cd861280SRobert P. J. Day item = kzalloc(sizeof(*item), GFP_NOFS); 20206714d8e8SKurt Hackel if (!item) 20216714d8e8SKurt Hackel return -ENOMEM; 20226714d8e8SKurt Hackel 20236714d8e8SKurt Hackel 20246714d8e8SKurt Hackel /* queue up work for dlm_assert_master_worker */ 20256714d8e8SKurt Hackel dlm_grab(dlm); /* get an extra ref for the work item */ 20266714d8e8SKurt Hackel dlm_init_work_item(dlm, item, dlm_assert_master_worker, NULL); 20276714d8e8SKurt Hackel item->u.am.lockres = res; /* already have a ref */ 20286714d8e8SKurt Hackel /* can optionally ignore node numbers higher than this node */ 20296714d8e8SKurt Hackel item->u.am.ignore_higher = ignore_higher; 20306714d8e8SKurt Hackel item->u.am.request_from = request_from; 20316714d8e8SKurt Hackel item->u.am.flags = flags; 20326714d8e8SKurt Hackel 20339c6510a5SKurt Hackel if (ignore_higher) 20349c6510a5SKurt Hackel mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len, 20359c6510a5SKurt Hackel res->lockname.name); 20369c6510a5SKurt Hackel 20376714d8e8SKurt Hackel spin_lock(&dlm->work_lock); 20386714d8e8SKurt Hackel list_add_tail(&item->list, &dlm->work_list); 20396714d8e8SKurt Hackel spin_unlock(&dlm->work_lock); 20406714d8e8SKurt Hackel 20413156d267SKurt Hackel queue_work(dlm->dlm_worker, &dlm->dispatched_work); 20426714d8e8SKurt Hackel return 0; 20436714d8e8SKurt Hackel } 20446714d8e8SKurt Hackel 20456714d8e8SKurt Hackel static void dlm_assert_master_worker(struct dlm_work_item *item, void *data) 20466714d8e8SKurt Hackel { 20476714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 20486714d8e8SKurt Hackel int ret = 0; 20496714d8e8SKurt Hackel struct dlm_lock_resource *res; 20506714d8e8SKurt Hackel unsigned long nodemap[BITS_TO_LONGS(O2NM_MAX_NODES)]; 20516714d8e8SKurt Hackel int ignore_higher; 20526714d8e8SKurt Hackel int bit; 20536714d8e8SKurt Hackel u8 request_from; 20546714d8e8SKurt Hackel u32 flags; 20556714d8e8SKurt Hackel 20566714d8e8SKurt Hackel dlm = item->dlm; 20576714d8e8SKurt Hackel res = item->u.am.lockres; 20586714d8e8SKurt Hackel ignore_higher = item->u.am.ignore_higher; 20596714d8e8SKurt Hackel request_from = item->u.am.request_from; 20606714d8e8SKurt Hackel flags = item->u.am.flags; 20616714d8e8SKurt Hackel 20626714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 20636714d8e8SKurt Hackel memcpy(nodemap, dlm->domain_map, sizeof(nodemap)); 20646714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 20656714d8e8SKurt Hackel 20666714d8e8SKurt Hackel clear_bit(dlm->node_num, nodemap); 20676714d8e8SKurt Hackel if (ignore_higher) { 20686714d8e8SKurt Hackel /* if is this just to clear up mles for nodes below 20696714d8e8SKurt Hackel * this node, do not send the message to the original 20706714d8e8SKurt Hackel * caller or any node number higher than this */ 20716714d8e8SKurt Hackel clear_bit(request_from, nodemap); 20726714d8e8SKurt Hackel bit = dlm->node_num; 20736714d8e8SKurt Hackel while (1) { 20746714d8e8SKurt Hackel bit = find_next_bit(nodemap, O2NM_MAX_NODES, 20756714d8e8SKurt Hackel bit+1); 20766714d8e8SKurt Hackel if (bit >= O2NM_MAX_NODES) 20776714d8e8SKurt Hackel break; 20786714d8e8SKurt Hackel clear_bit(bit, nodemap); 20796714d8e8SKurt Hackel } 20806714d8e8SKurt Hackel } 20816714d8e8SKurt Hackel 208236407488SKurt Hackel /* 208336407488SKurt Hackel * If we're migrating this lock to someone else, we are no 208436407488SKurt Hackel * longer allowed to assert out own mastery. OTOH, we need to 208536407488SKurt Hackel * prevent migration from starting while we're still asserting 208636407488SKurt Hackel * our dominance. The reserved ast delays migration. 208736407488SKurt Hackel */ 208836407488SKurt Hackel spin_lock(&res->spinlock); 208936407488SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) { 209036407488SKurt Hackel mlog(0, "Someone asked us to assert mastery, but we're " 209136407488SKurt Hackel "in the middle of migration. Skipping assert, " 209236407488SKurt Hackel "the new master will handle that.\n"); 209336407488SKurt Hackel spin_unlock(&res->spinlock); 209436407488SKurt Hackel goto put; 209536407488SKurt Hackel } else 209636407488SKurt Hackel __dlm_lockres_reserve_ast(res); 209736407488SKurt Hackel spin_unlock(&res->spinlock); 209836407488SKurt Hackel 20996714d8e8SKurt Hackel /* this call now finishes out the nodemap 21006714d8e8SKurt Hackel * even if one or more nodes die */ 21016714d8e8SKurt Hackel mlog(0, "worker about to master %.*s here, this=%u\n", 21026714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num); 2103ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, nodemap, flags); 21046714d8e8SKurt Hackel if (ret < 0) { 21056714d8e8SKurt Hackel /* no need to restart, we are done */ 21063b3b84a8SKurt Hackel if (!dlm_is_host_down(ret)) 21076714d8e8SKurt Hackel mlog_errno(ret); 21086714d8e8SKurt Hackel } 21096714d8e8SKurt Hackel 211036407488SKurt Hackel /* Ok, we've asserted ourselves. Let's let migration start. */ 211136407488SKurt Hackel dlm_lockres_release_ast(dlm, res); 211236407488SKurt Hackel 211336407488SKurt Hackel put: 21146714d8e8SKurt Hackel dlm_lockres_put(res); 21156714d8e8SKurt Hackel 21166714d8e8SKurt Hackel mlog(0, "finished with dlm_assert_master_worker\n"); 21176714d8e8SKurt Hackel } 21186714d8e8SKurt Hackel 2119c03872f5SKurt Hackel /* SPECIAL CASE for the $RECOVERY lock used by the recovery thread. 2120c03872f5SKurt Hackel * We cannot wait for node recovery to complete to begin mastering this 2121c03872f5SKurt Hackel * lockres because this lockres is used to kick off recovery! ;-) 2122c03872f5SKurt Hackel * So, do a pre-check on all living nodes to see if any of those nodes 2123c03872f5SKurt Hackel * think that $RECOVERY is currently mastered by a dead node. If so, 2124c03872f5SKurt Hackel * we wait a short time to allow that node to get notified by its own 2125c03872f5SKurt Hackel * heartbeat stack, then check again. All $RECOVERY lock resources 2126c03872f5SKurt Hackel * mastered by dead nodes are purged when the hearbeat callback is 2127c03872f5SKurt Hackel * fired, so we can know for sure that it is safe to continue once 2128c03872f5SKurt Hackel * the node returns a live node or no node. */ 2129c03872f5SKurt Hackel static int dlm_pre_master_reco_lockres(struct dlm_ctxt *dlm, 2130c03872f5SKurt Hackel struct dlm_lock_resource *res) 2131c03872f5SKurt Hackel { 2132c03872f5SKurt Hackel struct dlm_node_iter iter; 2133c03872f5SKurt Hackel int nodenum; 2134c03872f5SKurt Hackel int ret = 0; 2135c03872f5SKurt Hackel u8 master = DLM_LOCK_RES_OWNER_UNKNOWN; 2136c03872f5SKurt Hackel 2137c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 2138c03872f5SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter); 2139c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 2140c03872f5SKurt Hackel 2141c03872f5SKurt Hackel while ((nodenum = dlm_node_iter_next(&iter)) >= 0) { 2142c03872f5SKurt Hackel /* do not send to self */ 2143c03872f5SKurt Hackel if (nodenum == dlm->node_num) 2144c03872f5SKurt Hackel continue; 2145c03872f5SKurt Hackel ret = dlm_do_master_requery(dlm, res, nodenum, &master); 2146c03872f5SKurt Hackel if (ret < 0) { 2147c03872f5SKurt Hackel mlog_errno(ret); 2148c03872f5SKurt Hackel if (!dlm_is_host_down(ret)) 2149c03872f5SKurt Hackel BUG(); 2150c03872f5SKurt Hackel /* host is down, so answer for that node would be 2151c03872f5SKurt Hackel * DLM_LOCK_RES_OWNER_UNKNOWN. continue. */ 2152f42a100bSKurt Hackel ret = 0; 2153c03872f5SKurt Hackel } 2154c03872f5SKurt Hackel 2155c03872f5SKurt Hackel if (master != DLM_LOCK_RES_OWNER_UNKNOWN) { 2156c03872f5SKurt Hackel /* check to see if this master is in the recovery map */ 2157c03872f5SKurt Hackel spin_lock(&dlm->spinlock); 2158c03872f5SKurt Hackel if (test_bit(master, dlm->recovery_map)) { 2159c03872f5SKurt Hackel mlog(ML_NOTICE, "%s: node %u has not seen " 2160c03872f5SKurt Hackel "node %u go down yet, and thinks the " 2161c03872f5SKurt Hackel "dead node is mastering the recovery " 2162c03872f5SKurt Hackel "lock. must wait.\n", dlm->name, 2163c03872f5SKurt Hackel nodenum, master); 2164c03872f5SKurt Hackel ret = -EAGAIN; 2165c03872f5SKurt Hackel } 2166c03872f5SKurt Hackel spin_unlock(&dlm->spinlock); 2167c03872f5SKurt Hackel mlog(0, "%s: reco lock master is %u\n", dlm->name, 2168c03872f5SKurt Hackel master); 2169c03872f5SKurt Hackel break; 2170c03872f5SKurt Hackel } 2171c03872f5SKurt Hackel } 2172c03872f5SKurt Hackel return ret; 2173c03872f5SKurt Hackel } 2174c03872f5SKurt Hackel 2175ba2bf218SKurt Hackel /* 2176ba2bf218SKurt Hackel * DLM_DEREF_LOCKRES_MSG 2177ba2bf218SKurt Hackel */ 2178ba2bf218SKurt Hackel 2179ba2bf218SKurt Hackel int dlm_drop_lockres_ref(struct dlm_ctxt *dlm, struct dlm_lock_resource *res) 2180ba2bf218SKurt Hackel { 2181ba2bf218SKurt Hackel struct dlm_deref_lockres deref; 2182ba2bf218SKurt Hackel int ret = 0, r; 2183ba2bf218SKurt Hackel const char *lockname; 2184ba2bf218SKurt Hackel unsigned int namelen; 2185ba2bf218SKurt Hackel 2186ba2bf218SKurt Hackel lockname = res->lockname.name; 2187ba2bf218SKurt Hackel namelen = res->lockname.len; 2188ba2bf218SKurt Hackel BUG_ON(namelen > O2NM_MAX_NAME_LEN); 2189ba2bf218SKurt Hackel 2190ba2bf218SKurt Hackel mlog(0, "%s:%.*s: sending deref to %d\n", 2191ba2bf218SKurt Hackel dlm->name, namelen, lockname, res->owner); 2192ba2bf218SKurt Hackel memset(&deref, 0, sizeof(deref)); 2193ba2bf218SKurt Hackel deref.node_idx = dlm->node_num; 2194ba2bf218SKurt Hackel deref.namelen = namelen; 2195ba2bf218SKurt Hackel memcpy(deref.name, lockname, namelen); 2196ba2bf218SKurt Hackel 2197ba2bf218SKurt Hackel ret = o2net_send_message(DLM_DEREF_LOCKRES_MSG, dlm->key, 2198ba2bf218SKurt Hackel &deref, sizeof(deref), res->owner, &r); 2199ba2bf218SKurt Hackel if (ret < 0) 2200a5196ec5SWengang Wang mlog(ML_ERROR, "Error %d when sending message %u (key 0x%x) to " 2201a5196ec5SWengang Wang "node %u\n", ret, DLM_DEREF_LOCKRES_MSG, dlm->key, 2202a5196ec5SWengang Wang res->owner); 2203ba2bf218SKurt Hackel else if (r < 0) { 2204ba2bf218SKurt Hackel /* BAD. other node says I did not have a ref. */ 2205ba2bf218SKurt Hackel mlog(ML_ERROR,"while dropping ref on %s:%.*s " 2206ba2bf218SKurt Hackel "(master=%u) got %d.\n", dlm->name, namelen, 2207ba2bf218SKurt Hackel lockname, res->owner, r); 2208ba2bf218SKurt Hackel dlm_print_one_lock_resource(res); 2209ba2bf218SKurt Hackel BUG(); 2210ba2bf218SKurt Hackel } 2211ba2bf218SKurt Hackel return ret; 2212ba2bf218SKurt Hackel } 2213ba2bf218SKurt Hackel 2214d74c9803SKurt Hackel int dlm_deref_lockres_handler(struct o2net_msg *msg, u32 len, void *data, 2215d74c9803SKurt Hackel void **ret_data) 2216ba2bf218SKurt Hackel { 2217ba2bf218SKurt Hackel struct dlm_ctxt *dlm = data; 2218ba2bf218SKurt Hackel struct dlm_deref_lockres *deref = (struct dlm_deref_lockres *)msg->buf; 2219ba2bf218SKurt Hackel struct dlm_lock_resource *res = NULL; 2220ba2bf218SKurt Hackel char *name; 2221ba2bf218SKurt Hackel unsigned int namelen; 2222ba2bf218SKurt Hackel int ret = -EINVAL; 2223ba2bf218SKurt Hackel u8 node; 2224ba2bf218SKurt Hackel unsigned int hash; 2225f3f85464SSunil Mushran struct dlm_work_item *item; 2226f3f85464SSunil Mushran int cleared = 0; 2227f3f85464SSunil Mushran int dispatch = 0; 2228ba2bf218SKurt Hackel 2229ba2bf218SKurt Hackel if (!dlm_grab(dlm)) 2230ba2bf218SKurt Hackel return 0; 2231ba2bf218SKurt Hackel 2232ba2bf218SKurt Hackel name = deref->name; 2233ba2bf218SKurt Hackel namelen = deref->namelen; 2234ba2bf218SKurt Hackel node = deref->node_idx; 2235ba2bf218SKurt Hackel 2236ba2bf218SKurt Hackel if (namelen > DLM_LOCKID_NAME_MAX) { 2237ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid name length!"); 2238ba2bf218SKurt Hackel goto done; 2239ba2bf218SKurt Hackel } 2240ba2bf218SKurt Hackel if (deref->node_idx >= O2NM_MAX_NODES) { 2241ba2bf218SKurt Hackel mlog(ML_ERROR, "Invalid node number: %u\n", node); 2242ba2bf218SKurt Hackel goto done; 2243ba2bf218SKurt Hackel } 2244ba2bf218SKurt Hackel 2245ba2bf218SKurt Hackel hash = dlm_lockid_hash(name, namelen); 2246ba2bf218SKurt Hackel 2247ba2bf218SKurt Hackel spin_lock(&dlm->spinlock); 2248ba2bf218SKurt Hackel res = __dlm_lookup_lockres_full(dlm, name, namelen, hash); 2249ba2bf218SKurt Hackel if (!res) { 2250ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2251ba2bf218SKurt Hackel mlog(ML_ERROR, "%s:%.*s: bad lockres name\n", 2252ba2bf218SKurt Hackel dlm->name, namelen, name); 2253ba2bf218SKurt Hackel goto done; 2254ba2bf218SKurt Hackel } 2255ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2256ba2bf218SKurt Hackel 2257ba2bf218SKurt Hackel spin_lock(&res->spinlock); 2258f3f85464SSunil Mushran if (res->state & DLM_LOCK_RES_SETREF_INPROG) 2259f3f85464SSunil Mushran dispatch = 1; 2260f3f85464SSunil Mushran else { 2261ba2bf218SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF); 2262ba2bf218SKurt Hackel if (test_bit(node, res->refmap)) { 2263ba2bf218SKurt Hackel dlm_lockres_clear_refmap_bit(node, res); 2264f3f85464SSunil Mushran cleared = 1; 2265f3f85464SSunil Mushran } 2266ba2bf218SKurt Hackel } 2267ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 2268ba2bf218SKurt Hackel 2269f3f85464SSunil Mushran if (!dispatch) { 2270f3f85464SSunil Mushran if (cleared) 2271ba2bf218SKurt Hackel dlm_lockres_calc_usage(dlm, res); 2272f3f85464SSunil Mushran else { 2273f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref " 2274f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name, 2275f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node); 22762af37ce8STao Ma dlm_print_one_lock_resource(res); 2277f3f85464SSunil Mushran } 2278f3f85464SSunil Mushran ret = 0; 2279f3f85464SSunil Mushran goto done; 2280f3f85464SSunil Mushran } 2281f3f85464SSunil Mushran 2282f3f85464SSunil Mushran item = kzalloc(sizeof(*item), GFP_NOFS); 2283f3f85464SSunil Mushran if (!item) { 2284f3f85464SSunil Mushran ret = -ENOMEM; 2285f3f85464SSunil Mushran mlog_errno(ret); 2286f3f85464SSunil Mushran goto done; 2287f3f85464SSunil Mushran } 2288f3f85464SSunil Mushran 2289f3f85464SSunil Mushran dlm_init_work_item(dlm, item, dlm_deref_lockres_worker, NULL); 2290f3f85464SSunil Mushran item->u.dl.deref_res = res; 2291f3f85464SSunil Mushran item->u.dl.deref_node = node; 2292f3f85464SSunil Mushran 2293f3f85464SSunil Mushran spin_lock(&dlm->work_lock); 2294f3f85464SSunil Mushran list_add_tail(&item->list, &dlm->work_list); 2295f3f85464SSunil Mushran spin_unlock(&dlm->work_lock); 2296f3f85464SSunil Mushran 2297f3f85464SSunil Mushran queue_work(dlm->dlm_worker, &dlm->dispatched_work); 2298f3f85464SSunil Mushran return 0; 2299f3f85464SSunil Mushran 2300ba2bf218SKurt Hackel done: 2301ba2bf218SKurt Hackel if (res) 2302ba2bf218SKurt Hackel dlm_lockres_put(res); 2303ba2bf218SKurt Hackel dlm_put(dlm); 2304f3f85464SSunil Mushran 2305ba2bf218SKurt Hackel return ret; 2306ba2bf218SKurt Hackel } 2307ba2bf218SKurt Hackel 2308f3f85464SSunil Mushran static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data) 2309f3f85464SSunil Mushran { 2310f3f85464SSunil Mushran struct dlm_ctxt *dlm; 2311f3f85464SSunil Mushran struct dlm_lock_resource *res; 2312f3f85464SSunil Mushran u8 node; 2313f3f85464SSunil Mushran u8 cleared = 0; 2314f3f85464SSunil Mushran 2315f3f85464SSunil Mushran dlm = item->dlm; 2316f3f85464SSunil Mushran res = item->u.dl.deref_res; 2317f3f85464SSunil Mushran node = item->u.dl.deref_node; 2318f3f85464SSunil Mushran 2319f3f85464SSunil Mushran spin_lock(&res->spinlock); 2320f3f85464SSunil Mushran BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF); 2321f3f85464SSunil Mushran if (test_bit(node, res->refmap)) { 2322f3f85464SSunil Mushran __dlm_wait_on_lockres_flags(res, DLM_LOCK_RES_SETREF_INPROG); 2323f3f85464SSunil Mushran dlm_lockres_clear_refmap_bit(node, res); 2324f3f85464SSunil Mushran cleared = 1; 2325f3f85464SSunil Mushran } 2326f3f85464SSunil Mushran spin_unlock(&res->spinlock); 2327f3f85464SSunil Mushran 2328f3f85464SSunil Mushran if (cleared) { 2329f3f85464SSunil Mushran mlog(0, "%s:%.*s node %u ref dropped in dispatch\n", 2330f3f85464SSunil Mushran dlm->name, res->lockname.len, res->lockname.name, node); 2331f3f85464SSunil Mushran dlm_lockres_calc_usage(dlm, res); 2332f3f85464SSunil Mushran } else { 2333f3f85464SSunil Mushran mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref " 2334f3f85464SSunil Mushran "but it is already dropped!\n", dlm->name, 2335f3f85464SSunil Mushran res->lockname.len, res->lockname.name, node); 23362af37ce8STao Ma dlm_print_one_lock_resource(res); 2337f3f85464SSunil Mushran } 2338f3f85464SSunil Mushran 2339f3f85464SSunil Mushran dlm_lockres_put(res); 2340f3f85464SSunil Mushran } 2341f3f85464SSunil Mushran 23422f5bf1f2SSunil Mushran /* Checks whether the lockres can be migrated. Returns 0 if yes, < 0 23432f5bf1f2SSunil Mushran * if not. If 0, numlocks is set to the number of locks in the lockres. 23442f5bf1f2SSunil Mushran */ 23452f5bf1f2SSunil Mushran static int dlm_is_lockres_migrateable(struct dlm_ctxt *dlm, 23462f5bf1f2SSunil Mushran struct dlm_lock_resource *res, 2347388c4bcbSSunil Mushran int *numlocks, 2348388c4bcbSSunil Mushran int *hasrefs) 23492f5bf1f2SSunil Mushran { 23502f5bf1f2SSunil Mushran int ret; 23512f5bf1f2SSunil Mushran int i; 23522f5bf1f2SSunil Mushran int count = 0; 2353800deef3SChristoph Hellwig struct list_head *queue; 23542f5bf1f2SSunil Mushran struct dlm_lock *lock; 23552f5bf1f2SSunil Mushran 23562f5bf1f2SSunil Mushran assert_spin_locked(&res->spinlock); 23572f5bf1f2SSunil Mushran 2358388c4bcbSSunil Mushran *numlocks = 0; 2359388c4bcbSSunil Mushran *hasrefs = 0; 2360388c4bcbSSunil Mushran 23612f5bf1f2SSunil Mushran ret = -EINVAL; 23622f5bf1f2SSunil Mushran if (res->owner == DLM_LOCK_RES_OWNER_UNKNOWN) { 23632f5bf1f2SSunil Mushran mlog(0, "cannot migrate lockres with unknown owner!\n"); 23642f5bf1f2SSunil Mushran goto leave; 23652f5bf1f2SSunil Mushran } 23662f5bf1f2SSunil Mushran 23672f5bf1f2SSunil Mushran if (res->owner != dlm->node_num) { 23682f5bf1f2SSunil Mushran mlog(0, "cannot migrate lockres this node doesn't own!\n"); 23692f5bf1f2SSunil Mushran goto leave; 23702f5bf1f2SSunil Mushran } 23712f5bf1f2SSunil Mushran 23722f5bf1f2SSunil Mushran ret = 0; 23732f5bf1f2SSunil Mushran queue = &res->granted; 23742f5bf1f2SSunil Mushran for (i = 0; i < 3; i++) { 2375800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) { 23762f5bf1f2SSunil Mushran ++count; 23772f5bf1f2SSunil Mushran if (lock->ml.node == dlm->node_num) { 23782f5bf1f2SSunil Mushran mlog(0, "found a lock owned by this node still " 23792f5bf1f2SSunil Mushran "on the %s queue! will not migrate this " 23802f5bf1f2SSunil Mushran "lockres\n", (i == 0 ? "granted" : 23812f5bf1f2SSunil Mushran (i == 1 ? "converting" : 23822f5bf1f2SSunil Mushran "blocked"))); 23832f5bf1f2SSunil Mushran ret = -ENOTEMPTY; 23842f5bf1f2SSunil Mushran goto leave; 23852f5bf1f2SSunil Mushran } 23862f5bf1f2SSunil Mushran } 23872f5bf1f2SSunil Mushran queue++; 23882f5bf1f2SSunil Mushran } 23892f5bf1f2SSunil Mushran 23902f5bf1f2SSunil Mushran *numlocks = count; 2391388c4bcbSSunil Mushran 2392388c4bcbSSunil Mushran count = find_next_bit(res->refmap, O2NM_MAX_NODES, 0); 2393388c4bcbSSunil Mushran if (count < O2NM_MAX_NODES) 2394388c4bcbSSunil Mushran *hasrefs = 1; 2395388c4bcbSSunil Mushran 2396388c4bcbSSunil Mushran mlog(0, "%s: res %.*s, Migrateable, locks %d, refs %d\n", dlm->name, 2397388c4bcbSSunil Mushran res->lockname.len, res->lockname.name, *numlocks, *hasrefs); 23982f5bf1f2SSunil Mushran 23992f5bf1f2SSunil Mushran leave: 24002f5bf1f2SSunil Mushran return ret; 24012f5bf1f2SSunil Mushran } 24026714d8e8SKurt Hackel 24036714d8e8SKurt Hackel /* 24046714d8e8SKurt Hackel * DLM_MIGRATE_LOCKRES 24056714d8e8SKurt Hackel */ 24066714d8e8SKurt Hackel 24076714d8e8SKurt Hackel 2408faf0ec9fSAdrian Bunk static int dlm_migrate_lockres(struct dlm_ctxt *dlm, 2409faf0ec9fSAdrian Bunk struct dlm_lock_resource *res, 24106714d8e8SKurt Hackel u8 target) 24116714d8e8SKurt Hackel { 24126714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL; 24136714d8e8SKurt Hackel struct dlm_master_list_entry *oldmle = NULL; 24146714d8e8SKurt Hackel struct dlm_migratable_lockres *mres = NULL; 24152f5bf1f2SSunil Mushran int ret = 0; 24166714d8e8SKurt Hackel const char *name; 24176714d8e8SKurt Hackel unsigned int namelen; 24186714d8e8SKurt Hackel int mle_added = 0; 2419388c4bcbSSunil Mushran int numlocks, hasrefs; 24202f5bf1f2SSunil Mushran int wake = 0; 24216714d8e8SKurt Hackel 24226714d8e8SKurt Hackel if (!dlm_grab(dlm)) 24236714d8e8SKurt Hackel return -EINVAL; 24246714d8e8SKurt Hackel 24256714d8e8SKurt Hackel name = res->lockname.name; 24266714d8e8SKurt Hackel namelen = res->lockname.len; 24276714d8e8SKurt Hackel 2428388c4bcbSSunil Mushran mlog(0, "%s: Migrating %.*s to %u\n", dlm->name, namelen, name, target); 24296714d8e8SKurt Hackel 24306714d8e8SKurt Hackel /* 24316714d8e8SKurt Hackel * ensure this lockres is a proper candidate for migration 24326714d8e8SKurt Hackel */ 24336714d8e8SKurt Hackel spin_lock(&res->spinlock); 2434388c4bcbSSunil Mushran ret = dlm_is_lockres_migrateable(dlm, res, &numlocks, &hasrefs); 24352f5bf1f2SSunil Mushran if (ret < 0) { 24366714d8e8SKurt Hackel spin_unlock(&res->spinlock); 24376714d8e8SKurt Hackel goto leave; 24386714d8e8SKurt Hackel } 24396714d8e8SKurt Hackel spin_unlock(&res->spinlock); 24406714d8e8SKurt Hackel 24416714d8e8SKurt Hackel /* no work to do */ 2442388c4bcbSSunil Mushran if (numlocks == 0 && !hasrefs) 24436714d8e8SKurt Hackel goto leave; 24446714d8e8SKurt Hackel 24456714d8e8SKurt Hackel /* 24466714d8e8SKurt Hackel * preallocate up front 24476714d8e8SKurt Hackel * if this fails, abort 24486714d8e8SKurt Hackel */ 24496714d8e8SKurt Hackel 24506714d8e8SKurt Hackel ret = -ENOMEM; 2451ad8100e0SKurt Hackel mres = (struct dlm_migratable_lockres *) __get_free_page(GFP_NOFS); 24526714d8e8SKurt Hackel if (!mres) { 24536714d8e8SKurt Hackel mlog_errno(ret); 24546714d8e8SKurt Hackel goto leave; 24556714d8e8SKurt Hackel } 24566714d8e8SKurt Hackel 24573914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 24586714d8e8SKurt Hackel if (!mle) { 24596714d8e8SKurt Hackel mlog_errno(ret); 24606714d8e8SKurt Hackel goto leave; 24616714d8e8SKurt Hackel } 24626714d8e8SKurt Hackel ret = 0; 24636714d8e8SKurt Hackel 24646714d8e8SKurt Hackel /* 24656714d8e8SKurt Hackel * find a node to migrate the lockres to 24666714d8e8SKurt Hackel */ 24676714d8e8SKurt Hackel 24686714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 24696714d8e8SKurt Hackel /* pick a new node */ 24706714d8e8SKurt Hackel if (!test_bit(target, dlm->domain_map) || 24716714d8e8SKurt Hackel target >= O2NM_MAX_NODES) { 24726714d8e8SKurt Hackel target = dlm_pick_migration_target(dlm, res); 24736714d8e8SKurt Hackel } 2474388c4bcbSSunil Mushran mlog(0, "%s: res %.*s, Node %u chosen for migration\n", dlm->name, 2475388c4bcbSSunil Mushran namelen, name, target); 24766714d8e8SKurt Hackel 24776714d8e8SKurt Hackel if (target >= O2NM_MAX_NODES || 24786714d8e8SKurt Hackel !test_bit(target, dlm->domain_map)) { 24796714d8e8SKurt Hackel /* target chosen is not alive */ 24806714d8e8SKurt Hackel ret = -EINVAL; 24816714d8e8SKurt Hackel } 24826714d8e8SKurt Hackel 24836714d8e8SKurt Hackel if (ret) { 24846714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 24856714d8e8SKurt Hackel goto fail; 24866714d8e8SKurt Hackel } 24876714d8e8SKurt Hackel 24886714d8e8SKurt Hackel mlog(0, "continuing with target = %u\n", target); 24896714d8e8SKurt Hackel 24906714d8e8SKurt Hackel /* 24916714d8e8SKurt Hackel * clear any existing master requests and 24926714d8e8SKurt Hackel * add the migration mle to the list 24936714d8e8SKurt Hackel */ 24946714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 24956714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, name, 24966714d8e8SKurt Hackel namelen, target, dlm->node_num); 24976714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 24986714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 24996714d8e8SKurt Hackel 25006714d8e8SKurt Hackel if (ret == -EEXIST) { 25016714d8e8SKurt Hackel mlog(0, "another process is already migrating it\n"); 25026714d8e8SKurt Hackel goto fail; 25036714d8e8SKurt Hackel } 25046714d8e8SKurt Hackel mle_added = 1; 25056714d8e8SKurt Hackel 25066714d8e8SKurt Hackel /* 25076714d8e8SKurt Hackel * set the MIGRATING flag and flush asts 25086714d8e8SKurt Hackel * if we fail after this we need to re-dirty the lockres 25096714d8e8SKurt Hackel */ 25106714d8e8SKurt Hackel if (dlm_mark_lockres_migrating(dlm, res, target) < 0) { 25116714d8e8SKurt Hackel mlog(ML_ERROR, "tried to migrate %.*s to %u, but " 25126714d8e8SKurt Hackel "the target went down.\n", res->lockname.len, 25136714d8e8SKurt Hackel res->lockname.name, target); 25146714d8e8SKurt Hackel spin_lock(&res->spinlock); 25156714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2516a6fa3640SKurt Hackel wake = 1; 25176714d8e8SKurt Hackel spin_unlock(&res->spinlock); 25186714d8e8SKurt Hackel ret = -EINVAL; 25196714d8e8SKurt Hackel } 25206714d8e8SKurt Hackel 25216714d8e8SKurt Hackel fail: 25226714d8e8SKurt Hackel if (oldmle) { 25236714d8e8SKurt Hackel /* master is known, detach if not already detached */ 25246714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle); 25256714d8e8SKurt Hackel dlm_put_mle(oldmle); 25266714d8e8SKurt Hackel } 25276714d8e8SKurt Hackel 25286714d8e8SKurt Hackel if (ret < 0) { 25296714d8e8SKurt Hackel if (mle_added) { 25306714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 25316714d8e8SKurt Hackel dlm_put_mle(mle); 25326714d8e8SKurt Hackel } else if (mle) { 25336714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 25346714d8e8SKurt Hackel } 25356714d8e8SKurt Hackel goto leave; 25366714d8e8SKurt Hackel } 25376714d8e8SKurt Hackel 25386714d8e8SKurt Hackel /* 25396714d8e8SKurt Hackel * at this point, we have a migration target, an mle 25406714d8e8SKurt Hackel * in the master list, and the MIGRATING flag set on 25416714d8e8SKurt Hackel * the lockres 25426714d8e8SKurt Hackel */ 25436714d8e8SKurt Hackel 25441cd04dbeSKurt Hackel /* now that remote nodes are spinning on the MIGRATING flag, 25451cd04dbeSKurt Hackel * ensure that all assert_master work is flushed. */ 25461cd04dbeSKurt Hackel flush_workqueue(dlm->dlm_worker); 25476714d8e8SKurt Hackel 25486714d8e8SKurt Hackel /* get an extra reference on the mle. 25496714d8e8SKurt Hackel * otherwise the assert_master from the new 25506714d8e8SKurt Hackel * master will destroy this. 25516714d8e8SKurt Hackel * also, make sure that all callers of dlm_get_mle 25526714d8e8SKurt Hackel * take both dlm->spinlock and dlm->master_lock */ 25536714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 25546714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 2555a2bf0477SKurt Hackel dlm_get_mle_inuse(mle); 25566714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 25576714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 25586714d8e8SKurt Hackel 25596714d8e8SKurt Hackel /* notify new node and send all lock state */ 25606714d8e8SKurt Hackel /* call send_one_lockres with migration flag. 25616714d8e8SKurt Hackel * this serves as notice to the target node that a 25626714d8e8SKurt Hackel * migration is starting. */ 25636714d8e8SKurt Hackel ret = dlm_send_one_lockres(dlm, res, mres, target, 25646714d8e8SKurt Hackel DLM_MRES_MIGRATION); 25656714d8e8SKurt Hackel 25666714d8e8SKurt Hackel if (ret < 0) { 25676714d8e8SKurt Hackel mlog(0, "migration to node %u failed with %d\n", 25686714d8e8SKurt Hackel target, ret); 25696714d8e8SKurt Hackel /* migration failed, detach and clean up mle */ 25706714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 25716714d8e8SKurt Hackel dlm_put_mle(mle); 2572a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 2573a2bf0477SKurt Hackel spin_lock(&res->spinlock); 2574a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2575a6fa3640SKurt Hackel wake = 1; 2576a2bf0477SKurt Hackel spin_unlock(&res->spinlock); 2577df016c66SSunil Mushran if (dlm_is_host_down(ret)) 2578df016c66SSunil Mushran dlm_wait_for_node_death(dlm, target, 2579df016c66SSunil Mushran DLM_NODE_DEATH_WAIT_MAX); 25806714d8e8SKurt Hackel goto leave; 25816714d8e8SKurt Hackel } 25826714d8e8SKurt Hackel 25836714d8e8SKurt Hackel /* at this point, the target sends a message to all nodes, 25846714d8e8SKurt Hackel * (using dlm_do_migrate_request). this node is skipped since 25856714d8e8SKurt Hackel * we had to put an mle in the list to begin the process. this 25866714d8e8SKurt Hackel * node now waits for target to do an assert master. this node 25876714d8e8SKurt Hackel * will be the last one notified, ensuring that the migration 25886714d8e8SKurt Hackel * is complete everywhere. if the target dies while this is 25896714d8e8SKurt Hackel * going on, some nodes could potentially see the target as the 25906714d8e8SKurt Hackel * master, so it is important that my recovery finds the migration 2591af901ca1SAndré Goddard Rosa * mle and sets the master to UNKNOWN. */ 25926714d8e8SKurt Hackel 25936714d8e8SKurt Hackel 25946714d8e8SKurt Hackel /* wait for new node to assert master */ 25956714d8e8SKurt Hackel while (1) { 25966714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(mle->wq, 25976714d8e8SKurt Hackel (atomic_read(&mle->woken) == 1), 25986714d8e8SKurt Hackel msecs_to_jiffies(5000)); 25996714d8e8SKurt Hackel 26006714d8e8SKurt Hackel if (ret >= 0) { 26016714d8e8SKurt Hackel if (atomic_read(&mle->woken) == 1 || 26026714d8e8SKurt Hackel res->owner == target) 26036714d8e8SKurt Hackel break; 26046714d8e8SKurt Hackel 26051cd04dbeSKurt Hackel mlog(0, "%s:%.*s: timed out during migration\n", 26061cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 2607e2faea4cSKurt Hackel /* avoid hang during shutdown when migrating lockres 2608e2faea4cSKurt Hackel * to a node which also goes down */ 2609e2faea4cSKurt Hackel if (dlm_is_node_dead(dlm, target)) { 2610aa852354SKurt Hackel mlog(0, "%s:%.*s: expected migration " 2611aa852354SKurt Hackel "target %u is no longer up, restarting\n", 2612e2faea4cSKurt Hackel dlm->name, res->lockname.len, 2613e2faea4cSKurt Hackel res->lockname.name, target); 26141cd04dbeSKurt Hackel ret = -EINVAL; 26156714d8e8SKurt Hackel /* migration failed, detach and clean up mle */ 26166714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 26176714d8e8SKurt Hackel dlm_put_mle(mle); 2618a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 2619a2bf0477SKurt Hackel spin_lock(&res->spinlock); 2620a2bf0477SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 2621a6fa3640SKurt Hackel wake = 1; 2622a2bf0477SKurt Hackel spin_unlock(&res->spinlock); 26236714d8e8SKurt Hackel goto leave; 26246714d8e8SKurt Hackel } 26251cd04dbeSKurt Hackel } else 26261cd04dbeSKurt Hackel mlog(0, "%s:%.*s: caught signal during migration\n", 26271cd04dbeSKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 26286714d8e8SKurt Hackel } 26296714d8e8SKurt Hackel 26306714d8e8SKurt Hackel /* all done, set the owner, clear the flag */ 26316714d8e8SKurt Hackel spin_lock(&res->spinlock); 26326714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, target); 26336714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 26346714d8e8SKurt Hackel dlm_remove_nonlocal_locks(dlm, res); 26356714d8e8SKurt Hackel spin_unlock(&res->spinlock); 26366714d8e8SKurt Hackel wake_up(&res->wq); 26376714d8e8SKurt Hackel 26386714d8e8SKurt Hackel /* master is known, detach if not already detached */ 26396714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, mle); 2640a2bf0477SKurt Hackel dlm_put_mle_inuse(mle); 26416714d8e8SKurt Hackel ret = 0; 26426714d8e8SKurt Hackel 26436714d8e8SKurt Hackel dlm_lockres_calc_usage(dlm, res); 26446714d8e8SKurt Hackel 26456714d8e8SKurt Hackel leave: 26466714d8e8SKurt Hackel /* re-dirty the lockres if we failed */ 26476714d8e8SKurt Hackel if (ret < 0) 26486714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 26496714d8e8SKurt Hackel 2650a6fa3640SKurt Hackel /* wake up waiters if the MIGRATING flag got set 2651a6fa3640SKurt Hackel * but migration failed */ 2652a6fa3640SKurt Hackel if (wake) 2653a6fa3640SKurt Hackel wake_up(&res->wq); 2654a6fa3640SKurt Hackel 26556714d8e8SKurt Hackel /* TODO: cleanup */ 26566714d8e8SKurt Hackel if (mres) 26576714d8e8SKurt Hackel free_page((unsigned long)mres); 26586714d8e8SKurt Hackel 26596714d8e8SKurt Hackel dlm_put(dlm); 26606714d8e8SKurt Hackel 26616714d8e8SKurt Hackel mlog(0, "returning %d\n", ret); 26626714d8e8SKurt Hackel return ret; 26636714d8e8SKurt Hackel } 26646714d8e8SKurt Hackel 2665ba2bf218SKurt Hackel #define DLM_MIGRATION_RETRY_MS 100 2666ba2bf218SKurt Hackel 2667ba2bf218SKurt Hackel /* Should be called only after beginning the domain leave process. 2668ba2bf218SKurt Hackel * There should not be any remaining locks on nonlocal lock resources, 2669ba2bf218SKurt Hackel * and there should be no local locks left on locally mastered resources. 2670ba2bf218SKurt Hackel * 2671ba2bf218SKurt Hackel * Called with the dlm spinlock held, may drop it to do migration, but 2672ba2bf218SKurt Hackel * will re-acquire before exit. 2673ba2bf218SKurt Hackel * 2674ba2bf218SKurt Hackel * Returns: 1 if dlm->spinlock was dropped/retaken, 0 if never dropped */ 2675ba2bf218SKurt Hackel int dlm_empty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res) 2676ba2bf218SKurt Hackel { 2677ba2bf218SKurt Hackel int ret; 2678ba2bf218SKurt Hackel int lock_dropped = 0; 2679388c4bcbSSunil Mushran int numlocks, hasrefs; 2680ba2bf218SKurt Hackel 2681b36c3f84SSunil Mushran spin_lock(&res->spinlock); 2682ba2bf218SKurt Hackel if (res->owner != dlm->node_num) { 2683ba2bf218SKurt Hackel if (!__dlm_lockres_unused(res)) { 2684ba2bf218SKurt Hackel mlog(ML_ERROR, "%s:%.*s: this node is not master, " 2685ba2bf218SKurt Hackel "trying to free this but locks remain\n", 2686ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name); 2687ba2bf218SKurt Hackel } 2688b36c3f84SSunil Mushran spin_unlock(&res->spinlock); 2689ba2bf218SKurt Hackel goto leave; 2690ba2bf218SKurt Hackel } 26912f5bf1f2SSunil Mushran 26922f5bf1f2SSunil Mushran /* No need to migrate a lockres having no locks */ 2693388c4bcbSSunil Mushran ret = dlm_is_lockres_migrateable(dlm, res, &numlocks, &hasrefs); 2694388c4bcbSSunil Mushran if (ret >= 0 && numlocks == 0 && !hasrefs) { 26952f5bf1f2SSunil Mushran spin_unlock(&res->spinlock); 26962f5bf1f2SSunil Mushran goto leave; 26972f5bf1f2SSunil Mushran } 2698b36c3f84SSunil Mushran spin_unlock(&res->spinlock); 2699ba2bf218SKurt Hackel 2700ba2bf218SKurt Hackel /* Wheee! Migrate lockres here! Will sleep so drop spinlock. */ 2701ba2bf218SKurt Hackel spin_unlock(&dlm->spinlock); 2702ba2bf218SKurt Hackel lock_dropped = 1; 2703ba2bf218SKurt Hackel while (1) { 2704ba2bf218SKurt Hackel ret = dlm_migrate_lockres(dlm, res, O2NM_MAX_NODES); 2705ba2bf218SKurt Hackel if (ret >= 0) 2706ba2bf218SKurt Hackel break; 2707ba2bf218SKurt Hackel if (ret == -ENOTEMPTY) { 2708ba2bf218SKurt Hackel mlog(ML_ERROR, "lockres %.*s still has local locks!\n", 2709ba2bf218SKurt Hackel res->lockname.len, res->lockname.name); 2710ba2bf218SKurt Hackel BUG(); 2711ba2bf218SKurt Hackel } 2712ba2bf218SKurt Hackel 2713ba2bf218SKurt Hackel mlog(0, "lockres %.*s: migrate failed, " 2714ba2bf218SKurt Hackel "retrying\n", res->lockname.len, 2715ba2bf218SKurt Hackel res->lockname.name); 2716ba2bf218SKurt Hackel msleep(DLM_MIGRATION_RETRY_MS); 2717ba2bf218SKurt Hackel } 2718ba2bf218SKurt Hackel spin_lock(&dlm->spinlock); 2719ba2bf218SKurt Hackel leave: 2720ba2bf218SKurt Hackel return lock_dropped; 2721ba2bf218SKurt Hackel } 2722ba2bf218SKurt Hackel 27236714d8e8SKurt Hackel int dlm_lock_basts_flushed(struct dlm_ctxt *dlm, struct dlm_lock *lock) 27246714d8e8SKurt Hackel { 27256714d8e8SKurt Hackel int ret; 27266714d8e8SKurt Hackel spin_lock(&dlm->ast_lock); 27276714d8e8SKurt Hackel spin_lock(&lock->spinlock); 27286714d8e8SKurt Hackel ret = (list_empty(&lock->bast_list) && !lock->bast_pending); 27296714d8e8SKurt Hackel spin_unlock(&lock->spinlock); 27306714d8e8SKurt Hackel spin_unlock(&dlm->ast_lock); 27316714d8e8SKurt Hackel return ret; 27326714d8e8SKurt Hackel } 27336714d8e8SKurt Hackel 27346714d8e8SKurt Hackel static int dlm_migration_can_proceed(struct dlm_ctxt *dlm, 27356714d8e8SKurt Hackel struct dlm_lock_resource *res, 27366714d8e8SKurt Hackel u8 mig_target) 27376714d8e8SKurt Hackel { 27386714d8e8SKurt Hackel int can_proceed; 27396714d8e8SKurt Hackel spin_lock(&res->spinlock); 27406714d8e8SKurt Hackel can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING); 27416714d8e8SKurt Hackel spin_unlock(&res->spinlock); 27426714d8e8SKurt Hackel 27436714d8e8SKurt Hackel /* target has died, so make the caller break out of the 27446714d8e8SKurt Hackel * wait_event, but caller must recheck the domain_map */ 27456714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 27466714d8e8SKurt Hackel if (!test_bit(mig_target, dlm->domain_map)) 27476714d8e8SKurt Hackel can_proceed = 1; 27486714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 27496714d8e8SKurt Hackel return can_proceed; 27506714d8e8SKurt Hackel } 27516714d8e8SKurt Hackel 2752faf0ec9fSAdrian Bunk static int dlm_lockres_is_dirty(struct dlm_ctxt *dlm, 2753faf0ec9fSAdrian Bunk struct dlm_lock_resource *res) 27546714d8e8SKurt Hackel { 27556714d8e8SKurt Hackel int ret; 27566714d8e8SKurt Hackel spin_lock(&res->spinlock); 27576714d8e8SKurt Hackel ret = !!(res->state & DLM_LOCK_RES_DIRTY); 27586714d8e8SKurt Hackel spin_unlock(&res->spinlock); 27596714d8e8SKurt Hackel return ret; 27606714d8e8SKurt Hackel } 27616714d8e8SKurt Hackel 27626714d8e8SKurt Hackel 27636714d8e8SKurt Hackel static int dlm_mark_lockres_migrating(struct dlm_ctxt *dlm, 27646714d8e8SKurt Hackel struct dlm_lock_resource *res, 27656714d8e8SKurt Hackel u8 target) 27666714d8e8SKurt Hackel { 27676714d8e8SKurt Hackel int ret = 0; 27686714d8e8SKurt Hackel 27696714d8e8SKurt Hackel mlog(0, "dlm_mark_lockres_migrating: %.*s, from %u to %u\n", 27706714d8e8SKurt Hackel res->lockname.len, res->lockname.name, dlm->node_num, 27716714d8e8SKurt Hackel target); 27726714d8e8SKurt Hackel /* need to set MIGRATING flag on lockres. this is done by 27736714d8e8SKurt Hackel * ensuring that all asts have been flushed for this lockres. */ 27746714d8e8SKurt Hackel spin_lock(&res->spinlock); 27756714d8e8SKurt Hackel BUG_ON(res->migration_pending); 27766714d8e8SKurt Hackel res->migration_pending = 1; 27776714d8e8SKurt Hackel /* strategy is to reserve an extra ast then release 27786714d8e8SKurt Hackel * it below, letting the release do all of the work */ 27796714d8e8SKurt Hackel __dlm_lockres_reserve_ast(res); 27806714d8e8SKurt Hackel spin_unlock(&res->spinlock); 27816714d8e8SKurt Hackel 2782ddc09c8dSKurt Hackel /* now flush all the pending asts */ 27836714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 2784ddc09c8dSKurt Hackel /* before waiting on DIRTY, block processes which may 2785ddc09c8dSKurt Hackel * try to dirty the lockres before MIGRATING is set */ 2786ddc09c8dSKurt Hackel spin_lock(&res->spinlock); 2787ddc09c8dSKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_BLOCK_DIRTY); 2788ddc09c8dSKurt Hackel res->state |= DLM_LOCK_RES_BLOCK_DIRTY; 2789ddc09c8dSKurt Hackel spin_unlock(&res->spinlock); 2790ddc09c8dSKurt Hackel /* now wait on any pending asts and the DIRTY state */ 27916714d8e8SKurt Hackel wait_event(dlm->ast_wq, !dlm_lockres_is_dirty(dlm, res)); 27926714d8e8SKurt Hackel dlm_lockres_release_ast(dlm, res); 27936714d8e8SKurt Hackel 27946714d8e8SKurt Hackel mlog(0, "about to wait on migration_wq, dirty=%s\n", 27956714d8e8SKurt Hackel res->state & DLM_LOCK_RES_DIRTY ? "yes" : "no"); 27966714d8e8SKurt Hackel /* if the extra ref we just put was the final one, this 27976714d8e8SKurt Hackel * will pass thru immediately. otherwise, we need to wait 27986714d8e8SKurt Hackel * for the last ast to finish. */ 27996714d8e8SKurt Hackel again: 28006714d8e8SKurt Hackel ret = wait_event_interruptible_timeout(dlm->migration_wq, 28016714d8e8SKurt Hackel dlm_migration_can_proceed(dlm, res, target), 28026714d8e8SKurt Hackel msecs_to_jiffies(1000)); 28036714d8e8SKurt Hackel if (ret < 0) { 28046714d8e8SKurt Hackel mlog(0, "woken again: migrating? %s, dead? %s\n", 28056714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no", 28066714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes"); 28076714d8e8SKurt Hackel } else { 28086714d8e8SKurt Hackel mlog(0, "all is well: migrating? %s, dead? %s\n", 28096714d8e8SKurt Hackel res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no", 28106714d8e8SKurt Hackel test_bit(target, dlm->domain_map) ? "no":"yes"); 28116714d8e8SKurt Hackel } 28126714d8e8SKurt Hackel if (!dlm_migration_can_proceed(dlm, res, target)) { 28136714d8e8SKurt Hackel mlog(0, "trying again...\n"); 28146714d8e8SKurt Hackel goto again; 28156714d8e8SKurt Hackel } 28166714d8e8SKurt Hackel 2817a39953ddSWengang Wang ret = 0; 28186714d8e8SKurt Hackel /* did the target go down or die? */ 28196714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 28206714d8e8SKurt Hackel if (!test_bit(target, dlm->domain_map)) { 28216714d8e8SKurt Hackel mlog(ML_ERROR, "aha. migration target %u just went down\n", 28226714d8e8SKurt Hackel target); 28236714d8e8SKurt Hackel ret = -EHOSTDOWN; 28246714d8e8SKurt Hackel } 28256714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 28266714d8e8SKurt Hackel 28276714d8e8SKurt Hackel /* 2828a39953ddSWengang Wang * if target is down, we need to clear DLM_LOCK_RES_BLOCK_DIRTY for 2829a39953ddSWengang Wang * another try; otherwise, we are sure the MIGRATING state is there, 2830a39953ddSWengang Wang * drop the unneded state which blocked threads trying to DIRTY 2831a39953ddSWengang Wang */ 2832a39953ddSWengang Wang spin_lock(&res->spinlock); 2833a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_BLOCK_DIRTY)); 2834a39953ddSWengang Wang res->state &= ~DLM_LOCK_RES_BLOCK_DIRTY; 2835a39953ddSWengang Wang if (!ret) 2836a39953ddSWengang Wang BUG_ON(!(res->state & DLM_LOCK_RES_MIGRATING)); 2837a39953ddSWengang Wang spin_unlock(&res->spinlock); 2838a39953ddSWengang Wang 2839a39953ddSWengang Wang /* 28406714d8e8SKurt Hackel * at this point: 28416714d8e8SKurt Hackel * 2842a39953ddSWengang Wang * o the DLM_LOCK_RES_MIGRATING flag is set if target not down 28436714d8e8SKurt Hackel * o there are no pending asts on this lockres 28446714d8e8SKurt Hackel * o all processes trying to reserve an ast on this 28456714d8e8SKurt Hackel * lockres must wait for the MIGRATING flag to clear 28466714d8e8SKurt Hackel */ 28476714d8e8SKurt Hackel return ret; 28486714d8e8SKurt Hackel } 28496714d8e8SKurt Hackel 28506714d8e8SKurt Hackel /* last step in the migration process. 28516714d8e8SKurt Hackel * original master calls this to free all of the dlm_lock 28526714d8e8SKurt Hackel * structures that used to be for other nodes. */ 28536714d8e8SKurt Hackel static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm, 28546714d8e8SKurt Hackel struct dlm_lock_resource *res) 28556714d8e8SKurt Hackel { 28566714d8e8SKurt Hackel struct list_head *queue = &res->granted; 2857ba2bf218SKurt Hackel int i, bit; 2858800deef3SChristoph Hellwig struct dlm_lock *lock, *next; 28596714d8e8SKurt Hackel 28606714d8e8SKurt Hackel assert_spin_locked(&res->spinlock); 28616714d8e8SKurt Hackel 28626714d8e8SKurt Hackel BUG_ON(res->owner == dlm->node_num); 28636714d8e8SKurt Hackel 28646714d8e8SKurt Hackel for (i=0; i<3; i++) { 2865800deef3SChristoph Hellwig list_for_each_entry_safe(lock, next, queue, list) { 28666714d8e8SKurt Hackel if (lock->ml.node != dlm->node_num) { 28676714d8e8SKurt Hackel mlog(0, "putting lock for node %u\n", 28686714d8e8SKurt Hackel lock->ml.node); 28696714d8e8SKurt Hackel /* be extra careful */ 28706714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->ast_list)); 28716714d8e8SKurt Hackel BUG_ON(!list_empty(&lock->bast_list)); 28726714d8e8SKurt Hackel BUG_ON(lock->ast_pending); 28736714d8e8SKurt Hackel BUG_ON(lock->bast_pending); 2874ba2bf218SKurt Hackel dlm_lockres_clear_refmap_bit(lock->ml.node, res); 28756714d8e8SKurt Hackel list_del_init(&lock->list); 28766714d8e8SKurt Hackel dlm_lock_put(lock); 28772c5c54acSSunil Mushran /* In a normal unlock, we would have added a 28782c5c54acSSunil Mushran * DLM_UNLOCK_FREE_LOCK action. Force it. */ 28792c5c54acSSunil Mushran dlm_lock_put(lock); 28806714d8e8SKurt Hackel } 28816714d8e8SKurt Hackel } 28826714d8e8SKurt Hackel queue++; 28836714d8e8SKurt Hackel } 2884ba2bf218SKurt Hackel bit = 0; 2885ba2bf218SKurt Hackel while (1) { 2886ba2bf218SKurt Hackel bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit); 2887ba2bf218SKurt Hackel if (bit >= O2NM_MAX_NODES) 2888ba2bf218SKurt Hackel break; 2889ba2bf218SKurt Hackel /* do not clear the local node reference, if there is a 2890ba2bf218SKurt Hackel * process holding this, let it drop the ref itself */ 2891ba2bf218SKurt Hackel if (bit != dlm->node_num) { 2892ba2bf218SKurt Hackel mlog(0, "%s:%.*s: node %u had a ref to this " 2893ba2bf218SKurt Hackel "migrating lockres, clearing\n", dlm->name, 2894ba2bf218SKurt Hackel res->lockname.len, res->lockname.name, bit); 2895ba2bf218SKurt Hackel dlm_lockres_clear_refmap_bit(bit, res); 2896ba2bf218SKurt Hackel } 2897ba2bf218SKurt Hackel bit++; 2898ba2bf218SKurt Hackel } 28996714d8e8SKurt Hackel } 29006714d8e8SKurt Hackel 29016714d8e8SKurt Hackel /* for now this is not too intelligent. we will 29026714d8e8SKurt Hackel * need stats to make this do the right thing. 29036714d8e8SKurt Hackel * this just finds the first lock on one of the 29046714d8e8SKurt Hackel * queues and uses that node as the target. */ 29056714d8e8SKurt Hackel static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm, 29066714d8e8SKurt Hackel struct dlm_lock_resource *res) 29076714d8e8SKurt Hackel { 29086714d8e8SKurt Hackel int i; 29096714d8e8SKurt Hackel struct list_head *queue = &res->granted; 29106714d8e8SKurt Hackel struct dlm_lock *lock; 29116714d8e8SKurt Hackel int nodenum; 29126714d8e8SKurt Hackel 29136714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 29146714d8e8SKurt Hackel 29156714d8e8SKurt Hackel spin_lock(&res->spinlock); 29166714d8e8SKurt Hackel for (i=0; i<3; i++) { 2917800deef3SChristoph Hellwig list_for_each_entry(lock, queue, list) { 29186714d8e8SKurt Hackel /* up to the caller to make sure this node 29196714d8e8SKurt Hackel * is alive */ 29206714d8e8SKurt Hackel if (lock->ml.node != dlm->node_num) { 29216714d8e8SKurt Hackel spin_unlock(&res->spinlock); 29226714d8e8SKurt Hackel return lock->ml.node; 29236714d8e8SKurt Hackel } 29246714d8e8SKurt Hackel } 29256714d8e8SKurt Hackel queue++; 29266714d8e8SKurt Hackel } 2927388c4bcbSSunil Mushran 2928388c4bcbSSunil Mushran nodenum = find_next_bit(res->refmap, O2NM_MAX_NODES, 0); 2929388c4bcbSSunil Mushran if (nodenum < O2NM_MAX_NODES) { 2930388c4bcbSSunil Mushran spin_unlock(&res->spinlock); 2931388c4bcbSSunil Mushran return nodenum; 2932388c4bcbSSunil Mushran } 29336714d8e8SKurt Hackel spin_unlock(&res->spinlock); 29346714d8e8SKurt Hackel mlog(0, "have not found a suitable target yet! checking domain map\n"); 29356714d8e8SKurt Hackel 29366714d8e8SKurt Hackel /* ok now we're getting desperate. pick anyone alive. */ 29376714d8e8SKurt Hackel nodenum = -1; 29386714d8e8SKurt Hackel while (1) { 29396714d8e8SKurt Hackel nodenum = find_next_bit(dlm->domain_map, 29406714d8e8SKurt Hackel O2NM_MAX_NODES, nodenum+1); 29416714d8e8SKurt Hackel mlog(0, "found %d in domain map\n", nodenum); 29426714d8e8SKurt Hackel if (nodenum >= O2NM_MAX_NODES) 29436714d8e8SKurt Hackel break; 29446714d8e8SKurt Hackel if (nodenum != dlm->node_num) { 29456714d8e8SKurt Hackel mlog(0, "picking %d\n", nodenum); 29466714d8e8SKurt Hackel return nodenum; 29476714d8e8SKurt Hackel } 29486714d8e8SKurt Hackel } 29496714d8e8SKurt Hackel 29506714d8e8SKurt Hackel mlog(0, "giving up. no master to migrate to\n"); 29516714d8e8SKurt Hackel return DLM_LOCK_RES_OWNER_UNKNOWN; 29526714d8e8SKurt Hackel } 29536714d8e8SKurt Hackel 29546714d8e8SKurt Hackel 29556714d8e8SKurt Hackel 29566714d8e8SKurt Hackel /* this is called by the new master once all lockres 29576714d8e8SKurt Hackel * data has been received */ 29586714d8e8SKurt Hackel static int dlm_do_migrate_request(struct dlm_ctxt *dlm, 29596714d8e8SKurt Hackel struct dlm_lock_resource *res, 29606714d8e8SKurt Hackel u8 master, u8 new_master, 29616714d8e8SKurt Hackel struct dlm_node_iter *iter) 29626714d8e8SKurt Hackel { 29636714d8e8SKurt Hackel struct dlm_migrate_request migrate; 29642b832564SSunil Mushran int ret, skip, status = 0; 29656714d8e8SKurt Hackel int nodenum; 29666714d8e8SKurt Hackel 29676714d8e8SKurt Hackel memset(&migrate, 0, sizeof(migrate)); 29686714d8e8SKurt Hackel migrate.namelen = res->lockname.len; 29696714d8e8SKurt Hackel memcpy(migrate.name, res->lockname.name, migrate.namelen); 29706714d8e8SKurt Hackel migrate.new_master = new_master; 29716714d8e8SKurt Hackel migrate.master = master; 29726714d8e8SKurt Hackel 29736714d8e8SKurt Hackel ret = 0; 29746714d8e8SKurt Hackel 29756714d8e8SKurt Hackel /* send message to all nodes, except the master and myself */ 29766714d8e8SKurt Hackel while ((nodenum = dlm_node_iter_next(iter)) >= 0) { 29776714d8e8SKurt Hackel if (nodenum == master || 29786714d8e8SKurt Hackel nodenum == new_master) 29796714d8e8SKurt Hackel continue; 29806714d8e8SKurt Hackel 29812b832564SSunil Mushran /* We could race exit domain. If exited, skip. */ 29822b832564SSunil Mushran spin_lock(&dlm->spinlock); 29832b832564SSunil Mushran skip = (!test_bit(nodenum, dlm->domain_map)); 29842b832564SSunil Mushran spin_unlock(&dlm->spinlock); 29852b832564SSunil Mushran if (skip) { 29862b832564SSunil Mushran clear_bit(nodenum, iter->node_map); 29872b832564SSunil Mushran continue; 29882b832564SSunil Mushran } 29892b832564SSunil Mushran 29906714d8e8SKurt Hackel ret = o2net_send_message(DLM_MIGRATE_REQUEST_MSG, dlm->key, 29916714d8e8SKurt Hackel &migrate, sizeof(migrate), nodenum, 29926714d8e8SKurt Hackel &status); 29932b832564SSunil Mushran if (ret < 0) { 2994a5196ec5SWengang Wang mlog(ML_ERROR, "Error %d when sending message %u (key " 2995a5196ec5SWengang Wang "0x%x) to node %u\n", ret, DLM_MIGRATE_REQUEST_MSG, 2996a5196ec5SWengang Wang dlm->key, nodenum); 29972b832564SSunil Mushran if (!dlm_is_host_down(ret)) { 29982b832564SSunil Mushran mlog(ML_ERROR, "unhandled error=%d!\n", ret); 29992b832564SSunil Mushran BUG(); 30002b832564SSunil Mushran } 30012b832564SSunil Mushran clear_bit(nodenum, iter->node_map); 30022b832564SSunil Mushran ret = 0; 30032b832564SSunil Mushran } else if (status < 0) { 30046714d8e8SKurt Hackel mlog(0, "migrate request (node %u) returned %d!\n", 30056714d8e8SKurt Hackel nodenum, status); 30066714d8e8SKurt Hackel ret = status; 3007ba2bf218SKurt Hackel } else if (status == DLM_MIGRATE_RESPONSE_MASTERY_REF) { 3008ba2bf218SKurt Hackel /* during the migration request we short-circuited 3009ba2bf218SKurt Hackel * the mastery of the lockres. make sure we have 3010ba2bf218SKurt Hackel * a mastery ref for nodenum */ 3011ba2bf218SKurt Hackel mlog(0, "%s:%.*s: need ref for node %u\n", 3012ba2bf218SKurt Hackel dlm->name, res->lockname.len, res->lockname.name, 3013ba2bf218SKurt Hackel nodenum); 3014ba2bf218SKurt Hackel spin_lock(&res->spinlock); 3015ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(nodenum, res); 3016ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 30176714d8e8SKurt Hackel } 30186714d8e8SKurt Hackel } 30196714d8e8SKurt Hackel 30206714d8e8SKurt Hackel if (ret < 0) 30216714d8e8SKurt Hackel mlog_errno(ret); 30226714d8e8SKurt Hackel 30236714d8e8SKurt Hackel mlog(0, "returning ret=%d\n", ret); 30246714d8e8SKurt Hackel return ret; 30256714d8e8SKurt Hackel } 30266714d8e8SKurt Hackel 30276714d8e8SKurt Hackel 30286714d8e8SKurt Hackel /* if there is an existing mle for this lockres, we now know who the master is. 30296714d8e8SKurt Hackel * (the one who sent us *this* message) we can clear it up right away. 30306714d8e8SKurt Hackel * since the process that put the mle on the list still has a reference to it, 30316714d8e8SKurt Hackel * we can unhash it now, set the master and wake the process. as a result, 30326714d8e8SKurt Hackel * we will have no mle in the list to start with. now we can add an mle for 30336714d8e8SKurt Hackel * the migration and this should be the only one found for those scanning the 30346714d8e8SKurt Hackel * list. */ 3035d74c9803SKurt Hackel int dlm_migrate_request_handler(struct o2net_msg *msg, u32 len, void *data, 3036d74c9803SKurt Hackel void **ret_data) 30376714d8e8SKurt Hackel { 30386714d8e8SKurt Hackel struct dlm_ctxt *dlm = data; 30396714d8e8SKurt Hackel struct dlm_lock_resource *res = NULL; 30406714d8e8SKurt Hackel struct dlm_migrate_request *migrate = (struct dlm_migrate_request *) msg->buf; 30416714d8e8SKurt Hackel struct dlm_master_list_entry *mle = NULL, *oldmle = NULL; 30426714d8e8SKurt Hackel const char *name; 3043a3d33291SMark Fasheh unsigned int namelen, hash; 30446714d8e8SKurt Hackel int ret = 0; 30456714d8e8SKurt Hackel 30466714d8e8SKurt Hackel if (!dlm_grab(dlm)) 30476714d8e8SKurt Hackel return -EINVAL; 30486714d8e8SKurt Hackel 30496714d8e8SKurt Hackel name = migrate->name; 30506714d8e8SKurt Hackel namelen = migrate->namelen; 3051a3d33291SMark Fasheh hash = dlm_lockid_hash(name, namelen); 30526714d8e8SKurt Hackel 30536714d8e8SKurt Hackel /* preallocate.. if this fails, abort */ 30543914ed0cSJulia Lawall mle = kmem_cache_alloc(dlm_mle_cache, GFP_NOFS); 30556714d8e8SKurt Hackel 30566714d8e8SKurt Hackel if (!mle) { 30576714d8e8SKurt Hackel ret = -ENOMEM; 30586714d8e8SKurt Hackel goto leave; 30596714d8e8SKurt Hackel } 30606714d8e8SKurt Hackel 30616714d8e8SKurt Hackel /* check for pre-existing lock */ 30626714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 3063a3d33291SMark Fasheh res = __dlm_lookup_lockres(dlm, name, namelen, hash); 30646714d8e8SKurt Hackel if (res) { 30656714d8e8SKurt Hackel spin_lock(&res->spinlock); 30666714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_RECOVERING) { 30676714d8e8SKurt Hackel /* if all is working ok, this can only mean that we got 30686714d8e8SKurt Hackel * a migrate request from a node that we now see as 30696714d8e8SKurt Hackel * dead. what can we do here? drop it to the floor? */ 30706714d8e8SKurt Hackel spin_unlock(&res->spinlock); 30716714d8e8SKurt Hackel mlog(ML_ERROR, "Got a migrate request, but the " 30726714d8e8SKurt Hackel "lockres is marked as recovering!"); 30736714d8e8SKurt Hackel kmem_cache_free(dlm_mle_cache, mle); 30746714d8e8SKurt Hackel ret = -EINVAL; /* need a better solution */ 30756714d8e8SKurt Hackel goto unlock; 30766714d8e8SKurt Hackel } 30776714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING; 30786714d8e8SKurt Hackel spin_unlock(&res->spinlock); 30796714d8e8SKurt Hackel } 30806714d8e8SKurt Hackel 30816d98c3ccSWengang Wang spin_lock(&dlm->master_lock); 30826714d8e8SKurt Hackel /* ignore status. only nonzero status would BUG. */ 30836714d8e8SKurt Hackel ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, 30846714d8e8SKurt Hackel name, namelen, 30856714d8e8SKurt Hackel migrate->new_master, 30866714d8e8SKurt Hackel migrate->master); 30876714d8e8SKurt Hackel 30886714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 30896d98c3ccSWengang Wang unlock: 30906714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 30916714d8e8SKurt Hackel 30926714d8e8SKurt Hackel if (oldmle) { 30936714d8e8SKurt Hackel /* master is known, detach if not already detached */ 30946714d8e8SKurt Hackel dlm_mle_detach_hb_events(dlm, oldmle); 30956714d8e8SKurt Hackel dlm_put_mle(oldmle); 30966714d8e8SKurt Hackel } 30976714d8e8SKurt Hackel 30986714d8e8SKurt Hackel if (res) 30996714d8e8SKurt Hackel dlm_lockres_put(res); 31006714d8e8SKurt Hackel leave: 31016714d8e8SKurt Hackel dlm_put(dlm); 31026714d8e8SKurt Hackel return ret; 31036714d8e8SKurt Hackel } 31046714d8e8SKurt Hackel 31056714d8e8SKurt Hackel /* must be holding dlm->spinlock and dlm->master_lock 31066714d8e8SKurt Hackel * when adding a migration mle, we can clear any other mles 31076714d8e8SKurt Hackel * in the master list because we know with certainty that 31086714d8e8SKurt Hackel * the master is "master". so we remove any old mle from 31096714d8e8SKurt Hackel * the list after setting it's master field, and then add 31106714d8e8SKurt Hackel * the new migration mle. this way we can hold with the rule 31116714d8e8SKurt Hackel * of having only one mle for a given lock name at all times. */ 31126714d8e8SKurt Hackel static int dlm_add_migration_mle(struct dlm_ctxt *dlm, 31136714d8e8SKurt Hackel struct dlm_lock_resource *res, 31146714d8e8SKurt Hackel struct dlm_master_list_entry *mle, 31156714d8e8SKurt Hackel struct dlm_master_list_entry **oldmle, 31166714d8e8SKurt Hackel const char *name, unsigned int namelen, 31176714d8e8SKurt Hackel u8 new_master, u8 master) 31186714d8e8SKurt Hackel { 31196714d8e8SKurt Hackel int found; 31206714d8e8SKurt Hackel int ret = 0; 31216714d8e8SKurt Hackel 31226714d8e8SKurt Hackel *oldmle = NULL; 31236714d8e8SKurt Hackel 31246714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 31256714d8e8SKurt Hackel assert_spin_locked(&dlm->master_lock); 31266714d8e8SKurt Hackel 31276714d8e8SKurt Hackel /* caller is responsible for any ref taken here on oldmle */ 31286714d8e8SKurt Hackel found = dlm_find_mle(dlm, oldmle, (char *)name, namelen); 31296714d8e8SKurt Hackel if (found) { 31306714d8e8SKurt Hackel struct dlm_master_list_entry *tmp = *oldmle; 31316714d8e8SKurt Hackel spin_lock(&tmp->spinlock); 31326714d8e8SKurt Hackel if (tmp->type == DLM_MLE_MIGRATION) { 31336714d8e8SKurt Hackel if (master == dlm->node_num) { 31346714d8e8SKurt Hackel /* ah another process raced me to it */ 31356714d8e8SKurt Hackel mlog(0, "tried to migrate %.*s, but some " 31366714d8e8SKurt Hackel "process beat me to it\n", 31376714d8e8SKurt Hackel namelen, name); 31386714d8e8SKurt Hackel ret = -EEXIST; 31396714d8e8SKurt Hackel } else { 31406714d8e8SKurt Hackel /* bad. 2 NODES are trying to migrate! */ 31416714d8e8SKurt Hackel mlog(ML_ERROR, "migration error mle: " 31426714d8e8SKurt Hackel "master=%u new_master=%u // request: " 31436714d8e8SKurt Hackel "master=%u new_master=%u // " 31446714d8e8SKurt Hackel "lockres=%.*s\n", 31456714d8e8SKurt Hackel tmp->master, tmp->new_master, 31466714d8e8SKurt Hackel master, new_master, 31476714d8e8SKurt Hackel namelen, name); 31486714d8e8SKurt Hackel BUG(); 31496714d8e8SKurt Hackel } 31506714d8e8SKurt Hackel } else { 31516714d8e8SKurt Hackel /* this is essentially what assert_master does */ 31526714d8e8SKurt Hackel tmp->master = master; 31536714d8e8SKurt Hackel atomic_set(&tmp->woken, 1); 31546714d8e8SKurt Hackel wake_up(&tmp->wq); 31551c084577SSunil Mushran /* remove it so that only one mle will be found */ 31561c084577SSunil Mushran __dlm_unlink_mle(dlm, tmp); 3157ba2bf218SKurt Hackel __dlm_mle_detach_hb_events(dlm, tmp); 3158ba2bf218SKurt Hackel ret = DLM_MIGRATE_RESPONSE_MASTERY_REF; 3159ba2bf218SKurt Hackel mlog(0, "%s:%.*s: master=%u, newmaster=%u, " 3160ba2bf218SKurt Hackel "telling master to get ref for cleared out mle " 3161ba2bf218SKurt Hackel "during migration\n", dlm->name, namelen, name, 3162ba2bf218SKurt Hackel master, new_master); 31636714d8e8SKurt Hackel } 31646714d8e8SKurt Hackel spin_unlock(&tmp->spinlock); 31656714d8e8SKurt Hackel } 31666714d8e8SKurt Hackel 31676714d8e8SKurt Hackel /* now add a migration mle to the tail of the list */ 31686714d8e8SKurt Hackel dlm_init_mle(mle, DLM_MLE_MIGRATION, dlm, res, name, namelen); 31696714d8e8SKurt Hackel mle->new_master = new_master; 3170ba2bf218SKurt Hackel /* the new master will be sending an assert master for this. 3171ba2bf218SKurt Hackel * at that point we will get the refmap reference */ 31726714d8e8SKurt Hackel mle->master = master; 31736714d8e8SKurt Hackel /* do this for consistency with other mle types */ 31746714d8e8SKurt Hackel set_bit(new_master, mle->maybe_map); 31751c084577SSunil Mushran __dlm_insert_mle(dlm, mle); 31766714d8e8SKurt Hackel 31776714d8e8SKurt Hackel return ret; 31786714d8e8SKurt Hackel } 31796714d8e8SKurt Hackel 3180c2cd4a44SSunil Mushran /* 3181c2cd4a44SSunil Mushran * Sets the owner of the lockres, associated to the mle, to UNKNOWN 3182c2cd4a44SSunil Mushran */ 3183c2cd4a44SSunil Mushran static struct dlm_lock_resource *dlm_reset_mleres_owner(struct dlm_ctxt *dlm, 3184c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle) 3185c2cd4a44SSunil Mushran { 3186c2cd4a44SSunil Mushran struct dlm_lock_resource *res; 3187c2cd4a44SSunil Mushran 3188c2cd4a44SSunil Mushran /* Find the lockres associated to the mle and set its owner to UNK */ 31897141514bSSunil Mushran res = __dlm_lookup_lockres(dlm, mle->mname, mle->mnamelen, 31907141514bSSunil Mushran mle->mnamehash); 3191c2cd4a44SSunil Mushran if (res) { 3192c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock); 3193c2cd4a44SSunil Mushran 3194c2cd4a44SSunil Mushran /* move lockres onto recovery list */ 3195c2cd4a44SSunil Mushran spin_lock(&res->spinlock); 3196c2cd4a44SSunil Mushran dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN); 3197c2cd4a44SSunil Mushran dlm_move_lockres_to_recovery_list(dlm, res); 3198c2cd4a44SSunil Mushran spin_unlock(&res->spinlock); 3199c2cd4a44SSunil Mushran dlm_lockres_put(res); 3200c2cd4a44SSunil Mushran 3201c2cd4a44SSunil Mushran /* about to get rid of mle, detach from heartbeat */ 3202c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3203c2cd4a44SSunil Mushran 3204c2cd4a44SSunil Mushran /* dump the mle */ 3205c2cd4a44SSunil Mushran spin_lock(&dlm->master_lock); 3206c2cd4a44SSunil Mushran __dlm_put_mle(mle); 3207c2cd4a44SSunil Mushran spin_unlock(&dlm->master_lock); 3208c2cd4a44SSunil Mushran } 3209c2cd4a44SSunil Mushran 3210c2cd4a44SSunil Mushran return res; 3211c2cd4a44SSunil Mushran } 3212c2cd4a44SSunil Mushran 3213c2cd4a44SSunil Mushran static void dlm_clean_migration_mle(struct dlm_ctxt *dlm, 3214c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle) 3215c2cd4a44SSunil Mushran { 3216c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3217c2cd4a44SSunil Mushran 3218c2cd4a44SSunil Mushran spin_lock(&mle->spinlock); 3219c2cd4a44SSunil Mushran __dlm_unlink_mle(dlm, mle); 3220c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1); 3221c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3222c2cd4a44SSunil Mushran 3223c2cd4a44SSunil Mushran wake_up(&mle->wq); 3224c2cd4a44SSunil Mushran } 3225c2cd4a44SSunil Mushran 3226c2cd4a44SSunil Mushran static void dlm_clean_block_mle(struct dlm_ctxt *dlm, 3227c2cd4a44SSunil Mushran struct dlm_master_list_entry *mle, u8 dead_node) 3228c2cd4a44SSunil Mushran { 3229c2cd4a44SSunil Mushran int bit; 3230c2cd4a44SSunil Mushran 3231c2cd4a44SSunil Mushran BUG_ON(mle->type != DLM_MLE_BLOCK); 3232c2cd4a44SSunil Mushran 3233c2cd4a44SSunil Mushran spin_lock(&mle->spinlock); 3234c2cd4a44SSunil Mushran bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0); 3235c2cd4a44SSunil Mushran if (bit != dead_node) { 3236c2cd4a44SSunil Mushran mlog(0, "mle found, but dead node %u would not have been " 3237c2cd4a44SSunil Mushran "master\n", dead_node); 3238c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3239c2cd4a44SSunil Mushran } else { 3240c2cd4a44SSunil Mushran /* Must drop the refcount by one since the assert_master will 3241c2cd4a44SSunil Mushran * never arrive. This may result in the mle being unlinked and 3242c2cd4a44SSunil Mushran * freed, but there may still be a process waiting in the 3243c2cd4a44SSunil Mushran * dlmlock path which is fine. */ 3244c2cd4a44SSunil Mushran mlog(0, "node %u was expected master\n", dead_node); 3245c2cd4a44SSunil Mushran atomic_set(&mle->woken, 1); 3246c2cd4a44SSunil Mushran spin_unlock(&mle->spinlock); 3247c2cd4a44SSunil Mushran wake_up(&mle->wq); 3248c2cd4a44SSunil Mushran 3249c2cd4a44SSunil Mushran /* Do not need events any longer, so detach from heartbeat */ 3250c2cd4a44SSunil Mushran __dlm_mle_detach_hb_events(dlm, mle); 3251c2cd4a44SSunil Mushran __dlm_put_mle(mle); 3252c2cd4a44SSunil Mushran } 3253c2cd4a44SSunil Mushran } 32546714d8e8SKurt Hackel 32556714d8e8SKurt Hackel void dlm_clean_master_list(struct dlm_ctxt *dlm, u8 dead_node) 32566714d8e8SKurt Hackel { 32572ed6c750SSunil Mushran struct dlm_master_list_entry *mle; 32586714d8e8SKurt Hackel struct dlm_lock_resource *res; 32592ed6c750SSunil Mushran struct hlist_head *bucket; 32602ed6c750SSunil Mushran struct hlist_node *list; 32612ed6c750SSunil Mushran unsigned int i; 32626714d8e8SKurt Hackel 3263ef6b689bSTao Ma mlog(0, "dlm=%s, dead node=%u\n", dlm->name, dead_node); 32646714d8e8SKurt Hackel top: 32656714d8e8SKurt Hackel assert_spin_locked(&dlm->spinlock); 32666714d8e8SKurt Hackel 32676714d8e8SKurt Hackel /* clean the master list */ 32686714d8e8SKurt Hackel spin_lock(&dlm->master_lock); 32692ed6c750SSunil Mushran for (i = 0; i < DLM_HASH_BUCKETS; i++) { 32702ed6c750SSunil Mushran bucket = dlm_master_hash(dlm, i); 32712ed6c750SSunil Mushran hlist_for_each(list, bucket) { 32722ed6c750SSunil Mushran mle = hlist_entry(list, struct dlm_master_list_entry, 32732ed6c750SSunil Mushran master_hash_node); 32742ed6c750SSunil Mushran 32756714d8e8SKurt Hackel BUG_ON(mle->type != DLM_MLE_BLOCK && 32766714d8e8SKurt Hackel mle->type != DLM_MLE_MASTER && 32776714d8e8SKurt Hackel mle->type != DLM_MLE_MIGRATION); 32786714d8e8SKurt Hackel 327967ae1f06SSunil Mushran /* MASTER mles are initiated locally. The waiting 328067ae1f06SSunil Mushran * process will notice the node map change shortly. 328167ae1f06SSunil Mushran * Let that happen as normal. */ 32826714d8e8SKurt Hackel if (mle->type == DLM_MLE_MASTER) 32836714d8e8SKurt Hackel continue; 32846714d8e8SKurt Hackel 328567ae1f06SSunil Mushran /* BLOCK mles are initiated by other nodes. Need to 328667ae1f06SSunil Mushran * clean up if the dead node would have been the 328767ae1f06SSunil Mushran * master. */ 32886714d8e8SKurt Hackel if (mle->type == DLM_MLE_BLOCK) { 3289c2cd4a44SSunil Mushran dlm_clean_block_mle(dlm, mle, dead_node); 32906714d8e8SKurt Hackel continue; 32916714d8e8SKurt Hackel } 32926714d8e8SKurt Hackel 329367ae1f06SSunil Mushran /* Everything else is a MIGRATION mle */ 32946714d8e8SKurt Hackel 329567ae1f06SSunil Mushran /* The rule for MIGRATION mles is that the master 329667ae1f06SSunil Mushran * becomes UNKNOWN if *either* the original or the new 329767ae1f06SSunil Mushran * master dies. All UNKNOWN lockres' are sent to 329867ae1f06SSunil Mushran * whichever node becomes the recovery master. The new 329967ae1f06SSunil Mushran * master is responsible for determining if there is 330067ae1f06SSunil Mushran * still a master for this lockres, or if he needs to 330167ae1f06SSunil Mushran * take over mastery. Either way, this node should 330267ae1f06SSunil Mushran * expect another message to resolve this. */ 330367ae1f06SSunil Mushran 33046714d8e8SKurt Hackel if (mle->master != dead_node && 33056714d8e8SKurt Hackel mle->new_master != dead_node) 33066714d8e8SKurt Hackel continue; 33076714d8e8SKurt Hackel 330867ae1f06SSunil Mushran /* If we have reached this point, this mle needs to be 330967ae1f06SSunil Mushran * removed from the list and freed. */ 3310c2cd4a44SSunil Mushran dlm_clean_migration_mle(dlm, mle); 33116714d8e8SKurt Hackel 3312aa852354SKurt Hackel mlog(0, "%s: node %u died during migration from " 331367ae1f06SSunil Mushran "%u to %u!\n", dlm->name, dead_node, mle->master, 331467ae1f06SSunil Mushran mle->new_master); 3315c2cd4a44SSunil Mushran 3316c2cd4a44SSunil Mushran /* If we find a lockres associated with the mle, we've 3317c2cd4a44SSunil Mushran * hit this rare case that messes up our lock ordering. 3318c2cd4a44SSunil Mushran * If so, we need to drop the master lock so that we can 3319c2cd4a44SSunil Mushran * take the lockres lock, meaning that we will have to 33206714d8e8SKurt Hackel * restart from the head of list. */ 3321c2cd4a44SSunil Mushran res = dlm_reset_mleres_owner(dlm, mle); 3322c2cd4a44SSunil Mushran if (res) 33236714d8e8SKurt Hackel /* restart */ 33246714d8e8SKurt Hackel goto top; 33256714d8e8SKurt Hackel 332667ae1f06SSunil Mushran /* This may be the last reference */ 33276714d8e8SKurt Hackel __dlm_put_mle(mle); 33286714d8e8SKurt Hackel } 33292ed6c750SSunil Mushran } 33306714d8e8SKurt Hackel spin_unlock(&dlm->master_lock); 33316714d8e8SKurt Hackel } 33326714d8e8SKurt Hackel 33336714d8e8SKurt Hackel int dlm_finish_migration(struct dlm_ctxt *dlm, struct dlm_lock_resource *res, 33346714d8e8SKurt Hackel u8 old_master) 33356714d8e8SKurt Hackel { 33366714d8e8SKurt Hackel struct dlm_node_iter iter; 33376714d8e8SKurt Hackel int ret = 0; 33386714d8e8SKurt Hackel 33396714d8e8SKurt Hackel spin_lock(&dlm->spinlock); 33406714d8e8SKurt Hackel dlm_node_iter_init(dlm->domain_map, &iter); 33416714d8e8SKurt Hackel clear_bit(old_master, iter.node_map); 33426714d8e8SKurt Hackel clear_bit(dlm->node_num, iter.node_map); 33436714d8e8SKurt Hackel spin_unlock(&dlm->spinlock); 33446714d8e8SKurt Hackel 3345ba2bf218SKurt Hackel /* ownership of the lockres is changing. account for the 3346ba2bf218SKurt Hackel * mastery reference here since old_master will briefly have 3347ba2bf218SKurt Hackel * a reference after the migration completes */ 3348ba2bf218SKurt Hackel spin_lock(&res->spinlock); 3349ba2bf218SKurt Hackel dlm_lockres_set_refmap_bit(old_master, res); 3350ba2bf218SKurt Hackel spin_unlock(&res->spinlock); 3351ba2bf218SKurt Hackel 33526714d8e8SKurt Hackel mlog(0, "now time to do a migrate request to other nodes\n"); 33536714d8e8SKurt Hackel ret = dlm_do_migrate_request(dlm, res, old_master, 33546714d8e8SKurt Hackel dlm->node_num, &iter); 33556714d8e8SKurt Hackel if (ret < 0) { 33566714d8e8SKurt Hackel mlog_errno(ret); 33576714d8e8SKurt Hackel goto leave; 33586714d8e8SKurt Hackel } 33596714d8e8SKurt Hackel 33606714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s to all except the original node\n", 33616714d8e8SKurt Hackel res->lockname.len, res->lockname.name); 33626714d8e8SKurt Hackel /* this call now finishes out the nodemap 33636714d8e8SKurt Hackel * even if one or more nodes die */ 3364ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map, 33656714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION); 33666714d8e8SKurt Hackel if (ret < 0) { 33676714d8e8SKurt Hackel /* no longer need to retry. all living nodes contacted. */ 33686714d8e8SKurt Hackel mlog_errno(ret); 33696714d8e8SKurt Hackel ret = 0; 33706714d8e8SKurt Hackel } 33716714d8e8SKurt Hackel 33726714d8e8SKurt Hackel memset(iter.node_map, 0, sizeof(iter.node_map)); 33736714d8e8SKurt Hackel set_bit(old_master, iter.node_map); 33746714d8e8SKurt Hackel mlog(0, "doing assert master of %.*s back to %u\n", 33756714d8e8SKurt Hackel res->lockname.len, res->lockname.name, old_master); 3376ba2bf218SKurt Hackel ret = dlm_do_assert_master(dlm, res, iter.node_map, 33776714d8e8SKurt Hackel DLM_ASSERT_MASTER_FINISH_MIGRATION); 33786714d8e8SKurt Hackel if (ret < 0) { 33796714d8e8SKurt Hackel mlog(0, "assert master to original master failed " 33806714d8e8SKurt Hackel "with %d.\n", ret); 33816714d8e8SKurt Hackel /* the only nonzero status here would be because of 33826714d8e8SKurt Hackel * a dead original node. we're done. */ 33836714d8e8SKurt Hackel ret = 0; 33846714d8e8SKurt Hackel } 33856714d8e8SKurt Hackel 33866714d8e8SKurt Hackel /* all done, set the owner, clear the flag */ 33876714d8e8SKurt Hackel spin_lock(&res->spinlock); 33886714d8e8SKurt Hackel dlm_set_lockres_owner(dlm, res, dlm->node_num); 33896714d8e8SKurt Hackel res->state &= ~DLM_LOCK_RES_MIGRATING; 33906714d8e8SKurt Hackel spin_unlock(&res->spinlock); 33916714d8e8SKurt Hackel /* re-dirty it on the new master */ 33926714d8e8SKurt Hackel dlm_kick_thread(dlm, res); 33936714d8e8SKurt Hackel wake_up(&res->wq); 33946714d8e8SKurt Hackel leave: 33956714d8e8SKurt Hackel return ret; 33966714d8e8SKurt Hackel } 33976714d8e8SKurt Hackel 33986714d8e8SKurt Hackel /* 33996714d8e8SKurt Hackel * LOCKRES AST REFCOUNT 34006714d8e8SKurt Hackel * this is integral to migration 34016714d8e8SKurt Hackel */ 34026714d8e8SKurt Hackel 34036714d8e8SKurt Hackel /* for future intent to call an ast, reserve one ahead of time. 34046714d8e8SKurt Hackel * this should be called only after waiting on the lockres 34056714d8e8SKurt Hackel * with dlm_wait_on_lockres, and while still holding the 34066714d8e8SKurt Hackel * spinlock after the call. */ 34076714d8e8SKurt Hackel void __dlm_lockres_reserve_ast(struct dlm_lock_resource *res) 34086714d8e8SKurt Hackel { 34096714d8e8SKurt Hackel assert_spin_locked(&res->spinlock); 34106714d8e8SKurt Hackel if (res->state & DLM_LOCK_RES_MIGRATING) { 34116714d8e8SKurt Hackel __dlm_print_one_lock_resource(res); 34126714d8e8SKurt Hackel } 34136714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING); 34146714d8e8SKurt Hackel 34156714d8e8SKurt Hackel atomic_inc(&res->asts_reserved); 34166714d8e8SKurt Hackel } 34176714d8e8SKurt Hackel 34186714d8e8SKurt Hackel /* 34196714d8e8SKurt Hackel * used to drop the reserved ast, either because it went unused, 34206714d8e8SKurt Hackel * or because the ast/bast was actually called. 34216714d8e8SKurt Hackel * 34226714d8e8SKurt Hackel * also, if there is a pending migration on this lockres, 34236714d8e8SKurt Hackel * and this was the last pending ast on the lockres, 34246714d8e8SKurt Hackel * atomically set the MIGRATING flag before we drop the lock. 34256714d8e8SKurt Hackel * this is how we ensure that migration can proceed with no 34266714d8e8SKurt Hackel * asts in progress. note that it is ok if the state of the 34276714d8e8SKurt Hackel * queues is such that a lock should be granted in the future 34286714d8e8SKurt Hackel * or that a bast should be fired, because the new master will 34296714d8e8SKurt Hackel * shuffle the lists on this lockres as soon as it is migrated. 34306714d8e8SKurt Hackel */ 34316714d8e8SKurt Hackel void dlm_lockres_release_ast(struct dlm_ctxt *dlm, 34326714d8e8SKurt Hackel struct dlm_lock_resource *res) 34336714d8e8SKurt Hackel { 34346714d8e8SKurt Hackel if (!atomic_dec_and_lock(&res->asts_reserved, &res->spinlock)) 34356714d8e8SKurt Hackel return; 34366714d8e8SKurt Hackel 34376714d8e8SKurt Hackel if (!res->migration_pending) { 34386714d8e8SKurt Hackel spin_unlock(&res->spinlock); 34396714d8e8SKurt Hackel return; 34406714d8e8SKurt Hackel } 34416714d8e8SKurt Hackel 34426714d8e8SKurt Hackel BUG_ON(res->state & DLM_LOCK_RES_MIGRATING); 34436714d8e8SKurt Hackel res->migration_pending = 0; 34446714d8e8SKurt Hackel res->state |= DLM_LOCK_RES_MIGRATING; 34456714d8e8SKurt Hackel spin_unlock(&res->spinlock); 34466714d8e8SKurt Hackel wake_up(&res->wq); 34476714d8e8SKurt Hackel wake_up(&dlm->migration_wq); 34486714d8e8SKurt Hackel } 34495dad6c39SSrinivas Eeda 34505dad6c39SSrinivas Eeda void dlm_force_free_mles(struct dlm_ctxt *dlm) 34515dad6c39SSrinivas Eeda { 34525dad6c39SSrinivas Eeda int i; 34535dad6c39SSrinivas Eeda struct hlist_head *bucket; 34545dad6c39SSrinivas Eeda struct dlm_master_list_entry *mle; 34555dad6c39SSrinivas Eeda struct hlist_node *tmp, *list; 34565dad6c39SSrinivas Eeda 34575dad6c39SSrinivas Eeda /* 34585dad6c39SSrinivas Eeda * We notified all other nodes that we are exiting the domain and 34595dad6c39SSrinivas Eeda * marked the dlm state to DLM_CTXT_LEAVING. If any mles are still 34605dad6c39SSrinivas Eeda * around we force free them and wake any processes that are waiting 34615dad6c39SSrinivas Eeda * on the mles 34625dad6c39SSrinivas Eeda */ 34635dad6c39SSrinivas Eeda spin_lock(&dlm->spinlock); 34645dad6c39SSrinivas Eeda spin_lock(&dlm->master_lock); 34655dad6c39SSrinivas Eeda 34665dad6c39SSrinivas Eeda BUG_ON(dlm->dlm_state != DLM_CTXT_LEAVING); 34675dad6c39SSrinivas Eeda BUG_ON((find_next_bit(dlm->domain_map, O2NM_MAX_NODES, 0) < O2NM_MAX_NODES)); 34685dad6c39SSrinivas Eeda 34695dad6c39SSrinivas Eeda for (i = 0; i < DLM_HASH_BUCKETS; i++) { 34705dad6c39SSrinivas Eeda bucket = dlm_master_hash(dlm, i); 34715dad6c39SSrinivas Eeda hlist_for_each_safe(list, tmp, bucket) { 34725dad6c39SSrinivas Eeda mle = hlist_entry(list, struct dlm_master_list_entry, 34735dad6c39SSrinivas Eeda master_hash_node); 34745dad6c39SSrinivas Eeda if (mle->type != DLM_MLE_BLOCK) { 34755dad6c39SSrinivas Eeda mlog(ML_ERROR, "bad mle: %p\n", mle); 34765dad6c39SSrinivas Eeda dlm_print_one_mle(mle); 34775dad6c39SSrinivas Eeda } 34785dad6c39SSrinivas Eeda atomic_set(&mle->woken, 1); 34795dad6c39SSrinivas Eeda wake_up(&mle->wq); 34805dad6c39SSrinivas Eeda 34815dad6c39SSrinivas Eeda __dlm_unlink_mle(dlm, mle); 34825dad6c39SSrinivas Eeda __dlm_mle_detach_hb_events(dlm, mle); 34835dad6c39SSrinivas Eeda __dlm_put_mle(mle); 34845dad6c39SSrinivas Eeda } 34855dad6c39SSrinivas Eeda } 34865dad6c39SSrinivas Eeda spin_unlock(&dlm->master_lock); 34875dad6c39SSrinivas Eeda spin_unlock(&dlm->spinlock); 34885dad6c39SSrinivas Eeda } 3489