Lines Matching refs:res
66 struct dlm_lock_resource *res,
93 struct dlm_lock_resource *res,
102 static int dlm_do_master_request(struct dlm_lock_resource *res,
107 struct dlm_lock_resource *res,
111 struct dlm_lock_resource *res,
115 struct dlm_lock_resource *res,
122 struct dlm_lock_resource *res);
124 struct dlm_lock_resource *res);
126 struct dlm_lock_resource *res,
129 struct dlm_lock_resource *res);
268 struct dlm_lock_resource *res,
293 BUG_ON(!res);
294 mle->mleres = res;
295 memcpy(mle->mname, res->lockname.name, res->lockname.len);
296 mle->mnamelen = res->lockname.len;
297 mle->mnamehash = res->lockname.hash;
489 struct dlm_lock_resource *res;
492 res = container_of(kref, struct dlm_lock_resource, refs);
493 dlm = res->dlm;
497 BUG_ON(!res->lockname.name);
499 mlog(0, "destroying lockres %.*s\n", res->lockname.len,
500 res->lockname.name);
503 if (!list_empty(&res->tracking))
504 list_del_init(&res->tracking);
507 res->lockname.len, res->lockname.name);
508 dlm_print_one_lock_resource(res);
514 if (!hlist_unhashed(&res->hash_node) ||
515 !list_empty(&res->granted) ||
516 !list_empty(&res->converting) ||
517 !list_empty(&res->blocked) ||
518 !list_empty(&res->dirty) ||
519 !list_empty(&res->recovering) ||
520 !list_empty(&res->purge)) {
524 res->lockname.len, res->lockname.name,
525 !hlist_unhashed(&res->hash_node) ? 'H' : ' ',
526 !list_empty(&res->granted) ? 'G' : ' ',
527 !list_empty(&res->converting) ? 'C' : ' ',
528 !list_empty(&res->blocked) ? 'B' : ' ',
529 !list_empty(&res->dirty) ? 'D' : ' ',
530 !list_empty(&res->recovering) ? 'R' : ' ',
531 !list_empty(&res->purge) ? 'P' : ' ');
533 dlm_print_one_lock_resource(res);
538 BUG_ON(!hlist_unhashed(&res->hash_node));
539 BUG_ON(!list_empty(&res->granted));
540 BUG_ON(!list_empty(&res->converting));
541 BUG_ON(!list_empty(&res->blocked));
542 BUG_ON(!list_empty(&res->dirty));
543 BUG_ON(!list_empty(&res->recovering));
544 BUG_ON(!list_empty(&res->purge));
546 kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name);
548 kmem_cache_free(dlm_lockres_cache, res);
551 void dlm_lockres_put(struct dlm_lock_resource *res)
553 kref_put(&res->refs, dlm_lockres_release);
557 struct dlm_lock_resource *res,
563 * res->lockname.name, so be sure to init every field
566 qname = (char *) res->lockname.name;
569 res->lockname.len = namelen;
570 res->lockname.hash = dlm_lockid_hash(name, namelen);
572 init_waitqueue_head(&res->wq);
573 spin_lock_init(&res->spinlock);
574 INIT_HLIST_NODE(&res->hash_node);
575 INIT_LIST_HEAD(&res->granted);
576 INIT_LIST_HEAD(&res->converting);
577 INIT_LIST_HEAD(&res->blocked);
578 INIT_LIST_HEAD(&res->dirty);
579 INIT_LIST_HEAD(&res->recovering);
580 INIT_LIST_HEAD(&res->purge);
581 INIT_LIST_HEAD(&res->tracking);
582 atomic_set(&res->asts_reserved, 0);
583 res->migration_pending = 0;
584 res->inflight_locks = 0;
586 res->dlm = dlm;
588 kref_init(&res->refs);
594 spin_lock(&res->spinlock);
595 dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN);
596 spin_unlock(&res->spinlock);
598 res->state = DLM_LOCK_RES_IN_PROGRESS;
600 res->last_used = 0;
603 list_add_tail(&res->tracking, &dlm->tracking_list);
606 memset(res->lvb, 0, DLM_LVB_LEN);
607 memset(res->refmap, 0, sizeof(res->refmap));
614 struct dlm_lock_resource *res = NULL;
616 res = kmem_cache_zalloc(dlm_lockres_cache, GFP_NOFS);
617 if (!res)
620 res->lockname.name = kmem_cache_zalloc(dlm_lockname_cache, GFP_NOFS);
621 if (!res->lockname.name)
624 dlm_init_lockres(dlm, res, name, namelen);
625 return res;
628 if (res && res->lockname.name)
629 kmem_cache_free(dlm_lockname_cache, (void *)res->lockname.name);
631 if (res)
632 kmem_cache_free(dlm_lockres_cache, res);
637 struct dlm_lock_resource *res,
643 assert_spin_locked(&res->spinlock);
645 if (!test_bit(dlm->node_num, res->refmap)) {
646 BUG_ON(res->inflight_locks != 0);
647 dlm_lockres_set_refmap_bit(dlm->node_num, res);
649 res->inflight_locks++;
651 dlm->name, res->lockname.len, res->lockname.name,
652 res->inflight_locks);
656 struct dlm_lock_resource *res,
660 assert_spin_locked(&res->spinlock);
662 BUG_ON(res->inflight_locks == 0);
663 res->inflight_locks--;
665 dlm->name, res->lockname.len, res->lockname.name,
666 res->inflight_locks);
667 if (res->inflight_locks == 0)
668 dlm_lockres_clear_refmap_bit(dlm->node_num, res);
669 wake_up(&res->wq);
693 struct dlm_lock_resource *tmpres=NULL, *res=NULL;
744 if (res)
745 dlm_lockres_put(res);
746 res = tmpres;
750 if (!res) {
757 res = dlm_new_lockres(dlm, lockid, namelen);
758 if (!res)
763 mlog(0, "no lockres found, allocated our own: %p\n", res);
768 spin_lock(&res->spinlock);
769 dlm_change_lockres_owner(dlm, res, dlm->node_num);
770 __dlm_insert_lockres(dlm, res);
771 dlm_lockres_grab_inflight_ref(dlm, res);
772 spin_unlock(&res->spinlock);
824 dlm_init_mle(mle, DLM_MLE_MASTER, dlm, res, NULL, 0);
847 __dlm_insert_lockres(dlm, res);
849 dlm_lockres_grab_inflight_ref_new(dlm, res);
871 if (!dlm_pre_master_reco_lockres(dlm, res))
907 ret = dlm_do_master_request(res, mle, nodenum);
926 ret = dlm_wait_for_lock_mastery(dlm, res, mle, &blocked);
931 dlm->name, res->lockname.len,
932 res->lockname.name, blocked);
936 dlm->name, res->lockname.len,
937 res->lockname.name, blocked);
938 dlm_print_one_lock_resource(res);
945 mlog(0, "lockres mastered by %u\n", res->owner);
947 BUG_ON(res->owner == O2NM_MAX_NODES);
956 spin_lock(&res->spinlock);
957 if (res->owner != dlm->node_num && drop_inflight_if_nonlocal)
958 dlm_lockres_drop_inflight_ref(dlm, res);
959 res->state &= ~DLM_LOCK_RES_IN_PROGRESS;
960 spin_unlock(&res->spinlock);
961 wake_up(&res->wq);
968 return res;
975 struct dlm_lock_resource *res,
989 spin_lock(&res->spinlock);
990 if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
992 res->lockname.len, res->lockname.name, res->owner);
993 spin_unlock(&res->spinlock);
996 if (res->owner != dlm->node_num) {
997 ret = dlm_do_master_request(res, mle, res->owner);
1000 mlog(ML_ERROR, "link to %u went down?: %d\n", res->owner, ret);
1008 spin_unlock(&res->spinlock);
1021 dlm->name, res->lockname.len, res->lockname.name);
1022 ret = dlm_restart_lock_mastery(dlm, res, mle, *blocked);
1026 dlm->name, res->lockname.len, res->lockname.name,
1036 "rechecking now\n", dlm->name, res->lockname.len,
1037 res->lockname.name);
1042 "for %s:%.*s\n", dlm->name, res->lockname.len,
1043 res->lockname.name);
1081 res->lockname.len, res->lockname.name);
1087 if (res->owner == O2NM_MAX_NODES) {
1089 res->lockname.len, res->lockname.name);
1092 mlog(0, "done waiting, master is %u\n", res->owner);
1101 res->lockname.len, res->lockname.name, m);
1102 ret = dlm_do_assert_master(dlm, res, mle->vote_map, 0);
1117 spin_lock(&res->spinlock);
1120 dlm_change_lockres_owner(dlm, res, m);
1121 spin_unlock(&res->spinlock);
1187 struct dlm_lock_resource *res,
1234 res->lockname.len,
1235 res->lockname.name,
1250 res->lockname.len,
1251 res->lockname.name);
1253 mle->mleres = res;
1286 static int dlm_do_master_request(struct dlm_lock_resource *res,
1338 "reference\n", dlm->name, res->lockname.len,
1339 res->lockname.name, to);
1374 * res->spinlock
1385 struct dlm_lock_resource *res = NULL;
1413 res = __dlm_lookup_lockres(dlm, name, namelen, hash);
1414 if (res) {
1418 spin_lock(&res->spinlock);
1419 if (res->state & (DLM_LOCK_RES_RECOVERING|
1421 spin_unlock(&res->spinlock);
1422 mlog(0, "returning DLM_MASTER_RESP_ERROR since res is "
1430 if (res->owner == dlm->node_num) {
1433 dlm_lockres_set_refmap_bit(request->node_idx, res);
1434 spin_unlock(&res->spinlock);
1447 } else if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
1448 spin_unlock(&res->spinlock);
1449 // mlog(0, "node %u is the master\n", res->owner);
1459 if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) {
1498 dlm_lockres_set_refmap_bit(request->node_idx, res);
1514 spin_unlock(&res->spinlock);
1591 if (!res) {
1596 dlm->node_num, res->lockname.len, res->lockname.name);
1597 ret = dlm_dispatch_assert_master(dlm, res, 0, request->node_idx,
1602 dlm_lockres_put(res);
1605 if (res)
1606 dlm_lockres_put(res);
1624 struct dlm_lock_resource *res,
1632 const char *lockname = res->lockname.name;
1633 unsigned int namelen = res->lockname.len;
1637 spin_lock(&res->spinlock);
1638 res->state |= DLM_LOCK_RES_SETREF_INPROG;
1639 spin_unlock(&res->spinlock);
1706 spin_lock(&res->spinlock);
1707 dlm_lockres_set_refmap_bit(to, res);
1708 spin_unlock(&res->spinlock);
1715 spin_lock(&res->spinlock);
1716 res->state &= ~DLM_LOCK_RES_SETREF_INPROG;
1717 spin_unlock(&res->spinlock);
1718 wake_up(&res->wq);
1726 * res->spinlock
1738 struct dlm_lock_resource *res = NULL;
1816 res = __dlm_lookup_lockres(dlm, name, namelen, hash);
1817 if (res) {
1818 spin_lock(&res->spinlock);
1819 if (res->state & DLM_LOCK_RES_RECOVERING) {
1825 if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN &&
1826 res->owner != assert->node_idx) {
1829 assert->node_idx, res->owner, namelen,
1831 __dlm_print_one_lock_resource(res);
1835 if (res->owner != DLM_LOCK_RES_OWNER_UNKNOWN) {
1837 if (res->owner == assert->node_idx) {
1846 res->owner, namelen, name);
1849 if (!(res->state & DLM_LOCK_RES_IN_PROGRESS)) {
1870 spin_unlock(&res->spinlock);
1898 if (res) {
1900 spin_lock(&res->spinlock);
1904 res->lockname.len, res->lockname.name,
1906 res->state &= ~DLM_LOCK_RES_MIGRATING;
1908 dlm_change_lockres_owner(dlm, res, mle->new_master);
1909 BUG_ON(res->state & DLM_LOCK_RES_DIRTY);
1911 dlm_change_lockres_owner(dlm, res, mle->master);
1913 spin_unlock(&res->spinlock);
1916 wake_up(&res->wq);
1954 } else if (res) {
1955 if (res->owner != assert->node_idx) {
1958 res->owner, namelen, name);
1965 if (res) {
1966 spin_lock(&res->spinlock);
1967 res->state |= DLM_LOCK_RES_SETREF_INPROG;
1968 spin_unlock(&res->spinlock);
1969 *ret_data = (void *)res;
1994 __dlm_print_one_lock_resource(res);
1995 spin_unlock(&res->spinlock);
1997 *ret_data = (void *)res;
2004 struct dlm_lock_resource *res = (struct dlm_lock_resource *)ret_data;
2007 spin_lock(&res->spinlock);
2008 res->state &= ~DLM_LOCK_RES_SETREF_INPROG;
2009 spin_unlock(&res->spinlock);
2010 wake_up(&res->wq);
2011 dlm_lockres_put(res);
2017 struct dlm_lock_resource *res,
2029 item->u.am.lockres = res; /* already have a ref */
2036 mlog(0, "IGNORE HIGHER: %.*s\n", res->lockname.len,
2037 res->lockname.name);
2051 struct dlm_lock_resource *res;
2059 res = item->u.am.lockres;
2090 spin_lock(&res->spinlock);
2091 if (res->state & DLM_LOCK_RES_MIGRATING) {
2095 spin_unlock(&res->spinlock);
2098 __dlm_lockres_reserve_ast(res);
2099 spin_unlock(&res->spinlock);
2104 res->lockname.len, res->lockname.name, dlm->node_num);
2105 ret = dlm_do_assert_master(dlm, res, nodemap, flags);
2113 dlm_lockres_release_ast(dlm, res);
2116 dlm_lockres_put(res);
2132 struct dlm_lock_resource *res)
2147 ret = dlm_do_master_requery(dlm, res, nodenum, &master);
2181 int dlm_drop_lockres_ref(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
2188 lockname = res->lockname.name;
2189 namelen = res->lockname.len;
2193 dlm->name, namelen, lockname, res->owner);
2200 &deref, sizeof(deref), res->owner, &r);
2204 res->owner);
2209 lockname, res->owner, r);
2210 dlm_print_one_lock_resource(res);
2221 struct dlm_lock_resource *res = NULL;
2250 res = __dlm_lookup_lockres_full(dlm, name, namelen, hash);
2251 if (!res) {
2259 spin_lock(&res->spinlock);
2260 if (res->state & DLM_LOCK_RES_SETREF_INPROG)
2263 BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF);
2264 if (test_bit(node, res->refmap)) {
2265 dlm_lockres_clear_refmap_bit(node, res);
2269 spin_unlock(&res->spinlock);
2273 dlm_lockres_calc_usage(dlm, res);
2277 res->lockname.len, res->lockname.name, node);
2278 dlm_print_one_lock_resource(res);
2292 item->u.dl.deref_res = res;
2303 if (res)
2304 dlm_lockres_put(res);
2313 struct dlm_lock_resource *res;
2318 res = item->u.dl.deref_res;
2321 spin_lock(&res->spinlock);
2322 BUG_ON(res->state & DLM_LOCK_RES_DROPPING_REF);
2323 if (test_bit(node, res->refmap)) {
2324 __dlm_wait_on_lockres_flags(res, DLM_LOCK_RES_SETREF_INPROG);
2325 dlm_lockres_clear_refmap_bit(node, res);
2328 spin_unlock(&res->spinlock);
2332 dlm->name, res->lockname.len, res->lockname.name, node);
2333 dlm_lockres_calc_usage(dlm, res);
2337 res->lockname.len, res->lockname.name, node);
2338 dlm_print_one_lock_resource(res);
2341 dlm_lockres_put(res);
2348 struct dlm_lock_resource *res,
2357 assert_spin_locked(&res->spinlock);
2360 if (res->owner == DLM_LOCK_RES_OWNER_UNKNOWN) {
2365 if (res->owner != dlm->node_num) {
2371 queue = &res->granted;
2401 struct dlm_lock_resource *res,
2417 name = res->lockname.name;
2418 namelen = res->lockname.len;
2425 spin_lock(&res->spinlock);
2426 ret = dlm_is_lockres_migrateable(dlm, res, &numlocks);
2428 spin_unlock(&res->spinlock);
2431 spin_unlock(&res->spinlock);
2467 target = dlm_pick_migration_target(dlm, res);
2489 ret = dlm_add_migration_mle(dlm, res, mle, &oldmle, name,
2504 if (dlm_mark_lockres_migrating(dlm, res, target) < 0) {
2506 "the target went down.\n", res->lockname.len,
2507 res->lockname.name, target);
2508 spin_lock(&res->spinlock);
2509 res->state &= ~DLM_LOCK_RES_MIGRATING;
2511 spin_unlock(&res->spinlock);
2557 ret = dlm_send_one_lockres(dlm, res, mres, target,
2567 spin_lock(&res->spinlock);
2568 res->state &= ~DLM_LOCK_RES_MIGRATING;
2570 spin_unlock(&res->spinlock);
2593 res->owner == target)
2597 dlm->name, res->lockname.len, res->lockname.name);
2603 dlm->name, res->lockname.len,
2604 res->lockname.name, target);
2610 spin_lock(&res->spinlock);
2611 res->state &= ~DLM_LOCK_RES_MIGRATING;
2613 spin_unlock(&res->spinlock);
2618 dlm->name, res->lockname.len, res->lockname.name);
2622 spin_lock(&res->spinlock);
2623 dlm_set_lockres_owner(dlm, res, target);
2624 res->state &= ~DLM_LOCK_RES_MIGRATING;
2625 dlm_remove_nonlocal_locks(dlm, res);
2626 spin_unlock(&res->spinlock);
2627 wake_up(&res->wq);
2634 dlm_lockres_calc_usage(dlm, res);
2639 dlm_kick_thread(dlm, res);
2644 wake_up(&res->wq);
2666 int dlm_empty_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
2672 spin_lock(&res->spinlock);
2673 if (res->owner != dlm->node_num) {
2674 if (!__dlm_lockres_unused(res)) {
2677 dlm->name, res->lockname.len, res->lockname.name);
2679 spin_unlock(&res->spinlock);
2684 ret = dlm_is_lockres_migrateable(dlm, res, &numlocks);
2686 spin_unlock(&res->spinlock);
2689 spin_unlock(&res->spinlock);
2695 ret = dlm_migrate_lockres(dlm, res, O2NM_MAX_NODES);
2700 res->lockname.len, res->lockname.name);
2705 "retrying\n", res->lockname.len,
2706 res->lockname.name);
2726 struct dlm_lock_resource *res,
2730 spin_lock(&res->spinlock);
2731 can_proceed = !!(res->state & DLM_LOCK_RES_MIGRATING);
2732 spin_unlock(&res->spinlock);
2744 struct dlm_lock_resource *res)
2747 spin_lock(&res->spinlock);
2748 ret = !!(res->state & DLM_LOCK_RES_DIRTY);
2749 spin_unlock(&res->spinlock);
2755 struct dlm_lock_resource *res,
2761 res->lockname.len, res->lockname.name, dlm->node_num,
2765 spin_lock(&res->spinlock);
2766 BUG_ON(res->migration_pending);
2767 res->migration_pending = 1;
2770 __dlm_lockres_reserve_ast(res);
2771 spin_unlock(&res->spinlock);
2774 dlm_kick_thread(dlm, res);
2777 spin_lock(&res->spinlock);
2778 BUG_ON(res->state & DLM_LOCK_RES_BLOCK_DIRTY);
2779 res->state |= DLM_LOCK_RES_BLOCK_DIRTY;
2780 spin_unlock(&res->spinlock);
2782 wait_event(dlm->ast_wq, !dlm_lockres_is_dirty(dlm, res));
2783 dlm_lockres_release_ast(dlm, res);
2786 res->state & DLM_LOCK_RES_DIRTY ? "yes" : "no");
2792 dlm_migration_can_proceed(dlm, res, target),
2796 res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no",
2800 res->state & DLM_LOCK_RES_MIGRATING ? "yes":"no",
2803 if (!dlm_migration_can_proceed(dlm, res, target)) {
2823 spin_lock(&res->spinlock);
2824 BUG_ON(!(res->state & DLM_LOCK_RES_BLOCK_DIRTY));
2825 res->state &= ~DLM_LOCK_RES_BLOCK_DIRTY;
2827 BUG_ON(!(res->state & DLM_LOCK_RES_MIGRATING));
2828 spin_unlock(&res->spinlock);
2845 struct dlm_lock_resource *res)
2847 struct list_head *queue = &res->granted;
2851 assert_spin_locked(&res->spinlock);
2853 BUG_ON(res->owner == dlm->node_num);
2865 dlm_lockres_clear_refmap_bit(lock->ml.node, res);
2877 bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
2885 res->lockname.len, res->lockname.name, bit);
2886 dlm_lockres_clear_refmap_bit(bit, res);
2897 struct dlm_lock_resource *res)
2900 struct list_head *queue = &res->granted;
2906 spin_lock(&res->spinlock);
2912 spin_unlock(&res->spinlock);
2918 spin_unlock(&res->spinlock);
2944 struct dlm_lock_resource *res,
2953 migrate.namelen = res->lockname.len;
2954 memcpy(migrate.name, res->lockname.name, migrate.namelen);
2997 dlm->name, res->lockname.len, res->lockname.name,
2999 spin_lock(&res->spinlock);
3000 dlm_lockres_set_refmap_bit(nodenum, res);
3001 spin_unlock(&res->spinlock);
3024 struct dlm_lock_resource *res = NULL;
3048 res = __dlm_lookup_lockres(dlm, name, namelen, hash);
3049 if (res) {
3050 spin_lock(&res->spinlock);
3051 if (res->state & DLM_LOCK_RES_RECOVERING) {
3055 spin_unlock(&res->spinlock);
3062 res->state |= DLM_LOCK_RES_MIGRATING;
3063 spin_unlock(&res->spinlock);
3068 ret = dlm_add_migration_mle(dlm, res, mle, &oldmle,
3083 if (res)
3084 dlm_lockres_put(res);
3098 struct dlm_lock_resource *res,
3155 dlm_init_mle(mle, DLM_MLE_MIGRATION, dlm, res, name, namelen);
3173 struct dlm_lock_resource *res;
3176 res = __dlm_lookup_lockres(dlm, mle->mname, mle->mnamelen,
3178 if (res) {
3182 spin_lock(&res->spinlock);
3183 dlm_set_lockres_owner(dlm, res, DLM_LOCK_RES_OWNER_UNKNOWN);
3184 dlm_move_lockres_to_recovery_list(dlm, res);
3185 spin_unlock(&res->spinlock);
3186 dlm_lockres_put(res);
3197 return res;
3245 struct dlm_lock_resource *res;
3308 res = dlm_reset_mleres_owner(dlm, mle);
3309 if (res)
3320 int dlm_finish_migration(struct dlm_ctxt *dlm, struct dlm_lock_resource *res,
3335 spin_lock(&res->spinlock);
3336 dlm_lockres_set_refmap_bit(old_master, res);
3337 spin_unlock(&res->spinlock);
3340 ret = dlm_do_migrate_request(dlm, res, old_master,
3348 res->lockname.len, res->lockname.name);
3351 ret = dlm_do_assert_master(dlm, res, iter.node_map,
3362 res->lockname.len, res->lockname.name, old_master);
3363 ret = dlm_do_assert_master(dlm, res, iter.node_map,
3374 spin_lock(&res->spinlock);
3375 dlm_set_lockres_owner(dlm, res, dlm->node_num);
3376 res->state &= ~DLM_LOCK_RES_MIGRATING;
3377 spin_unlock(&res->spinlock);
3379 dlm_kick_thread(dlm, res);
3380 wake_up(&res->wq);
3394 void __dlm_lockres_reserve_ast(struct dlm_lock_resource *res)
3396 assert_spin_locked(&res->spinlock);
3397 if (res->state & DLM_LOCK_RES_MIGRATING) {
3398 __dlm_print_one_lock_resource(res);
3400 BUG_ON(res->state & DLM_LOCK_RES_MIGRATING);
3402 atomic_inc(&res->asts_reserved);
3419 struct dlm_lock_resource *res)
3421 if (!atomic_dec_and_lock(&res->asts_reserved, &res->spinlock))
3424 if (!res->migration_pending) {
3425 spin_unlock(&res->spinlock);
3429 BUG_ON(res->state & DLM_LOCK_RES_MIGRATING);
3430 res->migration_pending = 0;
3431 res->state |= DLM_LOCK_RES_MIGRATING;
3432 spin_unlock(&res->spinlock);
3433 wake_up(&res->wq);