1// SPDX-License-Identifier: GPL-2.0-or-later 2/* -*- mode: c; c-basic-offset: 8; -*- 3 * vim: noexpandtab sw=8 ts=8 sts=0: 4 * 5 * Copyright (C) 2004, 2005 Oracle. All rights reserved. 6 */ 7 8#include <linux/slab.h> 9#include <linux/kernel.h> 10#include <linux/module.h> 11#include <linux/configfs.h> 12 13#include "tcp.h" 14#include "nodemanager.h" 15#include "heartbeat.h" 16#include "masklog.h" 17#include "sys.h" 18 19/* for now we operate under the assertion that there can be only one 20 * cluster active at a time. Changing this will require trickling 21 * cluster references throughout where nodes are looked up */ 22struct o2nm_cluster *o2nm_single_cluster = NULL; 23 24static const char *o2nm_fence_method_desc[O2NM_FENCE_METHODS] = { 25 "reset", /* O2NM_FENCE_RESET */ 26 "panic", /* O2NM_FENCE_PANIC */ 27}; 28 29static inline void o2nm_lock_subsystem(void); 30static inline void o2nm_unlock_subsystem(void); 31 32struct o2nm_node *o2nm_get_node_by_num(u8 node_num) 33{ 34 struct o2nm_node *node = NULL; 35 36 if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL) 37 goto out; 38 39 read_lock(&o2nm_single_cluster->cl_nodes_lock); 40 node = o2nm_single_cluster->cl_nodes[node_num]; 41 if (node) 42 config_item_get(&node->nd_item); 43 read_unlock(&o2nm_single_cluster->cl_nodes_lock); 44out: 45 return node; 46} 47EXPORT_SYMBOL_GPL(o2nm_get_node_by_num); 48 49int o2nm_configured_node_map(unsigned long *map, unsigned bytes) 50{ 51 struct o2nm_cluster *cluster = o2nm_single_cluster; 52 53 BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap))); 54 55 if (cluster == NULL) 56 return -EINVAL; 57 58 read_lock(&cluster->cl_nodes_lock); 59 memcpy(map, cluster->cl_nodes_bitmap, sizeof(cluster->cl_nodes_bitmap)); 60 read_unlock(&cluster->cl_nodes_lock); 61 62 return 0; 63} 64EXPORT_SYMBOL_GPL(o2nm_configured_node_map); 65 66static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster, 67 __be32 ip_needle, 68 struct rb_node ***ret_p, 69 struct rb_node **ret_parent) 70{ 71 struct rb_node **p = &cluster->cl_node_ip_tree.rb_node; 72 struct rb_node *parent = NULL; 73 struct o2nm_node *node, *ret = NULL; 74 75 while (*p) { 76 int cmp; 77 78 parent = *p; 79 node = rb_entry(parent, struct o2nm_node, nd_ip_node); 80 81 cmp = memcmp(&ip_needle, &node->nd_ipv4_address, 82 sizeof(ip_needle)); 83 if (cmp < 0) 84 p = &(*p)->rb_left; 85 else if (cmp > 0) 86 p = &(*p)->rb_right; 87 else { 88 ret = node; 89 break; 90 } 91 } 92 93 if (ret_p != NULL) 94 *ret_p = p; 95 if (ret_parent != NULL) 96 *ret_parent = parent; 97 98 return ret; 99} 100 101struct o2nm_node *o2nm_get_node_by_ip(__be32 addr) 102{ 103 struct o2nm_node *node = NULL; 104 struct o2nm_cluster *cluster = o2nm_single_cluster; 105 106 if (cluster == NULL) 107 goto out; 108 109 read_lock(&cluster->cl_nodes_lock); 110 node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL); 111 if (node) 112 config_item_get(&node->nd_item); 113 read_unlock(&cluster->cl_nodes_lock); 114 115out: 116 return node; 117} 118EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip); 119 120void o2nm_node_put(struct o2nm_node *node) 121{ 122 config_item_put(&node->nd_item); 123} 124EXPORT_SYMBOL_GPL(o2nm_node_put); 125 126void o2nm_node_get(struct o2nm_node *node) 127{ 128 config_item_get(&node->nd_item); 129} 130EXPORT_SYMBOL_GPL(o2nm_node_get); 131 132u8 o2nm_this_node(void) 133{ 134 u8 node_num = O2NM_MAX_NODES; 135 136 if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local) 137 node_num = o2nm_single_cluster->cl_local_node; 138 139 return node_num; 140} 141EXPORT_SYMBOL_GPL(o2nm_this_node); 142 143/* node configfs bits */ 144 145static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item) 146{ 147 return item ? 148 container_of(to_config_group(item), struct o2nm_cluster, 149 cl_group) 150 : NULL; 151} 152 153static struct o2nm_node *to_o2nm_node(struct config_item *item) 154{ 155 return item ? container_of(item, struct o2nm_node, nd_item) : NULL; 156} 157 158static void o2nm_node_release(struct config_item *item) 159{ 160 struct o2nm_node *node = to_o2nm_node(item); 161 kfree(node); 162} 163 164static ssize_t o2nm_node_num_show(struct config_item *item, char *page) 165{ 166 return sprintf(page, "%d\n", to_o2nm_node(item)->nd_num); 167} 168 169static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node) 170{ 171 /* through the first node_set .parent 172 * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */ 173 if (node->nd_item.ci_parent) 174 return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent); 175 else 176 return NULL; 177} 178 179enum { 180 O2NM_NODE_ATTR_NUM = 0, 181 O2NM_NODE_ATTR_PORT, 182 O2NM_NODE_ATTR_ADDRESS, 183}; 184 185static ssize_t o2nm_node_num_store(struct config_item *item, const char *page, 186 size_t count) 187{ 188 struct o2nm_node *node = to_o2nm_node(item); 189 struct o2nm_cluster *cluster; 190 unsigned long tmp; 191 char *p = (char *)page; 192 int ret = 0; 193 194 tmp = simple_strtoul(p, &p, 0); 195 if (!p || (*p && (*p != '\n'))) 196 return -EINVAL; 197 198 if (tmp >= O2NM_MAX_NODES) 199 return -ERANGE; 200 201 /* once we're in the cl_nodes tree networking can look us up by 202 * node number and try to use our address and port attributes 203 * to connect to this node.. make sure that they've been set 204 * before writing the node attribute? */ 205 if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) || 206 !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) 207 return -EINVAL; /* XXX */ 208 209 o2nm_lock_subsystem(); 210 cluster = to_o2nm_cluster_from_node(node); 211 if (!cluster) { 212 o2nm_unlock_subsystem(); 213 return -EINVAL; 214 } 215 216 write_lock(&cluster->cl_nodes_lock); 217 if (cluster->cl_nodes[tmp]) 218 ret = -EEXIST; 219 else if (test_and_set_bit(O2NM_NODE_ATTR_NUM, 220 &node->nd_set_attributes)) 221 ret = -EBUSY; 222 else { 223 cluster->cl_nodes[tmp] = node; 224 node->nd_num = tmp; 225 set_bit(tmp, cluster->cl_nodes_bitmap); 226 } 227 write_unlock(&cluster->cl_nodes_lock); 228 o2nm_unlock_subsystem(); 229 230 if (ret) 231 return ret; 232 233 return count; 234} 235static ssize_t o2nm_node_ipv4_port_show(struct config_item *item, char *page) 236{ 237 return sprintf(page, "%u\n", ntohs(to_o2nm_node(item)->nd_ipv4_port)); 238} 239 240static ssize_t o2nm_node_ipv4_port_store(struct config_item *item, 241 const char *page, size_t count) 242{ 243 struct o2nm_node *node = to_o2nm_node(item); 244 unsigned long tmp; 245 char *p = (char *)page; 246 247 tmp = simple_strtoul(p, &p, 0); 248 if (!p || (*p && (*p != '\n'))) 249 return -EINVAL; 250 251 if (tmp == 0) 252 return -EINVAL; 253 if (tmp >= (u16)-1) 254 return -ERANGE; 255 256 if (test_and_set_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) 257 return -EBUSY; 258 node->nd_ipv4_port = htons(tmp); 259 260 return count; 261} 262 263static ssize_t o2nm_node_ipv4_address_show(struct config_item *item, char *page) 264{ 265 return sprintf(page, "%pI4\n", &to_o2nm_node(item)->nd_ipv4_address); 266} 267 268static ssize_t o2nm_node_ipv4_address_store(struct config_item *item, 269 const char *page, 270 size_t count) 271{ 272 struct o2nm_node *node = to_o2nm_node(item); 273 struct o2nm_cluster *cluster; 274 int ret, i; 275 struct rb_node **p, *parent; 276 unsigned int octets[4]; 277 __be32 ipv4_addr = 0; 278 279 ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2], 280 &octets[1], &octets[0]); 281 if (ret != 4) 282 return -EINVAL; 283 284 for (i = 0; i < ARRAY_SIZE(octets); i++) { 285 if (octets[i] > 255) 286 return -ERANGE; 287 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8)); 288 } 289 290 o2nm_lock_subsystem(); 291 cluster = to_o2nm_cluster_from_node(node); 292 if (!cluster) { 293 o2nm_unlock_subsystem(); 294 return -EINVAL; 295 } 296 297 ret = 0; 298 write_lock(&cluster->cl_nodes_lock); 299 if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent)) 300 ret = -EEXIST; 301 else if (test_and_set_bit(O2NM_NODE_ATTR_ADDRESS, 302 &node->nd_set_attributes)) 303 ret = -EBUSY; 304 else { 305 rb_link_node(&node->nd_ip_node, parent, p); 306 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree); 307 } 308 write_unlock(&cluster->cl_nodes_lock); 309 o2nm_unlock_subsystem(); 310 311 if (ret) 312 return ret; 313 314 memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr)); 315 316 return count; 317} 318 319static ssize_t o2nm_node_local_show(struct config_item *item, char *page) 320{ 321 return sprintf(page, "%d\n", to_o2nm_node(item)->nd_local); 322} 323 324static ssize_t o2nm_node_local_store(struct config_item *item, const char *page, 325 size_t count) 326{ 327 struct o2nm_node *node = to_o2nm_node(item); 328 struct o2nm_cluster *cluster; 329 unsigned long tmp; 330 char *p = (char *)page; 331 ssize_t ret; 332 333 tmp = simple_strtoul(p, &p, 0); 334 if (!p || (*p && (*p != '\n'))) 335 return -EINVAL; 336 337 tmp = !!tmp; /* boolean of whether this node wants to be local */ 338 339 /* setting local turns on networking rx for now so we require having 340 * set everything else first */ 341 if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) || 342 !test_bit(O2NM_NODE_ATTR_NUM, &node->nd_set_attributes) || 343 !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) 344 return -EINVAL; /* XXX */ 345 346 o2nm_lock_subsystem(); 347 cluster = to_o2nm_cluster_from_node(node); 348 if (!cluster) { 349 ret = -EINVAL; 350 goto out; 351 } 352 353 /* the only failure case is trying to set a new local node 354 * when a different one is already set */ 355 if (tmp && tmp == cluster->cl_has_local && 356 cluster->cl_local_node != node->nd_num) { 357 ret = -EBUSY; 358 goto out; 359 } 360 361 /* bring up the rx thread if we're setting the new local node. */ 362 if (tmp && !cluster->cl_has_local) { 363 ret = o2net_start_listening(node); 364 if (ret) 365 goto out; 366 } 367 368 if (!tmp && cluster->cl_has_local && 369 cluster->cl_local_node == node->nd_num) { 370 o2net_stop_listening(node); 371 cluster->cl_local_node = O2NM_INVALID_NODE_NUM; 372 } 373 374 node->nd_local = tmp; 375 if (node->nd_local) { 376 cluster->cl_has_local = tmp; 377 cluster->cl_local_node = node->nd_num; 378 } 379 380 ret = count; 381 382out: 383 o2nm_unlock_subsystem(); 384 return ret; 385} 386 387CONFIGFS_ATTR(o2nm_node_, num); 388CONFIGFS_ATTR(o2nm_node_, ipv4_port); 389CONFIGFS_ATTR(o2nm_node_, ipv4_address); 390CONFIGFS_ATTR(o2nm_node_, local); 391 392static struct configfs_attribute *o2nm_node_attrs[] = { 393 &o2nm_node_attr_num, 394 &o2nm_node_attr_ipv4_port, 395 &o2nm_node_attr_ipv4_address, 396 &o2nm_node_attr_local, 397 NULL, 398}; 399 400static struct configfs_item_operations o2nm_node_item_ops = { 401 .release = o2nm_node_release, 402}; 403 404static const struct config_item_type o2nm_node_type = { 405 .ct_item_ops = &o2nm_node_item_ops, 406 .ct_attrs = o2nm_node_attrs, 407 .ct_owner = THIS_MODULE, 408}; 409 410/* node set */ 411 412struct o2nm_node_group { 413 struct config_group ns_group; 414 /* some stuff? */ 415}; 416 417#if 0 418static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group) 419{ 420 return group ? 421 container_of(group, struct o2nm_node_group, ns_group) 422 : NULL; 423} 424#endif 425 426static ssize_t o2nm_cluster_attr_write(const char *page, ssize_t count, 427 unsigned int *val) 428{ 429 unsigned long tmp; 430 char *p = (char *)page; 431 432 tmp = simple_strtoul(p, &p, 0); 433 if (!p || (*p && (*p != '\n'))) 434 return -EINVAL; 435 436 if (tmp == 0) 437 return -EINVAL; 438 if (tmp >= (u32)-1) 439 return -ERANGE; 440 441 *val = tmp; 442 443 return count; 444} 445 446static ssize_t o2nm_cluster_idle_timeout_ms_show(struct config_item *item, 447 char *page) 448{ 449 return sprintf(page, "%u\n", to_o2nm_cluster(item)->cl_idle_timeout_ms); 450} 451 452static ssize_t o2nm_cluster_idle_timeout_ms_store(struct config_item *item, 453 const char *page, size_t count) 454{ 455 struct o2nm_cluster *cluster = to_o2nm_cluster(item); 456 ssize_t ret; 457 unsigned int val; 458 459 ret = o2nm_cluster_attr_write(page, count, &val); 460 461 if (ret > 0) { 462 if (cluster->cl_idle_timeout_ms != val 463 && o2net_num_connected_peers()) { 464 mlog(ML_NOTICE, 465 "o2net: cannot change idle timeout after " 466 "the first peer has agreed to it." 467 " %d connected peers\n", 468 o2net_num_connected_peers()); 469 ret = -EINVAL; 470 } else if (val <= cluster->cl_keepalive_delay_ms) { 471 mlog(ML_NOTICE, "o2net: idle timeout must be larger " 472 "than keepalive delay\n"); 473 ret = -EINVAL; 474 } else { 475 cluster->cl_idle_timeout_ms = val; 476 } 477 } 478 479 return ret; 480} 481 482static ssize_t o2nm_cluster_keepalive_delay_ms_show( 483 struct config_item *item, char *page) 484{ 485 return sprintf(page, "%u\n", 486 to_o2nm_cluster(item)->cl_keepalive_delay_ms); 487} 488 489static ssize_t o2nm_cluster_keepalive_delay_ms_store( 490 struct config_item *item, const char *page, size_t count) 491{ 492 struct o2nm_cluster *cluster = to_o2nm_cluster(item); 493 ssize_t ret; 494 unsigned int val; 495 496 ret = o2nm_cluster_attr_write(page, count, &val); 497 498 if (ret > 0) { 499 if (cluster->cl_keepalive_delay_ms != val 500 && o2net_num_connected_peers()) { 501 mlog(ML_NOTICE, 502 "o2net: cannot change keepalive delay after" 503 " the first peer has agreed to it." 504 " %d connected peers\n", 505 o2net_num_connected_peers()); 506 ret = -EINVAL; 507 } else if (val >= cluster->cl_idle_timeout_ms) { 508 mlog(ML_NOTICE, "o2net: keepalive delay must be " 509 "smaller than idle timeout\n"); 510 ret = -EINVAL; 511 } else { 512 cluster->cl_keepalive_delay_ms = val; 513 } 514 } 515 516 return ret; 517} 518 519static ssize_t o2nm_cluster_reconnect_delay_ms_show( 520 struct config_item *item, char *page) 521{ 522 return sprintf(page, "%u\n", 523 to_o2nm_cluster(item)->cl_reconnect_delay_ms); 524} 525 526static ssize_t o2nm_cluster_reconnect_delay_ms_store( 527 struct config_item *item, const char *page, size_t count) 528{ 529 return o2nm_cluster_attr_write(page, count, 530 &to_o2nm_cluster(item)->cl_reconnect_delay_ms); 531} 532 533static ssize_t o2nm_cluster_fence_method_show( 534 struct config_item *item, char *page) 535{ 536 struct o2nm_cluster *cluster = to_o2nm_cluster(item); 537 ssize_t ret = 0; 538 539 if (cluster) 540 ret = sprintf(page, "%s\n", 541 o2nm_fence_method_desc[cluster->cl_fence_method]); 542 return ret; 543} 544 545static ssize_t o2nm_cluster_fence_method_store( 546 struct config_item *item, const char *page, size_t count) 547{ 548 unsigned int i; 549 550 if (page[count - 1] != '\n') 551 goto bail; 552 553 for (i = 0; i < O2NM_FENCE_METHODS; ++i) { 554 if (count != strlen(o2nm_fence_method_desc[i]) + 1) 555 continue; 556 if (strncasecmp(page, o2nm_fence_method_desc[i], count - 1)) 557 continue; 558 if (to_o2nm_cluster(item)->cl_fence_method != i) { 559 printk(KERN_INFO "ocfs2: Changing fence method to %s\n", 560 o2nm_fence_method_desc[i]); 561 to_o2nm_cluster(item)->cl_fence_method = i; 562 } 563 return count; 564 } 565 566bail: 567 return -EINVAL; 568} 569 570CONFIGFS_ATTR(o2nm_cluster_, idle_timeout_ms); 571CONFIGFS_ATTR(o2nm_cluster_, keepalive_delay_ms); 572CONFIGFS_ATTR(o2nm_cluster_, reconnect_delay_ms); 573CONFIGFS_ATTR(o2nm_cluster_, fence_method); 574 575static struct configfs_attribute *o2nm_cluster_attrs[] = { 576 &o2nm_cluster_attr_idle_timeout_ms, 577 &o2nm_cluster_attr_keepalive_delay_ms, 578 &o2nm_cluster_attr_reconnect_delay_ms, 579 &o2nm_cluster_attr_fence_method, 580 NULL, 581}; 582 583static struct config_item *o2nm_node_group_make_item(struct config_group *group, 584 const char *name) 585{ 586 struct o2nm_node *node = NULL; 587 588 if (strlen(name) > O2NM_MAX_NAME_LEN) 589 return ERR_PTR(-ENAMETOOLONG); 590 591 node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL); 592 if (node == NULL) 593 return ERR_PTR(-ENOMEM); 594 595 strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */ 596 config_item_init_type_name(&node->nd_item, name, &o2nm_node_type); 597 spin_lock_init(&node->nd_lock); 598 599 mlog(ML_CLUSTER, "o2nm: Registering node %s\n", name); 600 601 return &node->nd_item; 602} 603 604static void o2nm_node_group_drop_item(struct config_group *group, 605 struct config_item *item) 606{ 607 struct o2nm_node *node = to_o2nm_node(item); 608 struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent); 609 610 if (cluster->cl_nodes[node->nd_num] == node) { 611 o2net_disconnect_node(node); 612 613 if (cluster->cl_has_local && 614 (cluster->cl_local_node == node->nd_num)) { 615 cluster->cl_has_local = 0; 616 cluster->cl_local_node = O2NM_INVALID_NODE_NUM; 617 o2net_stop_listening(node); 618 } 619 } 620 621 /* XXX call into net to stop this node from trading messages */ 622 623 write_lock(&cluster->cl_nodes_lock); 624 625 /* XXX sloppy */ 626 if (node->nd_ipv4_address) 627 rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree); 628 629 /* nd_num might be 0 if the node number hasn't been set.. */ 630 if (cluster->cl_nodes[node->nd_num] == node) { 631 cluster->cl_nodes[node->nd_num] = NULL; 632 clear_bit(node->nd_num, cluster->cl_nodes_bitmap); 633 } 634 write_unlock(&cluster->cl_nodes_lock); 635 636 mlog(ML_CLUSTER, "o2nm: Unregistered node %s\n", 637 config_item_name(&node->nd_item)); 638 639 config_item_put(item); 640} 641 642static struct configfs_group_operations o2nm_node_group_group_ops = { 643 .make_item = o2nm_node_group_make_item, 644 .drop_item = o2nm_node_group_drop_item, 645}; 646 647static const struct config_item_type o2nm_node_group_type = { 648 .ct_group_ops = &o2nm_node_group_group_ops, 649 .ct_owner = THIS_MODULE, 650}; 651 652/* cluster */ 653 654static void o2nm_cluster_release(struct config_item *item) 655{ 656 struct o2nm_cluster *cluster = to_o2nm_cluster(item); 657 658 kfree(cluster); 659} 660 661static struct configfs_item_operations o2nm_cluster_item_ops = { 662 .release = o2nm_cluster_release, 663}; 664 665static const struct config_item_type o2nm_cluster_type = { 666 .ct_item_ops = &o2nm_cluster_item_ops, 667 .ct_attrs = o2nm_cluster_attrs, 668 .ct_owner = THIS_MODULE, 669}; 670 671/* cluster set */ 672 673struct o2nm_cluster_group { 674 struct configfs_subsystem cs_subsys; 675 /* some stuff? */ 676}; 677 678#if 0 679static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group) 680{ 681 return group ? 682 container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys) 683 : NULL; 684} 685#endif 686 687static struct config_group *o2nm_cluster_group_make_group(struct config_group *group, 688 const char *name) 689{ 690 struct o2nm_cluster *cluster = NULL; 691 struct o2nm_node_group *ns = NULL; 692 struct config_group *o2hb_group = NULL, *ret = NULL; 693 694 /* this runs under the parent dir's i_mutex; there can be only 695 * one caller in here at a time */ 696 if (o2nm_single_cluster) 697 return ERR_PTR(-ENOSPC); 698 699 cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL); 700 ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL); 701 o2hb_group = o2hb_alloc_hb_set(); 702 if (cluster == NULL || ns == NULL || o2hb_group == NULL) 703 goto out; 704 705 config_group_init_type_name(&cluster->cl_group, name, 706 &o2nm_cluster_type); 707 configfs_add_default_group(&ns->ns_group, &cluster->cl_group); 708 709 config_group_init_type_name(&ns->ns_group, "node", 710 &o2nm_node_group_type); 711 configfs_add_default_group(o2hb_group, &cluster->cl_group); 712 713 rwlock_init(&cluster->cl_nodes_lock); 714 cluster->cl_node_ip_tree = RB_ROOT; 715 cluster->cl_reconnect_delay_ms = O2NET_RECONNECT_DELAY_MS_DEFAULT; 716 cluster->cl_idle_timeout_ms = O2NET_IDLE_TIMEOUT_MS_DEFAULT; 717 cluster->cl_keepalive_delay_ms = O2NET_KEEPALIVE_DELAY_MS_DEFAULT; 718 cluster->cl_fence_method = O2NM_FENCE_RESET; 719 720 ret = &cluster->cl_group; 721 o2nm_single_cluster = cluster; 722 723out: 724 if (ret == NULL) { 725 kfree(cluster); 726 kfree(ns); 727 o2hb_free_hb_set(o2hb_group); 728 ret = ERR_PTR(-ENOMEM); 729 } 730 731 return ret; 732} 733 734static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item) 735{ 736 struct o2nm_cluster *cluster = to_o2nm_cluster(item); 737 738 BUG_ON(o2nm_single_cluster != cluster); 739 o2nm_single_cluster = NULL; 740 741 configfs_remove_default_groups(&cluster->cl_group); 742 config_item_put(item); 743} 744 745static struct configfs_group_operations o2nm_cluster_group_group_ops = { 746 .make_group = o2nm_cluster_group_make_group, 747 .drop_item = o2nm_cluster_group_drop_item, 748}; 749 750static const struct config_item_type o2nm_cluster_group_type = { 751 .ct_group_ops = &o2nm_cluster_group_group_ops, 752 .ct_owner = THIS_MODULE, 753}; 754 755static struct o2nm_cluster_group o2nm_cluster_group = { 756 .cs_subsys = { 757 .su_group = { 758 .cg_item = { 759 .ci_namebuf = "cluster", 760 .ci_type = &o2nm_cluster_group_type, 761 }, 762 }, 763 }, 764}; 765 766static inline void o2nm_lock_subsystem(void) 767{ 768 mutex_lock(&o2nm_cluster_group.cs_subsys.su_mutex); 769} 770 771static inline void o2nm_unlock_subsystem(void) 772{ 773 mutex_unlock(&o2nm_cluster_group.cs_subsys.su_mutex); 774} 775 776int o2nm_depend_item(struct config_item *item) 777{ 778 return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item); 779} 780 781void o2nm_undepend_item(struct config_item *item) 782{ 783 configfs_undepend_item(item); 784} 785 786int o2nm_depend_this_node(void) 787{ 788 int ret = 0; 789 struct o2nm_node *local_node; 790 791 local_node = o2nm_get_node_by_num(o2nm_this_node()); 792 if (!local_node) { 793 ret = -EINVAL; 794 goto out; 795 } 796 797 ret = o2nm_depend_item(&local_node->nd_item); 798 o2nm_node_put(local_node); 799 800out: 801 return ret; 802} 803 804void o2nm_undepend_this_node(void) 805{ 806 struct o2nm_node *local_node; 807 808 local_node = o2nm_get_node_by_num(o2nm_this_node()); 809 BUG_ON(!local_node); 810 811 o2nm_undepend_item(&local_node->nd_item); 812 o2nm_node_put(local_node); 813} 814 815 816static void __exit exit_o2nm(void) 817{ 818 /* XXX sync with hb callbacks and shut down hb? */ 819 o2net_unregister_hb_callbacks(); 820 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys); 821 o2cb_sys_shutdown(); 822 823 o2net_exit(); 824 o2hb_exit(); 825} 826 827static int __init init_o2nm(void) 828{ 829 int ret = -1; 830 831 o2hb_init(); 832 833 ret = o2net_init(); 834 if (ret) 835 goto out_o2hb; 836 837 ret = o2net_register_hb_callbacks(); 838 if (ret) 839 goto out_o2net; 840 841 config_group_init(&o2nm_cluster_group.cs_subsys.su_group); 842 mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex); 843 ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys); 844 if (ret) { 845 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret); 846 goto out_callbacks; 847 } 848 849 ret = o2cb_sys_init(); 850 if (!ret) 851 goto out; 852 853 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys); 854out_callbacks: 855 o2net_unregister_hb_callbacks(); 856out_o2net: 857 o2net_exit(); 858out_o2hb: 859 o2hb_exit(); 860out: 861 return ret; 862} 863 864MODULE_AUTHOR("Oracle"); 865MODULE_LICENSE("GPL"); 866MODULE_DESCRIPTION("OCFS2 cluster management"); 867 868module_init(init_o2nm) 869module_exit(exit_o2nm) 870