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