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