Lines Matching refs:dlm
145 static void dlm_unregister_domain_handlers(struct dlm_ctxt *dlm);
147 void __dlm_unhash_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
152 mlog(0, "%s: Unhash res %.*s\n", dlm->name, res->lockname.len,
158 void __dlm_insert_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res)
162 assert_spin_locked(&dlm->spinlock);
164 bucket = dlm_lockres_hash(dlm, res->lockname.hash);
171 mlog(0, "%s: Hash res %.*s\n", dlm->name, res->lockname.len,
175 struct dlm_lock_resource * __dlm_lookup_lockres_full(struct dlm_ctxt *dlm,
185 assert_spin_locked(&dlm->spinlock);
187 bucket = dlm_lockres_hash(dlm, hash);
208 struct dlm_lock_resource * __dlm_lookup_lockres(struct dlm_ctxt *dlm,
217 assert_spin_locked(&dlm->spinlock);
219 res = __dlm_lookup_lockres_full(dlm, name, len, hash);
233 struct dlm_lock_resource * dlm_lookup_lockres(struct dlm_ctxt *dlm,
240 spin_lock(&dlm->spinlock);
241 res = __dlm_lookup_lockres(dlm, name, len, hash);
242 spin_unlock(&dlm->spinlock);
292 static void dlm_free_ctxt_mem(struct dlm_ctxt *dlm)
294 dlm_destroy_debugfs_subroot(dlm);
296 if (dlm->lockres_hash)
297 dlm_free_pagevec((void **)dlm->lockres_hash, DLM_HASH_PAGES);
299 if (dlm->master_hash)
300 dlm_free_pagevec((void **)dlm->master_hash, DLM_HASH_PAGES);
302 kfree(dlm->name);
303 kfree(dlm);
311 struct dlm_ctxt *dlm;
313 dlm = container_of(kref, struct dlm_ctxt, dlm_refs);
315 BUG_ON(dlm->num_joins);
316 BUG_ON(dlm->dlm_state == DLM_CTXT_JOINED);
319 list_del_init(&dlm->list);
323 mlog(0, "freeing memory from domain %s\n", dlm->name);
327 dlm_free_ctxt_mem(dlm);
332 void dlm_put(struct dlm_ctxt *dlm)
335 kref_put(&dlm->dlm_refs, dlm_ctxt_release);
339 static void __dlm_get(struct dlm_ctxt *dlm)
341 kref_get(&dlm->dlm_refs);
344 /* given a questionable reference to a dlm object, gets a reference if
347 struct dlm_ctxt *dlm_grab(struct dlm_ctxt *dlm)
355 if (target == dlm) {
367 int dlm_domain_fully_joined(struct dlm_ctxt *dlm)
372 ret = (dlm->dlm_state == DLM_CTXT_JOINED) ||
373 (dlm->dlm_state == DLM_CTXT_IN_SHUTDOWN);
379 static void dlm_destroy_dlm_worker(struct dlm_ctxt *dlm)
381 if (dlm->dlm_worker) {
382 destroy_workqueue(dlm->dlm_worker);
383 dlm->dlm_worker = NULL;
387 static void dlm_complete_dlm_shutdown(struct dlm_ctxt *dlm)
389 dlm_unregister_domain_handlers(dlm);
390 dlm_complete_thread(dlm);
391 dlm_complete_recovery_thread(dlm);
392 dlm_destroy_dlm_worker(dlm);
398 list_del_init(&dlm->list);
405 static int dlm_migrate_all_locks(struct dlm_ctxt *dlm)
413 mlog(0, "Migrating locks from domain %s\n", dlm->name);
416 spin_lock(&dlm->spinlock);
420 bucket = dlm_lockres_hash(dlm, i);
427 /* migrate, if necessary. this will drop the dlm
429 dropped = dlm_empty_lockres(dlm, res);
433 __dlm_lockres_calc_usage(dlm, res);
441 cond_resched_lock(&dlm->spinlock);
445 cond_resched_lock(&dlm->spinlock);
450 if (dlm->reco.state & DLM_RECO_STATE_ACTIVE) {
452 "need to be migrated after dlm recovery\n", dlm->name);
455 mlog(0, "%s: we won't do dlm recovery after migrating "
456 "all lock resources\n", dlm->name);
457 dlm->migrate_done = 1;
461 spin_unlock(&dlm->spinlock);
462 wake_up(&dlm->dlm_thread_wq);
464 /* let the dlm thread take care of purging, keep scanning until
468 dlm->name, num);
471 mlog(0, "DONE Migrating locks from domain %s\n", dlm->name);
475 static int dlm_no_joining_node(struct dlm_ctxt *dlm)
479 spin_lock(&dlm->spinlock);
480 ret = dlm->joining_node == DLM_LOCK_RES_OWNER_UNKNOWN;
481 spin_unlock(&dlm->spinlock);
489 struct dlm_ctxt *dlm = data;
493 if (!dlm_grab(dlm))
497 mlog(0, "%s: Node %u sent a begin exit domain message\n", dlm->name, node);
499 spin_lock(&dlm->spinlock);
500 set_bit(node, dlm->exit_domain_map);
501 spin_unlock(&dlm->spinlock);
503 dlm_put(dlm);
508 static void dlm_mark_domain_leaving(struct dlm_ctxt *dlm)
510 /* Yikes, a double spinlock! I need domain_lock for the dlm
511 * state and the dlm spinlock for join state... Sorry! */
514 spin_lock(&dlm->spinlock);
516 if (dlm->joining_node != DLM_LOCK_RES_OWNER_UNKNOWN) {
518 dlm->joining_node);
519 spin_unlock(&dlm->spinlock);
522 wait_event(dlm->dlm_join_events, dlm_no_joining_node(dlm));
526 dlm->dlm_state = DLM_CTXT_LEAVING;
527 spin_unlock(&dlm->spinlock);
531 static void __dlm_print_nodes(struct dlm_ctxt *dlm)
535 assert_spin_locked(&dlm->spinlock);
538 while ((node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES,
549 struct dlm_ctxt *dlm = data;
555 if (!dlm_grab(dlm))
560 spin_lock(&dlm->spinlock);
561 clear_bit(node, dlm->domain_map);
562 clear_bit(node, dlm->exit_domain_map);
563 printk(KERN_NOTICE "o2dlm: Node %u leaves domain %s ", node, dlm->name);
564 __dlm_print_nodes(dlm);
567 dlm_hb_event_notify_attached(dlm, node, 0);
569 spin_unlock(&dlm->spinlock);
571 dlm_put(dlm);
576 static int dlm_send_one_domain_exit(struct dlm_ctxt *dlm, u32 msg_type,
582 mlog(0, "%s: Sending domain exit message %u to node %u\n", dlm->name,
586 leave_msg.node_idx = dlm->node_num;
588 status = o2net_send_message(msg_type, dlm->key, &leave_msg,
593 dlm->name);
598 static void dlm_begin_exit_domain(struct dlm_ctxt *dlm)
603 if (dlm->dlm_locking_proto.pv_major == 1 &&
604 dlm->dlm_locking_proto.pv_minor < 2)
612 spin_lock(&dlm->spinlock);
614 node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES, node + 1);
617 if (node == dlm->node_num)
620 spin_unlock(&dlm->spinlock);
621 dlm_send_one_domain_exit(dlm, DLM_BEGIN_EXIT_DOMAIN_MSG, node);
622 spin_lock(&dlm->spinlock);
624 spin_unlock(&dlm->spinlock);
627 static void dlm_leave_domain(struct dlm_ctxt *dlm)
632 * accept mastership of new ones. The dlm is responsible for
636 spin_lock(&dlm->spinlock);
638 clear_bit(dlm->node_num, dlm->domain_map);
639 while ((node = find_next_bit(dlm->domain_map, O2NM_MAX_NODES,
641 /* Drop the dlm spinlock. This is safe wrt the domain_map.
647 spin_unlock(&dlm->spinlock);
651 status = dlm_send_one_domain_exit(dlm, DLM_EXIT_DOMAIN_MSG,
666 spin_lock(&dlm->spinlock);
670 clear_bit(node, dlm->domain_map);
672 spin_unlock(&dlm->spinlock);
675 void dlm_unregister_domain(struct dlm_ctxt *dlm)
681 BUG_ON(dlm->dlm_state != DLM_CTXT_JOINED);
682 BUG_ON(!dlm->num_joins);
684 dlm->num_joins--;
685 if (!dlm->num_joins) {
692 dlm->dlm_state = DLM_CTXT_IN_SHUTDOWN;
698 mlog(0, "shutting down domain %s\n", dlm->name);
699 dlm_begin_exit_domain(dlm);
701 /* We changed dlm state, notify the thread */
702 dlm_kick_thread(dlm, NULL);
704 while (dlm_migrate_all_locks(dlm)) {
707 mlog(0, "%s: more migration to do\n", dlm->name);
711 if (!list_empty(&dlm->tracking_list)) {
714 list_for_each_entry(res, &dlm->tracking_list, tracking)
718 dlm_mark_domain_leaving(dlm);
719 dlm_leave_domain(dlm);
720 printk(KERN_NOTICE "o2dlm: Leaving domain %s\n", dlm->name);
721 dlm_force_free_mles(dlm);
722 dlm_complete_dlm_shutdown(dlm);
724 dlm_put(dlm);
798 struct dlm_ctxt *dlm = NULL;
823 dlm = __dlm_lookup_domain_full(query->domain, query->name_len);
824 if (!dlm)
834 if (test_bit(nodenum, dlm->domain_map)) {
846 /* Once the dlm ctxt is marked as leaving then we don't want
850 if (dlm->dlm_state != DLM_CTXT_LEAVING) {
852 spin_lock(&dlm->spinlock);
854 if (dlm->dlm_state == DLM_CTXT_NEW &&
855 dlm->joining_node == DLM_LOCK_RES_OWNER_UNKNOWN) {
860 } else if (dlm->joining_node != DLM_LOCK_RES_OWNER_UNKNOWN) {
863 } else if (dlm->reco.state & DLM_RECO_STATE_ACTIVE) {
867 } else if (test_bit(bit, dlm->recovery_map)) {
871 } else if (test_bit(bit, dlm->domain_map)) {
884 &dlm->dlm_locking_proto,
888 &dlm->fs_locking_proto,
895 __dlm_set_joining_node(dlm, query->node_idx);
899 spin_unlock(&dlm->spinlock);
915 struct dlm_ctxt *dlm = NULL;
923 dlm = __dlm_lookup_domain_full(assert->domain, assert->name_len);
924 /* XXX should we consider no dlm ctxt an error? */
925 if (dlm) {
926 spin_lock(&dlm->spinlock);
931 BUG_ON(dlm->joining_node != assert->node_idx);
933 if (dlm->reco.state & DLM_RECO_STATE_ACTIVE) {
934 mlog(0, "dlm recovery is ongoing, disallow join\n");
935 spin_unlock(&dlm->spinlock);
940 set_bit(assert->node_idx, dlm->domain_map);
941 clear_bit(assert->node_idx, dlm->exit_domain_map);
942 __dlm_set_joining_node(dlm, DLM_LOCK_RES_OWNER_UNKNOWN);
945 assert->node_idx, dlm->name);
946 __dlm_print_nodes(dlm);
949 dlm_hb_event_notify_attached(dlm, assert->node_idx, 1);
951 spin_unlock(&dlm->spinlock);
958 static int dlm_match_regions(struct dlm_ctxt *dlm,
971 qr->qr_domain, qr->qr_node, dlm->node_num);
980 qr->qr_domain, dlm->node_num, qr->qr_node);
1011 dlm->node_num, qr->qr_node);
1034 qr->qr_node, dlm->node_num);
1044 static int dlm_send_regions(struct dlm_ctxt *dlm, unsigned long *node_map)
1060 qr->qr_node = dlm->node_num;
1061 qr->qr_namelen = strlen(dlm->name);
1062 memcpy(qr->qr_domain, dlm->name, qr->qr_namelen);
1075 if (i == dlm->node_num)
1101 struct dlm_ctxt *dlm = NULL;
1118 dlm = __dlm_lookup_domain_full(qr->qr_domain, qr->qr_namelen);
1119 if (!dlm) {
1125 spin_lock(&dlm->spinlock);
1126 if (dlm->joining_node != qr->qr_node) {
1129 dlm->joining_node);
1134 if (dlm->dlm_locking_proto.pv_major == 1 &&
1135 dlm->dlm_locking_proto.pv_minor == 0) {
1137 "but active dlm protocol is %d.%d\n", qr->qr_node,
1138 qr->qr_domain, dlm->dlm_locking_proto.pv_major,
1139 dlm->dlm_locking_proto.pv_minor);
1143 status = dlm_match_regions(dlm, qr, local, sizeof(qr->qr_regions));
1146 spin_unlock(&dlm->spinlock);
1156 static int dlm_match_nodes(struct dlm_ctxt *dlm, struct dlm_query_nodeinfo *qn)
1198 qn->qn_nodenum, dlm->node_num);
1205 dlm->node_num, qn->qn_nodenum);
1216 static int dlm_send_nodeinfo(struct dlm_ctxt *dlm, unsigned long *node_map)
1245 qn->qn_nodenum = dlm->node_num;
1247 qn->qn_namelen = strlen(dlm->name);
1248 memcpy(qn->qn_domain, dlm->name, qn->qn_namelen);
1253 if (i == dlm->node_num)
1278 struct dlm_ctxt *dlm = NULL;
1287 dlm = __dlm_lookup_domain_full(qn->qn_domain, qn->qn_namelen);
1288 if (!dlm) {
1294 spin_lock(&dlm->spinlock);
1296 if (dlm->joining_node != qn->qn_nodenum) {
1299 dlm->joining_node);
1304 if (dlm->dlm_locking_proto.pv_major == 1 &&
1305 dlm->dlm_locking_proto.pv_minor == 0) {
1307 "but active dlm protocol is %d.%d\n", qn->qn_nodenum,
1308 qn->qn_domain, dlm->dlm_locking_proto.pv_major,
1309 dlm->dlm_locking_proto.pv_minor);
1313 status = dlm_match_nodes(dlm, qn);
1317 spin_unlock(&dlm->spinlock);
1327 struct dlm_ctxt *dlm = NULL;
1335 dlm = __dlm_lookup_domain_full(cancel->domain, cancel->name_len);
1337 if (dlm) {
1338 spin_lock(&dlm->spinlock);
1342 BUG_ON(dlm->joining_node != cancel->node_idx);
1343 __dlm_set_joining_node(dlm, DLM_LOCK_RES_OWNER_UNKNOWN);
1345 spin_unlock(&dlm->spinlock);
1352 static int dlm_send_one_join_cancel(struct dlm_ctxt *dlm,
1359 cancel_msg.node_idx = dlm->node_num;
1360 cancel_msg.name_len = strlen(dlm->name);
1361 memcpy(cancel_msg.domain, dlm->name, cancel_msg.name_len);
1378 static int dlm_send_join_cancels(struct dlm_ctxt *dlm,
1397 if (node == dlm->node_num)
1400 tmpstat = dlm_send_one_join_cancel(dlm, node);
1414 static int dlm_request_join(struct dlm_ctxt *dlm,
1426 join_msg.node_idx = dlm->node_num;
1427 join_msg.name_len = strlen(dlm->name);
1428 memcpy(join_msg.domain, dlm->name, join_msg.name_len);
1429 join_msg.dlm_proto = dlm->dlm_locking_proto;
1430 join_msg.fs_proto = dlm->fs_locking_proto;
1433 byte_copymap(join_msg.node_map, dlm->live_nodes_map, O2NM_MAX_NODES);
1447 his dlm isn't up, so we can consider him a 'yes' but not
1464 dlm->dlm_locking_proto.pv_major,
1465 dlm->dlm_locking_proto.pv_minor,
1466 dlm->fs_locking_proto.pv_major,
1467 dlm->fs_locking_proto.pv_minor,
1473 dlm->dlm_locking_proto.pv_minor = packet.dlm_minor;
1474 dlm->fs_locking_proto.pv_minor = packet.fs_minor;
1479 dlm->dlm_locking_proto.pv_major,
1480 dlm->dlm_locking_proto.pv_minor,
1481 dlm->fs_locking_proto.pv_major,
1482 dlm->fs_locking_proto.pv_minor);
1501 static int dlm_send_one_join_assert(struct dlm_ctxt *dlm,
1511 assert_msg.node_idx = dlm->node_num;
1512 assert_msg.name_len = strlen(dlm->name);
1513 memcpy(assert_msg.domain, dlm->name, assert_msg.name_len);
1528 static void dlm_send_join_asserts(struct dlm_ctxt *dlm,
1537 if (node == dlm->node_num)
1544 status = dlm_send_one_join_assert(dlm, node);
1546 spin_lock(&dlm->spinlock);
1547 live = test_bit(node, dlm->live_nodes_map);
1548 spin_unlock(&dlm->spinlock);
1567 static int dlm_should_restart_join(struct dlm_ctxt *dlm,
1578 spin_lock(&dlm->spinlock);
1581 ret = memcmp(ctxt->live_map, dlm->live_nodes_map,
1582 sizeof(dlm->live_nodes_map));
1583 spin_unlock(&dlm->spinlock);
1591 static int dlm_try_to_join_domain(struct dlm_ctxt *dlm)
1597 mlog(0, "%p", dlm);
1609 o2hb_fill_node_map(dlm->live_nodes_map, sizeof(dlm->live_nodes_map));
1611 spin_lock(&dlm->spinlock);
1612 memcpy(ctxt->live_map, dlm->live_nodes_map, sizeof(ctxt->live_map));
1614 __dlm_set_joining_node(dlm, dlm->node_num);
1616 spin_unlock(&dlm->spinlock);
1621 if (node == dlm->node_num)
1624 status = dlm_request_join(dlm, node, &response);
1631 * dlm up. */
1635 if (dlm_should_restart_join(dlm, ctxt, response)) {
1647 spin_lock(&dlm->spinlock);
1648 memcpy(dlm->domain_map, ctxt->yes_resp_map,
1650 set_bit(dlm->node_num, dlm->domain_map);
1651 spin_unlock(&dlm->spinlock);
1654 if (dlm->dlm_locking_proto.pv_major > 1 ||
1655 dlm->dlm_locking_proto.pv_minor > 0) {
1656 status = dlm_send_nodeinfo(dlm, ctxt->yes_resp_map);
1661 status = dlm_send_regions(dlm, ctxt->yes_resp_map);
1668 dlm_send_join_asserts(dlm, ctxt->yes_resp_map);
1675 dlm->dlm_state = DLM_CTXT_JOINED;
1676 dlm->num_joins++;
1680 spin_lock(&dlm->spinlock);
1681 __dlm_set_joining_node(dlm, DLM_LOCK_RES_OWNER_UNKNOWN);
1683 printk(KERN_NOTICE "o2dlm: Joining domain %s ", dlm->name);
1684 __dlm_print_nodes(dlm);
1686 spin_unlock(&dlm->spinlock);
1691 tmpstat = dlm_send_join_cancels(dlm,
1704 static void dlm_unregister_domain_handlers(struct dlm_ctxt *dlm)
1706 o2hb_unregister_callback(dlm->name, &dlm->dlm_hb_up);
1707 o2hb_unregister_callback(dlm->name, &dlm->dlm_hb_down);
1708 o2net_unregister_handler_list(&dlm->dlm_domain_handlers);
1711 static int dlm_register_domain_handlers(struct dlm_ctxt *dlm)
1717 o2hb_setup_callback(&dlm->dlm_hb_down, O2HB_NODE_DOWN_CB,
1718 dlm_hb_node_down_cb, dlm, DLM_HB_NODE_DOWN_PRI);
1719 o2hb_setup_callback(&dlm->dlm_hb_up, O2HB_NODE_UP_CB,
1720 dlm_hb_node_up_cb, dlm, DLM_HB_NODE_UP_PRI);
1722 status = o2hb_register_callback(dlm->name, &dlm->dlm_hb_down);
1726 status = o2hb_register_callback(dlm->name, &dlm->dlm_hb_up);
1730 status = o2net_register_handler(DLM_MASTER_REQUEST_MSG, dlm->key,
1733 dlm, NULL, &dlm->dlm_domain_handlers);
1737 status = o2net_register_handler(DLM_ASSERT_MASTER_MSG, dlm->key,
1740 dlm, dlm_assert_master_post_handler,
1741 &dlm->dlm_domain_handlers);
1745 status = o2net_register_handler(DLM_CREATE_LOCK_MSG, dlm->key,
1748 dlm, NULL, &dlm->dlm_domain_handlers);
1752 status = o2net_register_handler(DLM_CONVERT_LOCK_MSG, dlm->key,
1755 dlm, NULL, &dlm->dlm_domain_handlers);
1759 status = o2net_register_handler(DLM_UNLOCK_LOCK_MSG, dlm->key,
1762 dlm, NULL, &dlm->dlm_domain_handlers);
1766 status = o2net_register_handler(DLM_PROXY_AST_MSG, dlm->key,
1769 dlm, NULL, &dlm->dlm_domain_handlers);
1773 status = o2net_register_handler(DLM_EXIT_DOMAIN_MSG, dlm->key,
1776 dlm, NULL, &dlm->dlm_domain_handlers);
1780 status = o2net_register_handler(DLM_DEREF_LOCKRES_MSG, dlm->key,
1783 dlm, NULL, &dlm->dlm_domain_handlers);
1787 status = o2net_register_handler(DLM_MIGRATE_REQUEST_MSG, dlm->key,
1790 dlm, NULL, &dlm->dlm_domain_handlers);
1794 status = o2net_register_handler(DLM_MIG_LOCKRES_MSG, dlm->key,
1797 dlm, NULL, &dlm->dlm_domain_handlers);
1801 status = o2net_register_handler(DLM_MASTER_REQUERY_MSG, dlm->key,
1804 dlm, NULL, &dlm->dlm_domain_handlers);
1808 status = o2net_register_handler(DLM_LOCK_REQUEST_MSG, dlm->key,
1811 dlm, NULL, &dlm->dlm_domain_handlers);
1815 status = o2net_register_handler(DLM_RECO_DATA_DONE_MSG, dlm->key,
1818 dlm, NULL, &dlm->dlm_domain_handlers);
1822 status = o2net_register_handler(DLM_BEGIN_RECO_MSG, dlm->key,
1825 dlm, NULL, &dlm->dlm_domain_handlers);
1829 status = o2net_register_handler(DLM_FINALIZE_RECO_MSG, dlm->key,
1832 dlm, NULL, &dlm->dlm_domain_handlers);
1836 status = o2net_register_handler(DLM_BEGIN_EXIT_DOMAIN_MSG, dlm->key,
1839 dlm, NULL, &dlm->dlm_domain_handlers);
1843 status = o2net_register_handler(DLM_DEREF_LOCKRES_DONE, dlm->key,
1846 dlm, NULL, &dlm->dlm_domain_handlers);
1849 dlm_unregister_domain_handlers(dlm);
1854 static int dlm_join_domain(struct dlm_ctxt *dlm)
1861 BUG_ON(!dlm);
1863 mlog(0, "Join domain %s\n", dlm->name);
1865 status = dlm_register_domain_handlers(dlm);
1871 status = dlm_launch_thread(dlm);
1877 status = dlm_launch_recovery_thread(dlm);
1883 dlm_debug_init(dlm);
1885 snprintf(wq_name, O2NM_MAX_NAME_LEN, "dlm_wq-%s", dlm->name);
1886 dlm->dlm_worker = alloc_workqueue(wq_name, WQ_MEM_RECLAIM, 0);
1887 if (!dlm->dlm_worker) {
1894 status = dlm_try_to_join_domain(dlm);
1908 mlog(ML_NOTICE, "Timed out joining dlm domain "
1909 "%s after %u msecs\n", dlm->name,
1939 dlm_unregister_domain_handlers(dlm);
1940 dlm_complete_thread(dlm);
1941 dlm_complete_recovery_thread(dlm);
1942 dlm_destroy_dlm_worker(dlm);
1953 struct dlm_ctxt *dlm = NULL;
1955 dlm = kzalloc(sizeof(*dlm), GFP_KERNEL);
1956 if (!dlm) {
1962 dlm->name = kstrdup(domain, GFP_KERNEL);
1963 if (dlm->name == NULL) {
1969 dlm->lockres_hash = (struct hlist_head **)dlm_alloc_pagevec(DLM_HASH_PAGES);
1970 if (!dlm->lockres_hash) {
1977 INIT_HLIST_HEAD(dlm_lockres_hash(dlm, i));
1979 dlm->master_hash = (struct hlist_head **)
1981 if (!dlm->master_hash) {
1988 INIT_HLIST_HEAD(dlm_master_hash(dlm, i));
1990 dlm->key = key;
1991 dlm->node_num = o2nm_this_node();
1993 dlm_create_debugfs_subroot(dlm);
1995 spin_lock_init(&dlm->spinlock);
1996 spin_lock_init(&dlm->master_lock);
1997 spin_lock_init(&dlm->ast_lock);
1998 spin_lock_init(&dlm->track_lock);
1999 INIT_LIST_HEAD(&dlm->list);
2000 INIT_LIST_HEAD(&dlm->dirty_list);
2001 INIT_LIST_HEAD(&dlm->reco.resources);
2002 INIT_LIST_HEAD(&dlm->reco.node_data);
2003 INIT_LIST_HEAD(&dlm->purge_list);
2004 INIT_LIST_HEAD(&dlm->dlm_domain_handlers);
2005 INIT_LIST_HEAD(&dlm->tracking_list);
2006 dlm->reco.state = 0;
2008 INIT_LIST_HEAD(&dlm->pending_asts);
2009 INIT_LIST_HEAD(&dlm->pending_basts);
2011 mlog(0, "dlm->recovery_map=%p, &(dlm->recovery_map[0])=%p\n",
2012 dlm->recovery_map, &(dlm->recovery_map[0]));
2014 memset(dlm->recovery_map, 0, sizeof(dlm->recovery_map));
2015 memset(dlm->live_nodes_map, 0, sizeof(dlm->live_nodes_map));
2016 memset(dlm->domain_map, 0, sizeof(dlm->domain_map));
2018 dlm->dlm_thread_task = NULL;
2019 dlm->dlm_reco_thread_task = NULL;
2020 dlm->dlm_worker = NULL;
2021 init_waitqueue_head(&dlm->dlm_thread_wq);
2022 init_waitqueue_head(&dlm->dlm_reco_thread_wq);
2023 init_waitqueue_head(&dlm->reco.event);
2024 init_waitqueue_head(&dlm->ast_wq);
2025 init_waitqueue_head(&dlm->migration_wq);
2026 INIT_LIST_HEAD(&dlm->mle_hb_events);
2028 dlm->joining_node = DLM_LOCK_RES_OWNER_UNKNOWN;
2029 init_waitqueue_head(&dlm->dlm_join_events);
2031 dlm->migrate_done = 0;
2033 dlm->reco.new_master = O2NM_INVALID_NODE_NUM;
2034 dlm->reco.dead_node = O2NM_INVALID_NODE_NUM;
2036 atomic_set(&dlm->res_tot_count, 0);
2037 atomic_set(&dlm->res_cur_count, 0);
2039 atomic_set(&dlm->mle_tot_count[i], 0);
2040 atomic_set(&dlm->mle_cur_count[i], 0);
2043 spin_lock_init(&dlm->work_lock);
2044 INIT_LIST_HEAD(&dlm->work_list);
2045 INIT_WORK(&dlm->dispatched_work, dlm_dispatch_work);
2047 kref_init(&dlm->dlm_refs);
2048 dlm->dlm_state = DLM_CTXT_NEW;
2050 INIT_LIST_HEAD(&dlm->dlm_eviction_callbacks);
2053 kref_read(&dlm->dlm_refs));
2057 if (ret < 0 && dlm) {
2058 if (dlm->master_hash)
2059 dlm_free_pagevec((void **)dlm->master_hash,
2062 if (dlm->lockres_hash)
2063 dlm_free_pagevec((void **)dlm->lockres_hash,
2066 kfree(dlm->name);
2067 kfree(dlm);
2068 dlm = NULL;
2070 return dlm;
2108 struct dlm_ctxt *dlm = NULL;
2120 dlm = NULL;
2129 dlm = __dlm_lookup_domain(domain);
2130 if (dlm) {
2131 if (dlm->dlm_state != DLM_CTXT_JOINED) {
2141 if (dlm_protocol_compare(&dlm->fs_locking_proto, fs_proto)) {
2151 __dlm_get(dlm);
2152 dlm->num_joins++;
2174 dlm = new_ctxt;
2178 list_add_tail(&dlm->list, &dlm_domains);
2185 dlm->dlm_locking_proto = dlm_protocol;
2186 dlm->fs_locking_proto = *fs_proto;
2188 ret = dlm_join_domain(dlm);
2191 dlm_put(dlm);
2196 *fs_proto = dlm->fs_locking_proto;
2204 dlm = ERR_PTR(ret);
2206 return dlm;
2264 * dlm completes it's recovery work, otherwise it may be able to
2265 * acquire locks on resources requiring recovery. Since the dlm can
2274 void dlm_fire_domain_eviction_callbacks(struct dlm_ctxt *dlm,
2280 list_for_each_entry(cb, &dlm->dlm_eviction_callbacks, ec_item) {
2296 void dlm_register_eviction_cb(struct dlm_ctxt *dlm,
2300 list_add_tail(&cb->ec_item, &dlm->dlm_eviction_callbacks);