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