fs/ocfs2/cluster/nodemanager.c

   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 */
  38 static struct o2nm_cluster *o2nm_single_cluster = NULL;
  39
  40 #define OCFS2_MAX_HB_CTL_PATH 256
  41 static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
  42
  43 static 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
  56 static ctl_table ocfs2_mod_table[] = {
  57         {
  58                 .ctl_name       = KERN_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
  68 static ctl_table ocfs2_kern_table[] = {
  69         {
  70                 .ctl_name       = KERN_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
  80 static 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
  92 static struct ctl_table_header *ocfs2_table_header = NULL;
  93
  94 const char *o2nm_get_hb_ctl_path(void)
  95 {
  96         return ocfs2_hb_ctl_path;
  97 }
  98 EXPORT_SYMBOL_GPL(o2nm_get_hb_ctl_path);
  99
 100 struct o2nm_cluster {
 101         struct config_group     cl_group;
 102         unsigned                cl_has_local:1;
 103         u8                      cl_local_node;
 104         rwlock_t                cl_nodes_lock;
 105         struct o2nm_node        *cl_nodes[O2NM_MAX_NODES];
 106         struct rb_root          cl_node_ip_tree;
 107         /* this bitmap is part of a hack for disk bitmap.. will go eventually. - zab */
 108         unsigned long   cl_nodes_bitmap[BITS_TO_LONGS(O2NM_MAX_NODES)];
 109 };
 110
 111 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
 112 {
 113         struct o2nm_node *node = NULL;
 114
 115         if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL)
 116                 goto out;
 117
 118         read_lock(&o2nm_single_cluster->cl_nodes_lock);
 119         node = o2nm_single_cluster->cl_nodes[node_num];
 120         if (node)
 121                 config_item_get(&node->nd_item);
 122         read_unlock(&o2nm_single_cluster->cl_nodes_lock);
 123 out:
 124         return node;
 125 }
 126 EXPORT_SYMBOL_GPL(o2nm_get_node_by_num);
 127
 128 int o2nm_configured_node_map(unsigned long *map, unsigned bytes)
 129 {
 130         struct o2nm_cluster *cluster = o2nm_single_cluster;
 131
 132         BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap)));
 133
 134         if (cluster == NULL)
 135                 return -EINVAL;
 136
 137         read_lock(&cluster->cl_nodes_lock);
 138         memcpy(map, cluster->cl_nodes_bitmap, sizeof(cluster->cl_nodes_bitmap));
 139         read_unlock(&cluster->cl_nodes_lock);
 140
 141         return 0;
 142 }
 143 EXPORT_SYMBOL_GPL(o2nm_configured_node_map);
 144
 145 static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster,
 146                                                   __be32 ip_needle,
 147                                                   struct rb_node ***ret_p,
 148                                                   struct rb_node **ret_parent)
 149 {
 150         struct rb_node **p = &cluster->cl_node_ip_tree.rb_node;
 151         struct rb_node *parent = NULL;
 152         struct o2nm_node *node, *ret = NULL;
 153
 154         while (*p) {
 155                 int cmp;
 156
 157                 parent = *p;
 158                 node = rb_entry(parent, struct o2nm_node, nd_ip_node);
 159
 160                 cmp = memcmp(&ip_needle, &node->nd_ipv4_address,
 161                                 sizeof(ip_needle));
 162                 if (cmp < 0)
 163                         p = &(*p)->rb_left;
 164                 else if (cmp > 0)
 165                         p = &(*p)->rb_right;
 166                 else {
 167                         ret = node;
 168                         break;
 169                 }
 170         }
 171
 172         if (ret_p != NULL)
 173                 *ret_p = p;
 174         if (ret_parent != NULL)
 175                 *ret_parent = parent;
 176
 177         return ret;
 178 }
 179
 180 struct o2nm_node *o2nm_get_node_by_ip(__be32 addr)
 181 {
 182         struct o2nm_node *node = NULL;
 183         struct o2nm_cluster *cluster = o2nm_single_cluster;
 184
 185         if (cluster == NULL)
 186                 goto out;
 187
 188         read_lock(&cluster->cl_nodes_lock);
 189         node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL);
 190         if (node)
 191                 config_item_get(&node->nd_item);
 192         read_unlock(&cluster->cl_nodes_lock);
 193
 194 out:
 195         return node;
 196 }
 197 EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip);
 198
 199 void o2nm_node_put(struct o2nm_node *node)
 200 {
 201         config_item_put(&node->nd_item);
 202 }
 203 EXPORT_SYMBOL_GPL(o2nm_node_put);
 204
 205 void o2nm_node_get(struct o2nm_node *node)
 206 {
 207         config_item_get(&node->nd_item);
 208 }
 209 EXPORT_SYMBOL_GPL(o2nm_node_get);
 210
 211 u8 o2nm_this_node(void)
 212 {
 213         u8 node_num = O2NM_MAX_NODES;
 214
 215         if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local)
 216                 node_num = o2nm_single_cluster->cl_local_node;
 217
 218         return node_num;
 219 }
 220 EXPORT_SYMBOL_GPL(o2nm_this_node);
 221
 222 /* node configfs bits */
 223
 224 static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item)
 225 {
 226         return item ?
 227                 container_of(to_config_group(item), struct o2nm_cluster,
 228                              cl_group)
 229                 : NULL;
 230 }
 231
 232 static struct o2nm_node *to_o2nm_node(struct config_item *item)
 233 {
 234         return item ? container_of(item, struct o2nm_node, nd_item) : NULL;
 235 }
 236
 237 static void o2nm_node_release(struct config_item *item)
 238 {
 239         struct o2nm_node *node = to_o2nm_node(item);
 240         kfree(node);
 241 }
 242
 243 static ssize_t o2nm_node_num_read(struct o2nm_node *node, char *page)
 244 {
 245         return sprintf(page, "%d\n", node->nd_num);
 246 }
 247
 248 static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node)
 249 {
 250         /* through the first node_set .parent
 251          * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */
 252         return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
 253 }
 254
 255 enum {
 256         O2NM_NODE_ATTR_NUM = 0,
 257         O2NM_NODE_ATTR_PORT,
 258         O2NM_NODE_ATTR_ADDRESS,
 259         O2NM_NODE_ATTR_LOCAL,
 260 };
 261
 262 static ssize_t o2nm_node_num_write(struct o2nm_node *node, const char *page,
 263                                    size_t count)
 264 {
 265         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
 266         unsigned long tmp;
 267         char *p = (char *)page;
 268
 269         tmp = simple_strtoul(p, &p, 0);
 270         if (!p || (*p && (*p != '\n')))
 271                 return -EINVAL;
 272
 273         if (tmp >= O2NM_MAX_NODES)
 274                 return -ERANGE;
 275
 276         /* once we're in the cl_nodes tree networking can look us up by
 277          * node number and try to use our address and port attributes
 278          * to connect to this node.. make sure that they've been set
 279          * before writing the node attribute? */
 280         if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
 281             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
 282                 return -EINVAL; /* XXX */
 283
 284         write_lock(&cluster->cl_nodes_lock);
 285         if (cluster->cl_nodes[tmp])
 286                 p = NULL;
 287         else  {
 288                 cluster->cl_nodes[tmp] = node;
 289                 node->nd_num = tmp;
 290                 set_bit(tmp, cluster->cl_nodes_bitmap);
 291         }
 292         write_unlock(&cluster->cl_nodes_lock);
 293         if (p == NULL)
 294                 return -EEXIST;
 295
 296         return count;
 297 }
 298 static ssize_t o2nm_node_ipv4_port_read(struct o2nm_node *node, char *page)
 299 {
 300         return sprintf(page, "%u\n", ntohs(node->nd_ipv4_port));
 301 }
 302
 303 static ssize_t o2nm_node_ipv4_port_write(struct o2nm_node *node,
 304                                          const char *page, size_t count)
 305 {
 306         unsigned long tmp;
 307         char *p = (char *)page;
 308
 309         tmp = simple_strtoul(p, &p, 0);
 310         if (!p || (*p && (*p != '\n')))
 311                 return -EINVAL;
 312
 313         if (tmp == 0)
 314                 return -EINVAL;
 315         if (tmp >= (u16)-1)
 316                 return -ERANGE;
 317
 318         node->nd_ipv4_port = htons(tmp);
 319
 320         return count;
 321 }
 322
 323 static ssize_t o2nm_node_ipv4_address_read(struct o2nm_node *node, char *page)
 324 {
 325         return sprintf(page, "%u.%u.%u.%u\n", NIPQUAD(node->nd_ipv4_address));
 326 }
 327
 328 static ssize_t o2nm_node_ipv4_address_write(struct o2nm_node *node,
 329                                             const char *page,
 330                                             size_t count)
 331 {
 332         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
 333         int ret, i;
 334         struct rb_node **p, *parent;
 335         unsigned int octets[4];
 336         __be32 ipv4_addr = 0;
 337
 338         ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2],
 339                      &octets[1], &octets[0]);
 340         if (ret != 4)
 341                 return -EINVAL;
 342
 343         for (i = 0; i < ARRAY_SIZE(octets); i++) {
 344                 if (octets[i] > 255)
 345                         return -ERANGE;
 346                 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8));
 347         }
 348
 349         ret = 0;
 350         write_lock(&cluster->cl_nodes_lock);
 351         if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
 352                 ret = -EEXIST;
 353         else {
 354                 rb_link_node(&node->nd_ip_node, parent, p);
 355                 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree);
 356         }
 357         write_unlock(&cluster->cl_nodes_lock);
 358         if (ret)
 359                 return ret;
 360
 361         memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr));
 362
 363         return count;
 364 }
 365
 366 static ssize_t o2nm_node_local_read(struct o2nm_node *node, char *page)
 367 {
 368         return sprintf(page, "%d\n", node->nd_local);
 369 }
 370
 371 static ssize_t o2nm_node_local_write(struct o2nm_node *node, const char *page,
 372                                      size_t count)
 373 {
 374         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
 375         unsigned long tmp;
 376         char *p = (char *)page;
 377         ssize_t ret;
 378
 379         tmp = simple_strtoul(p, &p, 0);
 380         if (!p || (*p && (*p != '\n')))
 381                 return -EINVAL;
 382
 383         tmp = !!tmp; /* boolean of whether this node wants to be local */
 384
 385         /* setting local turns on networking rx for now so we require having
 386          * set everything else first */
 387         if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
 388             !test_bit(O2NM_NODE_ATTR_NUM, &node->nd_set_attributes) ||
 389             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
 390                 return -EINVAL; /* XXX */
 391
 392         /* the only failure case is trying to set a new local node
 393          * when a different one is already set */
 394         if (tmp && tmp == cluster->cl_has_local &&
 395             cluster->cl_local_node != node->nd_num)
 396                 return -EBUSY;
 397
 398         /* bring up the rx thread if we're setting the new local node. */
 399         if (tmp && !cluster->cl_has_local) {
 400                 ret = o2net_start_listening(node);
 401                 if (ret)
 402                         return ret;
 403         }
 404
 405         if (!tmp && cluster->cl_has_local &&
 406             cluster->cl_local_node == node->nd_num) {
 407                 o2net_stop_listening(node);
 408                 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
 409         }
 410
 411         node->nd_local = tmp;
 412         if (node->nd_local) {
 413                 cluster->cl_has_local = tmp;
 414                 cluster->cl_local_node = node->nd_num;
 415         }
 416
 417         return count;
 418 }
 419
 420 struct o2nm_node_attribute {
 421         struct configfs_attribute attr;
 422         ssize_t (*show)(struct o2nm_node *, char *);
 423         ssize_t (*store)(struct o2nm_node *, const char *, size_t);
 424 };
 425
 426 static struct o2nm_node_attribute o2nm_node_attr_num = {
 427         .attr   = { .ca_owner = THIS_MODULE,
 428                     .ca_name = "num",
 429                     .ca_mode = S_IRUGO | S_IWUSR },
 430         .show   = o2nm_node_num_read,
 431         .store  = o2nm_node_num_write,
 432 };
 433
 434 static struct o2nm_node_attribute o2nm_node_attr_ipv4_port = {
 435         .attr   = { .ca_owner = THIS_MODULE,
 436                     .ca_name = "ipv4_port",
 437                     .ca_mode = S_IRUGO | S_IWUSR },
 438         .show   = o2nm_node_ipv4_port_read,
 439         .store  = o2nm_node_ipv4_port_write,
 440 };
 441
 442 static struct o2nm_node_attribute o2nm_node_attr_ipv4_address = {
 443         .attr   = { .ca_owner = THIS_MODULE,
 444                     .ca_name = "ipv4_address",
 445                     .ca_mode = S_IRUGO | S_IWUSR },
 446         .show   = o2nm_node_ipv4_address_read,
 447         .store  = o2nm_node_ipv4_address_write,
 448 };
 449
 450 static struct o2nm_node_attribute o2nm_node_attr_local = {
 451         .attr   = { .ca_owner = THIS_MODULE,
 452                     .ca_name = "local",
 453                     .ca_mode = S_IRUGO | S_IWUSR },
 454         .show   = o2nm_node_local_read,
 455         .store  = o2nm_node_local_write,
 456 };
 457
 458 static struct configfs_attribute *o2nm_node_attrs[] = {
 459         [O2NM_NODE_ATTR_NUM] = &o2nm_node_attr_num.attr,
 460         [O2NM_NODE_ATTR_PORT] = &o2nm_node_attr_ipv4_port.attr,
 461         [O2NM_NODE_ATTR_ADDRESS] = &o2nm_node_attr_ipv4_address.attr,
 462         [O2NM_NODE_ATTR_LOCAL] = &o2nm_node_attr_local.attr,
 463         NULL,
 464 };
 465
 466 static int o2nm_attr_index(struct configfs_attribute *attr)
 467 {
 468         int i;
 469         for (i = 0; i < ARRAY_SIZE(o2nm_node_attrs); i++) {
 470                 if (attr == o2nm_node_attrs[i])
 471                         return i;
 472         }
 473         BUG();
 474         return 0;
 475 }
 476
 477 static ssize_t o2nm_node_show(struct config_item *item,
 478                               struct configfs_attribute *attr,
 479                               char *page)
 480 {
 481         struct o2nm_node *node = to_o2nm_node(item);
 482         struct o2nm_node_attribute *o2nm_node_attr =
 483                 container_of(attr, struct o2nm_node_attribute, attr);
 484         ssize_t ret = 0;
 485
 486         if (o2nm_node_attr->show)
 487                 ret = o2nm_node_attr->show(node, page);
 488         return ret;
 489 }
 490
 491 static ssize_t o2nm_node_store(struct config_item *item,
 492                                struct configfs_attribute *attr,
 493                                const char *page, size_t count)
 494 {
 495         struct o2nm_node *node = to_o2nm_node(item);
 496         struct o2nm_node_attribute *o2nm_node_attr =
 497                 container_of(attr, struct o2nm_node_attribute, attr);
 498         ssize_t ret;
 499         int attr_index = o2nm_attr_index(attr);
 500
 501         if (o2nm_node_attr->store == NULL) {
 502                 ret = -EINVAL;
 503                 goto out;
 504         }
 505
 506         if (test_bit(attr_index, &node->nd_set_attributes))
 507                 return -EBUSY;
 508
 509         ret = o2nm_node_attr->store(node, page, count);
 510         if (ret < count)
 511                 goto out;
 512
 513         set_bit(attr_index, &node->nd_set_attributes);
 514 out:
 515         return ret;
 516 }
 517
 518 static struct configfs_item_operations o2nm_node_item_ops = {
 519         .release                = o2nm_node_release,
 520         .show_attribute         = o2nm_node_show,
 521         .store_attribute        = o2nm_node_store,
 522 };
 523
 524 static struct config_item_type o2nm_node_type = {
 525         .ct_item_ops    = &o2nm_node_item_ops,
 526         .ct_attrs       = o2nm_node_attrs,
 527         .ct_owner       = THIS_MODULE,
 528 };
 529
 530 /* node set */
 531
 532 struct o2nm_node_group {
 533         struct config_group ns_group;
 534         /* some stuff? */
 535 };
 536
 537 #if 0
 538 static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group)
 539 {
 540         return group ?
 541                 container_of(group, struct o2nm_node_group, ns_group)
 542                 : NULL;
 543 }
 544 #endif
 545
 546 static struct config_item *o2nm_node_group_make_item(struct config_group *group,
 547                                                      const char *name)
 548 {
 549         struct o2nm_node *node = NULL;
 550         struct config_item *ret = NULL;
 551
 552         if (strlen(name) > O2NM_MAX_NAME_LEN)
 553                 goto out; /* ENAMETOOLONG */
 554
 555         node = kcalloc(1, sizeof(struct o2nm_node), GFP_KERNEL);
 556         if (node == NULL)
 557                 goto out; /* ENOMEM */
 558
 559         strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */
 560         config_item_init_type_name(&node->nd_item, name, &o2nm_node_type);
 561         spin_lock_init(&node->nd_lock);
 562
 563         ret = &node->nd_item;
 564
 565 out:
 566         if (ret == NULL)
 567                 kfree(node);
 568
 569         return ret;
 570 }
 571
 572 static void o2nm_node_group_drop_item(struct config_group *group,
 573                                       struct config_item *item)
 574 {
 575         struct o2nm_node *node = to_o2nm_node(item);
 576         struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent);
 577
 578         o2net_disconnect_node(node);
 579
 580         if (cluster->cl_has_local &&
 581             (cluster->cl_local_node == node->nd_num)) {
 582                 cluster->cl_has_local = 0;
 583                 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
 584                 o2net_stop_listening(node);
 585         }
 586
 587         /* XXX call into net to stop this node from trading messages */
 588
 589         write_lock(&cluster->cl_nodes_lock);
 590
 591         /* XXX sloppy */
 592         if (node->nd_ipv4_address)
 593                 rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree);
 594
 595         /* nd_num might be 0 if the node number hasn't been set.. */
 596         if (cluster->cl_nodes[node->nd_num] == node) {
 597                 cluster->cl_nodes[node->nd_num] = NULL;
 598                 clear_bit(node->nd_num, cluster->cl_nodes_bitmap);
 599         }
 600         write_unlock(&cluster->cl_nodes_lock);
 601
 602         config_item_put(item);
 603 }
 604
 605 static struct configfs_group_operations o2nm_node_group_group_ops = {
 606         .make_item      = o2nm_node_group_make_item,
 607         .drop_item      = o2nm_node_group_drop_item,
 608 };
 609
 610 static struct config_item_type o2nm_node_group_type = {
 611         .ct_group_ops   = &o2nm_node_group_group_ops,
 612         .ct_owner       = THIS_MODULE,
 613 };
 614
 615 /* cluster */
 616
 617 static void o2nm_cluster_release(struct config_item *item)
 618 {
 619         struct o2nm_cluster *cluster = to_o2nm_cluster(item);
 620
 621         kfree(cluster->cl_group.default_groups);
 622         kfree(cluster);
 623 }
 624
 625 static struct configfs_item_operations o2nm_cluster_item_ops = {
 626         .release        = o2nm_cluster_release,
 627 };
 628
 629 static struct config_item_type o2nm_cluster_type = {
 630         .ct_item_ops    = &o2nm_cluster_item_ops,
 631         .ct_owner       = THIS_MODULE,
 632 };
 633
 634 /* cluster set */
 635
 636 struct o2nm_cluster_group {
 637         struct configfs_subsystem cs_subsys;
 638         /* some stuff? */
 639 };
 640
 641 #if 0
 642 static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group)
 643 {
 644         return group ?
 645                 container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys)
 646                : NULL;
 647 }
 648 #endif
 649
 650 static struct config_group *o2nm_cluster_group_make_group(struct config_group *group,
 651                                                           const char *name)
 652 {
 653         struct o2nm_cluster *cluster = NULL;
 654         struct o2nm_node_group *ns = NULL;
 655         struct config_group *o2hb_group = NULL, *ret = NULL;
 656         void *defs = NULL;
 657
 658         /* this runs under the parent dir's i_mutex; there can be only
 659          * one caller in here at a time */
 660         if (o2nm_single_cluster)
 661                 goto out; /* ENOSPC */
 662
 663         cluster = kcalloc(1, sizeof(struct o2nm_cluster), GFP_KERNEL);
 664         ns = kcalloc(1, sizeof(struct o2nm_node_group), GFP_KERNEL);
 665         defs = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
 666         o2hb_group = o2hb_alloc_hb_set();
 667         if (cluster == NULL || ns == NULL || o2hb_group == NULL || defs == NULL)
 668                 goto out;
 669
 670         config_group_init_type_name(&cluster->cl_group, name,
 671                                     &o2nm_cluster_type);
 672         config_group_init_type_name(&ns->ns_group, "node",
 673                                     &o2nm_node_group_type);
 674
 675         cluster->cl_group.default_groups = defs;
 676         cluster->cl_group.default_groups[0] = &ns->ns_group;
 677         cluster->cl_group.default_groups[1] = o2hb_group;
 678         cluster->cl_group.default_groups[2] = NULL;
 679         rwlock_init(&cluster->cl_nodes_lock);
 680         cluster->cl_node_ip_tree = RB_ROOT;
 681
 682         ret = &cluster->cl_group;
 683         o2nm_single_cluster = cluster;
 684
 685 out:
 686         if (ret == NULL) {
 687                 kfree(cluster);
 688                 kfree(ns);
 689                 o2hb_free_hb_set(o2hb_group);
 690                 kfree(defs);
 691         }
 692
 693         return ret;
 694 }
 695
 696 static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item)
 697 {
 698         struct o2nm_cluster *cluster = to_o2nm_cluster(item);
 699         int i;
 700         struct config_item *killme;
 701
 702         BUG_ON(o2nm_single_cluster != cluster);
 703         o2nm_single_cluster = NULL;
 704
 705         for (i = 0; cluster->cl_group.default_groups[i]; i++) {
 706                 killme = &cluster->cl_group.default_groups[i]->cg_item;
 707                 cluster->cl_group.default_groups[i] = NULL;
 708                 config_item_put(killme);
 709         }
 710
 711         config_item_put(item);
 712 }
 713
 714 static struct configfs_group_operations o2nm_cluster_group_group_ops = {
 715         .make_group     = o2nm_cluster_group_make_group,
 716         .drop_item      = o2nm_cluster_group_drop_item,
 717 };
 718
 719 static struct config_item_type o2nm_cluster_group_type = {
 720         .ct_group_ops   = &o2nm_cluster_group_group_ops,
 721         .ct_owner       = THIS_MODULE,
 722 };
 723
 724 static struct o2nm_cluster_group o2nm_cluster_group = {
 725         .cs_subsys = {
 726                 .su_group = {
 727                         .cg_item = {
 728                                 .ci_namebuf = "cluster",
 729                                 .ci_type = &o2nm_cluster_group_type,
 730                         },
 731                 },
 732         },
 733 };
 734
 735 static void __exit exit_o2nm(void)
 736 {
 737         if (ocfs2_table_header)
 738                 unregister_sysctl_table(ocfs2_table_header);
 739
 740         /* XXX sync with hb callbacks and shut down hb? */
 741         o2net_unregister_hb_callbacks();
 742         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
 743         o2cb_sys_shutdown();
 744
 745         o2net_exit();
 746 }
 747
 748 static int __init init_o2nm(void)
 749 {
 750         int ret = -1;
 751
 752         cluster_print_version();
 753
 754         o2hb_init();
 755         o2net_init();
 756
 757         ocfs2_table_header = register_sysctl_table(ocfs2_root_table, 0);
 758         if (!ocfs2_table_header) {
 759                 printk(KERN_ERR "nodemanager: unable to register sysctl\n");
 760                 ret = -ENOMEM; /* or something. */
 761                 goto out_o2net;
 762         }
 763
 764         ret = o2net_register_hb_callbacks();
 765         if (ret)
 766                 goto out_sysctl;
 767
 768         config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
 769         init_MUTEX(&o2nm_cluster_group.cs_subsys.su_sem);
 770         ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys);
 771         if (ret) {
 772                 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
 773                 goto out_callbacks;
 774         }
 775
 776         ret = o2cb_sys_init();
 777         if (!ret)
 778                 goto out;
 779
 780         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
 781 out_callbacks:
 782         o2net_unregister_hb_callbacks();
 783 out_sysctl:
 784         unregister_sysctl_table(ocfs2_table_header);
 785 out_o2net:
 786         o2net_exit();
 787 out:
 788         return ret;
 789 }
 790
 791 MODULE_AUTHOR("Oracle");
 792 MODULE_LICENSE("GPL");
 793
 794 module_init(init_o2nm)
 795 module_exit(exit_o2nm)