1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (C) 2004, 2005 Oracle. All rights reserved.
6 #include <linux/slab.h>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/configfs.h>
12 #include "nodemanager.h"
13 #include "heartbeat.h"
17 /* for now we operate under the assertion that there can be only one
18 * cluster active at a time. Changing this will require trickling
19 * cluster references throughout where nodes are looked up */
20 struct o2nm_cluster *o2nm_single_cluster = NULL;
22 static const char *o2nm_fence_method_desc[O2NM_FENCE_METHODS] = {
23 "reset", /* O2NM_FENCE_RESET */
24 "panic", /* O2NM_FENCE_PANIC */
27 static inline void o2nm_lock_subsystem(void);
28 static inline void o2nm_unlock_subsystem(void);
30 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
32 struct o2nm_node *node = NULL;
34 if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL)
37 read_lock(&o2nm_single_cluster->cl_nodes_lock);
38 node = o2nm_single_cluster->cl_nodes[node_num];
40 config_item_get(&node->nd_item);
41 read_unlock(&o2nm_single_cluster->cl_nodes_lock);
45 EXPORT_SYMBOL_GPL(o2nm_get_node_by_num);
47 int o2nm_configured_node_map(unsigned long *map, unsigned bytes)
49 struct o2nm_cluster *cluster = o2nm_single_cluster;
51 BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap)));
56 read_lock(&cluster->cl_nodes_lock);
57 bitmap_copy(map, cluster->cl_nodes_bitmap, O2NM_MAX_NODES);
58 read_unlock(&cluster->cl_nodes_lock);
62 EXPORT_SYMBOL_GPL(o2nm_configured_node_map);
64 static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster,
66 struct rb_node ***ret_p,
67 struct rb_node **ret_parent)
69 struct rb_node **p = &cluster->cl_node_ip_tree.rb_node;
70 struct rb_node *parent = NULL;
71 struct o2nm_node *node, *ret = NULL;
77 node = rb_entry(parent, struct o2nm_node, nd_ip_node);
79 cmp = memcmp(&ip_needle, &node->nd_ipv4_address,
93 if (ret_parent != NULL)
99 struct o2nm_node *o2nm_get_node_by_ip(__be32 addr)
101 struct o2nm_node *node = NULL;
102 struct o2nm_cluster *cluster = o2nm_single_cluster;
107 read_lock(&cluster->cl_nodes_lock);
108 node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL);
110 config_item_get(&node->nd_item);
111 read_unlock(&cluster->cl_nodes_lock);
116 EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip);
118 void o2nm_node_put(struct o2nm_node *node)
120 config_item_put(&node->nd_item);
122 EXPORT_SYMBOL_GPL(o2nm_node_put);
124 void o2nm_node_get(struct o2nm_node *node)
126 config_item_get(&node->nd_item);
128 EXPORT_SYMBOL_GPL(o2nm_node_get);
130 u8 o2nm_this_node(void)
132 u8 node_num = O2NM_MAX_NODES;
134 if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local)
135 node_num = o2nm_single_cluster->cl_local_node;
139 EXPORT_SYMBOL_GPL(o2nm_this_node);
141 /* node configfs bits */
143 static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item)
146 container_of(to_config_group(item), struct o2nm_cluster,
151 static struct o2nm_node *to_o2nm_node(struct config_item *item)
153 return item ? container_of(item, struct o2nm_node, nd_item) : NULL;
156 static void o2nm_node_release(struct config_item *item)
158 struct o2nm_node *node = to_o2nm_node(item);
162 static ssize_t o2nm_node_num_show(struct config_item *item, char *page)
164 return sprintf(page, "%d\n", to_o2nm_node(item)->nd_num);
167 static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node)
169 /* through the first node_set .parent
170 * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */
171 if (node->nd_item.ci_parent)
172 return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
178 O2NM_NODE_ATTR_NUM = 0,
180 O2NM_NODE_ATTR_ADDRESS,
183 static ssize_t o2nm_node_num_store(struct config_item *item, const char *page,
186 struct o2nm_node *node = to_o2nm_node(item);
187 struct o2nm_cluster *cluster;
189 char *p = (char *)page;
192 tmp = simple_strtoul(p, &p, 0);
193 if (!p || (*p && (*p != '\n')))
196 if (tmp >= O2NM_MAX_NODES)
199 /* once we're in the cl_nodes tree networking can look us up by
200 * node number and try to use our address and port attributes
201 * to connect to this node.. make sure that they've been set
202 * before writing the node attribute? */
203 if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
204 !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
205 return -EINVAL; /* XXX */
207 o2nm_lock_subsystem();
208 cluster = to_o2nm_cluster_from_node(node);
210 o2nm_unlock_subsystem();
214 write_lock(&cluster->cl_nodes_lock);
215 if (cluster->cl_nodes[tmp])
217 else if (test_and_set_bit(O2NM_NODE_ATTR_NUM,
218 &node->nd_set_attributes))
221 cluster->cl_nodes[tmp] = node;
223 set_bit(tmp, cluster->cl_nodes_bitmap);
225 write_unlock(&cluster->cl_nodes_lock);
226 o2nm_unlock_subsystem();
233 static ssize_t o2nm_node_ipv4_port_show(struct config_item *item, char *page)
235 return sprintf(page, "%u\n", ntohs(to_o2nm_node(item)->nd_ipv4_port));
238 static ssize_t o2nm_node_ipv4_port_store(struct config_item *item,
239 const char *page, size_t count)
241 struct o2nm_node *node = to_o2nm_node(item);
243 char *p = (char *)page;
245 tmp = simple_strtoul(p, &p, 0);
246 if (!p || (*p && (*p != '\n')))
254 if (test_and_set_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
256 node->nd_ipv4_port = htons(tmp);
261 static ssize_t o2nm_node_ipv4_address_show(struct config_item *item, char *page)
263 return sprintf(page, "%pI4\n", &to_o2nm_node(item)->nd_ipv4_address);
266 static ssize_t o2nm_node_ipv4_address_store(struct config_item *item,
270 struct o2nm_node *node = to_o2nm_node(item);
271 struct o2nm_cluster *cluster;
273 struct rb_node **p, *parent;
274 unsigned int octets[4];
275 __be32 ipv4_addr = 0;
277 ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2],
278 &octets[1], &octets[0]);
282 for (i = 0; i < ARRAY_SIZE(octets); i++) {
285 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8));
288 o2nm_lock_subsystem();
289 cluster = to_o2nm_cluster_from_node(node);
291 o2nm_unlock_subsystem();
296 write_lock(&cluster->cl_nodes_lock);
297 if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
299 else if (test_and_set_bit(O2NM_NODE_ATTR_ADDRESS,
300 &node->nd_set_attributes))
303 rb_link_node(&node->nd_ip_node, parent, p);
304 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree);
306 write_unlock(&cluster->cl_nodes_lock);
307 o2nm_unlock_subsystem();
312 memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr));
317 static ssize_t o2nm_node_local_show(struct config_item *item, char *page)
319 return sprintf(page, "%d\n", to_o2nm_node(item)->nd_local);
322 static ssize_t o2nm_node_local_store(struct config_item *item, const char *page,
325 struct o2nm_node *node = to_o2nm_node(item);
326 struct o2nm_cluster *cluster;
328 char *p = (char *)page;
331 tmp = simple_strtoul(p, &p, 0);
332 if (!p || (*p && (*p != '\n')))
335 tmp = !!tmp; /* boolean of whether this node wants to be local */
337 /* setting local turns on networking rx for now so we require having
338 * set everything else first */
339 if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
340 !test_bit(O2NM_NODE_ATTR_NUM, &node->nd_set_attributes) ||
341 !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
342 return -EINVAL; /* XXX */
344 o2nm_lock_subsystem();
345 cluster = to_o2nm_cluster_from_node(node);
351 /* the only failure case is trying to set a new local node
352 * when a different one is already set */
353 if (tmp && tmp == cluster->cl_has_local &&
354 cluster->cl_local_node != node->nd_num) {
359 /* bring up the rx thread if we're setting the new local node. */
360 if (tmp && !cluster->cl_has_local) {
361 ret = o2net_start_listening(node);
366 if (!tmp && cluster->cl_has_local &&
367 cluster->cl_local_node == node->nd_num) {
368 o2net_stop_listening(node);
369 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
372 node->nd_local = tmp;
373 if (node->nd_local) {
374 cluster->cl_has_local = tmp;
375 cluster->cl_local_node = node->nd_num;
381 o2nm_unlock_subsystem();
385 CONFIGFS_ATTR(o2nm_node_, num);
386 CONFIGFS_ATTR(o2nm_node_, ipv4_port);
387 CONFIGFS_ATTR(o2nm_node_, ipv4_address);
388 CONFIGFS_ATTR(o2nm_node_, local);
390 static struct configfs_attribute *o2nm_node_attrs[] = {
392 &o2nm_node_attr_ipv4_port,
393 &o2nm_node_attr_ipv4_address,
394 &o2nm_node_attr_local,
398 static struct configfs_item_operations o2nm_node_item_ops = {
399 .release = o2nm_node_release,
402 static const struct config_item_type o2nm_node_type = {
403 .ct_item_ops = &o2nm_node_item_ops,
404 .ct_attrs = o2nm_node_attrs,
405 .ct_owner = THIS_MODULE,
410 struct o2nm_node_group {
411 struct config_group ns_group;
416 static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group)
419 container_of(group, struct o2nm_node_group, ns_group)
424 static ssize_t o2nm_cluster_attr_write(const char *page, ssize_t count,
428 char *p = (char *)page;
430 tmp = simple_strtoul(p, &p, 0);
431 if (!p || (*p && (*p != '\n')))
444 static ssize_t o2nm_cluster_idle_timeout_ms_show(struct config_item *item,
447 return sprintf(page, "%u\n", to_o2nm_cluster(item)->cl_idle_timeout_ms);
450 static ssize_t o2nm_cluster_idle_timeout_ms_store(struct config_item *item,
451 const char *page, size_t count)
453 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
457 ret = o2nm_cluster_attr_write(page, count, &val);
460 if (cluster->cl_idle_timeout_ms != val
461 && o2net_num_connected_peers()) {
463 "o2net: cannot change idle timeout after "
464 "the first peer has agreed to it."
465 " %d connected peers\n",
466 o2net_num_connected_peers());
468 } else if (val <= cluster->cl_keepalive_delay_ms) {
469 mlog(ML_NOTICE, "o2net: idle timeout must be larger "
470 "than keepalive delay\n");
473 cluster->cl_idle_timeout_ms = val;
480 static ssize_t o2nm_cluster_keepalive_delay_ms_show(
481 struct config_item *item, char *page)
483 return sprintf(page, "%u\n",
484 to_o2nm_cluster(item)->cl_keepalive_delay_ms);
487 static ssize_t o2nm_cluster_keepalive_delay_ms_store(
488 struct config_item *item, const char *page, size_t count)
490 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
494 ret = o2nm_cluster_attr_write(page, count, &val);
497 if (cluster->cl_keepalive_delay_ms != val
498 && o2net_num_connected_peers()) {
500 "o2net: cannot change keepalive delay after"
501 " the first peer has agreed to it."
502 " %d connected peers\n",
503 o2net_num_connected_peers());
505 } else if (val >= cluster->cl_idle_timeout_ms) {
506 mlog(ML_NOTICE, "o2net: keepalive delay must be "
507 "smaller than idle timeout\n");
510 cluster->cl_keepalive_delay_ms = val;
517 static ssize_t o2nm_cluster_reconnect_delay_ms_show(
518 struct config_item *item, char *page)
520 return sprintf(page, "%u\n",
521 to_o2nm_cluster(item)->cl_reconnect_delay_ms);
524 static ssize_t o2nm_cluster_reconnect_delay_ms_store(
525 struct config_item *item, const char *page, size_t count)
527 return o2nm_cluster_attr_write(page, count,
528 &to_o2nm_cluster(item)->cl_reconnect_delay_ms);
531 static ssize_t o2nm_cluster_fence_method_show(
532 struct config_item *item, char *page)
534 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
538 ret = sprintf(page, "%s\n",
539 o2nm_fence_method_desc[cluster->cl_fence_method]);
543 static ssize_t o2nm_cluster_fence_method_store(
544 struct config_item *item, const char *page, size_t count)
548 if (page[count - 1] != '\n')
551 for (i = 0; i < O2NM_FENCE_METHODS; ++i) {
552 if (count != strlen(o2nm_fence_method_desc[i]) + 1)
554 if (strncasecmp(page, o2nm_fence_method_desc[i], count - 1))
556 if (to_o2nm_cluster(item)->cl_fence_method != i) {
557 printk(KERN_INFO "ocfs2: Changing fence method to %s\n",
558 o2nm_fence_method_desc[i]);
559 to_o2nm_cluster(item)->cl_fence_method = i;
568 CONFIGFS_ATTR(o2nm_cluster_, idle_timeout_ms);
569 CONFIGFS_ATTR(o2nm_cluster_, keepalive_delay_ms);
570 CONFIGFS_ATTR(o2nm_cluster_, reconnect_delay_ms);
571 CONFIGFS_ATTR(o2nm_cluster_, fence_method);
573 static struct configfs_attribute *o2nm_cluster_attrs[] = {
574 &o2nm_cluster_attr_idle_timeout_ms,
575 &o2nm_cluster_attr_keepalive_delay_ms,
576 &o2nm_cluster_attr_reconnect_delay_ms,
577 &o2nm_cluster_attr_fence_method,
581 static struct config_item *o2nm_node_group_make_item(struct config_group *group,
584 struct o2nm_node *node = NULL;
586 if (strlen(name) > O2NM_MAX_NAME_LEN)
587 return ERR_PTR(-ENAMETOOLONG);
589 node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL);
591 return ERR_PTR(-ENOMEM);
593 strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */
594 config_item_init_type_name(&node->nd_item, name, &o2nm_node_type);
595 spin_lock_init(&node->nd_lock);
597 mlog(ML_CLUSTER, "o2nm: Registering node %s\n", name);
599 return &node->nd_item;
602 static void o2nm_node_group_drop_item(struct config_group *group,
603 struct config_item *item)
605 struct o2nm_node *node = to_o2nm_node(item);
606 struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent);
608 if (cluster->cl_nodes[node->nd_num] == node) {
609 o2net_disconnect_node(node);
611 if (cluster->cl_has_local &&
612 (cluster->cl_local_node == node->nd_num)) {
613 cluster->cl_has_local = 0;
614 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
615 o2net_stop_listening(node);
619 /* XXX call into net to stop this node from trading messages */
621 write_lock(&cluster->cl_nodes_lock);
624 if (node->nd_ipv4_address)
625 rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree);
627 /* nd_num might be 0 if the node number hasn't been set.. */
628 if (cluster->cl_nodes[node->nd_num] == node) {
629 cluster->cl_nodes[node->nd_num] = NULL;
630 clear_bit(node->nd_num, cluster->cl_nodes_bitmap);
632 write_unlock(&cluster->cl_nodes_lock);
634 mlog(ML_CLUSTER, "o2nm: Unregistered node %s\n",
635 config_item_name(&node->nd_item));
637 config_item_put(item);
640 static struct configfs_group_operations o2nm_node_group_group_ops = {
641 .make_item = o2nm_node_group_make_item,
642 .drop_item = o2nm_node_group_drop_item,
645 static const struct config_item_type o2nm_node_group_type = {
646 .ct_group_ops = &o2nm_node_group_group_ops,
647 .ct_owner = THIS_MODULE,
652 static void o2nm_cluster_release(struct config_item *item)
654 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
659 static struct configfs_item_operations o2nm_cluster_item_ops = {
660 .release = o2nm_cluster_release,
663 static const struct config_item_type o2nm_cluster_type = {
664 .ct_item_ops = &o2nm_cluster_item_ops,
665 .ct_attrs = o2nm_cluster_attrs,
666 .ct_owner = THIS_MODULE,
671 struct o2nm_cluster_group {
672 struct configfs_subsystem cs_subsys;
677 static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group)
680 container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys)
685 static struct config_group *o2nm_cluster_group_make_group(struct config_group *group,
688 struct o2nm_cluster *cluster = NULL;
689 struct o2nm_node_group *ns = NULL;
690 struct config_group *o2hb_group = NULL, *ret = NULL;
692 /* this runs under the parent dir's i_rwsem; there can be only
693 * one caller in here at a time */
694 if (o2nm_single_cluster)
695 return ERR_PTR(-ENOSPC);
697 cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL);
698 ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL);
699 o2hb_group = o2hb_alloc_hb_set();
700 if (cluster == NULL || ns == NULL || o2hb_group == NULL)
703 config_group_init_type_name(&cluster->cl_group, name,
705 configfs_add_default_group(&ns->ns_group, &cluster->cl_group);
707 config_group_init_type_name(&ns->ns_group, "node",
708 &o2nm_node_group_type);
709 configfs_add_default_group(o2hb_group, &cluster->cl_group);
711 rwlock_init(&cluster->cl_nodes_lock);
712 cluster->cl_node_ip_tree = RB_ROOT;
713 cluster->cl_reconnect_delay_ms = O2NET_RECONNECT_DELAY_MS_DEFAULT;
714 cluster->cl_idle_timeout_ms = O2NET_IDLE_TIMEOUT_MS_DEFAULT;
715 cluster->cl_keepalive_delay_ms = O2NET_KEEPALIVE_DELAY_MS_DEFAULT;
716 cluster->cl_fence_method = O2NM_FENCE_RESET;
718 ret = &cluster->cl_group;
719 o2nm_single_cluster = cluster;
725 o2hb_free_hb_set(o2hb_group);
726 ret = ERR_PTR(-ENOMEM);
732 static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item)
734 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
736 BUG_ON(o2nm_single_cluster != cluster);
737 o2nm_single_cluster = NULL;
739 configfs_remove_default_groups(&cluster->cl_group);
740 config_item_put(item);
743 static struct configfs_group_operations o2nm_cluster_group_group_ops = {
744 .make_group = o2nm_cluster_group_make_group,
745 .drop_item = o2nm_cluster_group_drop_item,
748 static const struct config_item_type o2nm_cluster_group_type = {
749 .ct_group_ops = &o2nm_cluster_group_group_ops,
750 .ct_owner = THIS_MODULE,
753 static struct o2nm_cluster_group o2nm_cluster_group = {
757 .ci_namebuf = "cluster",
758 .ci_type = &o2nm_cluster_group_type,
764 static inline void o2nm_lock_subsystem(void)
766 mutex_lock(&o2nm_cluster_group.cs_subsys.su_mutex);
769 static inline void o2nm_unlock_subsystem(void)
771 mutex_unlock(&o2nm_cluster_group.cs_subsys.su_mutex);
774 int o2nm_depend_item(struct config_item *item)
776 return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item);
779 void o2nm_undepend_item(struct config_item *item)
781 configfs_undepend_item(item);
784 int o2nm_depend_this_node(void)
787 struct o2nm_node *local_node;
789 local_node = o2nm_get_node_by_num(o2nm_this_node());
795 ret = o2nm_depend_item(&local_node->nd_item);
796 o2nm_node_put(local_node);
802 void o2nm_undepend_this_node(void)
804 struct o2nm_node *local_node;
806 local_node = o2nm_get_node_by_num(o2nm_this_node());
809 o2nm_undepend_item(&local_node->nd_item);
810 o2nm_node_put(local_node);
814 static void __exit exit_o2nm(void)
816 /* XXX sync with hb callbacks and shut down hb? */
817 o2net_unregister_hb_callbacks();
818 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
825 static int __init init_o2nm(void)
835 ret = o2net_register_hb_callbacks();
839 config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
840 mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex);
841 ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys);
843 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
847 ret = o2cb_sys_init();
851 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
853 o2net_unregister_hb_callbacks();
862 MODULE_AUTHOR("Oracle");
863 MODULE_LICENSE("GPL");
864 MODULE_DESCRIPTION("OCFS2 cluster management");
866 module_init(init_o2nm)
867 module_exit(exit_o2nm)