mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
867 lines
21 KiB
867 lines
21 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Copyright (C) 2004, 2005 Oracle. All rights reserved. |
|
*/ |
|
|
|
#include <linux/slab.h> |
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/configfs.h> |
|
|
|
#include "tcp.h" |
|
#include "nodemanager.h" |
|
#include "heartbeat.h" |
|
#include "masklog.h" |
|
#include "sys.h" |
|
|
|
/* for now we operate under the assertion that there can be only one |
|
* cluster active at a time. Changing this will require trickling |
|
* cluster references throughout where nodes are looked up */ |
|
struct o2nm_cluster *o2nm_single_cluster = NULL; |
|
|
|
static const char *o2nm_fence_method_desc[O2NM_FENCE_METHODS] = { |
|
"reset", /* O2NM_FENCE_RESET */ |
|
"panic", /* O2NM_FENCE_PANIC */ |
|
}; |
|
|
|
static inline void o2nm_lock_subsystem(void); |
|
static inline void o2nm_unlock_subsystem(void); |
|
|
|
struct o2nm_node *o2nm_get_node_by_num(u8 node_num) |
|
{ |
|
struct o2nm_node *node = NULL; |
|
|
|
if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL) |
|
goto out; |
|
|
|
read_lock(&o2nm_single_cluster->cl_nodes_lock); |
|
node = o2nm_single_cluster->cl_nodes[node_num]; |
|
if (node) |
|
config_item_get(&node->nd_item); |
|
read_unlock(&o2nm_single_cluster->cl_nodes_lock); |
|
out: |
|
return node; |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_get_node_by_num); |
|
|
|
int o2nm_configured_node_map(unsigned long *map, unsigned bytes) |
|
{ |
|
struct o2nm_cluster *cluster = o2nm_single_cluster; |
|
|
|
BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap))); |
|
|
|
if (cluster == NULL) |
|
return -EINVAL; |
|
|
|
read_lock(&cluster->cl_nodes_lock); |
|
memcpy(map, cluster->cl_nodes_bitmap, sizeof(cluster->cl_nodes_bitmap)); |
|
read_unlock(&cluster->cl_nodes_lock); |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_configured_node_map); |
|
|
|
static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster, |
|
__be32 ip_needle, |
|
struct rb_node ***ret_p, |
|
struct rb_node **ret_parent) |
|
{ |
|
struct rb_node **p = &cluster->cl_node_ip_tree.rb_node; |
|
struct rb_node *parent = NULL; |
|
struct o2nm_node *node, *ret = NULL; |
|
|
|
while (*p) { |
|
int cmp; |
|
|
|
parent = *p; |
|
node = rb_entry(parent, struct o2nm_node, nd_ip_node); |
|
|
|
cmp = memcmp(&ip_needle, &node->nd_ipv4_address, |
|
sizeof(ip_needle)); |
|
if (cmp < 0) |
|
p = &(*p)->rb_left; |
|
else if (cmp > 0) |
|
p = &(*p)->rb_right; |
|
else { |
|
ret = node; |
|
break; |
|
} |
|
} |
|
|
|
if (ret_p != NULL) |
|
*ret_p = p; |
|
if (ret_parent != NULL) |
|
*ret_parent = parent; |
|
|
|
return ret; |
|
} |
|
|
|
struct o2nm_node *o2nm_get_node_by_ip(__be32 addr) |
|
{ |
|
struct o2nm_node *node = NULL; |
|
struct o2nm_cluster *cluster = o2nm_single_cluster; |
|
|
|
if (cluster == NULL) |
|
goto out; |
|
|
|
read_lock(&cluster->cl_nodes_lock); |
|
node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL); |
|
if (node) |
|
config_item_get(&node->nd_item); |
|
read_unlock(&cluster->cl_nodes_lock); |
|
|
|
out: |
|
return node; |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip); |
|
|
|
void o2nm_node_put(struct o2nm_node *node) |
|
{ |
|
config_item_put(&node->nd_item); |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_node_put); |
|
|
|
void o2nm_node_get(struct o2nm_node *node) |
|
{ |
|
config_item_get(&node->nd_item); |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_node_get); |
|
|
|
u8 o2nm_this_node(void) |
|
{ |
|
u8 node_num = O2NM_MAX_NODES; |
|
|
|
if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local) |
|
node_num = o2nm_single_cluster->cl_local_node; |
|
|
|
return node_num; |
|
} |
|
EXPORT_SYMBOL_GPL(o2nm_this_node); |
|
|
|
/* node configfs bits */ |
|
|
|
static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item) |
|
{ |
|
return item ? |
|
container_of(to_config_group(item), struct o2nm_cluster, |
|
cl_group) |
|
: NULL; |
|
} |
|
|
|
static struct o2nm_node *to_o2nm_node(struct config_item *item) |
|
{ |
|
return item ? container_of(item, struct o2nm_node, nd_item) : NULL; |
|
} |
|
|
|
static void o2nm_node_release(struct config_item *item) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
kfree(node); |
|
} |
|
|
|
static ssize_t o2nm_node_num_show(struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%d\n", to_o2nm_node(item)->nd_num); |
|
} |
|
|
|
static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node) |
|
{ |
|
/* through the first node_set .parent |
|
* mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */ |
|
if (node->nd_item.ci_parent) |
|
return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent); |
|
else |
|
return NULL; |
|
} |
|
|
|
enum { |
|
O2NM_NODE_ATTR_NUM = 0, |
|
O2NM_NODE_ATTR_PORT, |
|
O2NM_NODE_ATTR_ADDRESS, |
|
}; |
|
|
|
static ssize_t o2nm_node_num_store(struct config_item *item, const char *page, |
|
size_t count) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
struct o2nm_cluster *cluster; |
|
unsigned long tmp; |
|
char *p = (char *)page; |
|
int ret = 0; |
|
|
|
tmp = simple_strtoul(p, &p, 0); |
|
if (!p || (*p && (*p != '\n'))) |
|
return -EINVAL; |
|
|
|
if (tmp >= O2NM_MAX_NODES) |
|
return -ERANGE; |
|
|
|
/* once we're in the cl_nodes tree networking can look us up by |
|
* node number and try to use our address and port attributes |
|
* to connect to this node.. make sure that they've been set |
|
* before writing the node attribute? */ |
|
if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) || |
|
!test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) |
|
return -EINVAL; /* XXX */ |
|
|
|
o2nm_lock_subsystem(); |
|
cluster = to_o2nm_cluster_from_node(node); |
|
if (!cluster) { |
|
o2nm_unlock_subsystem(); |
|
return -EINVAL; |
|
} |
|
|
|
write_lock(&cluster->cl_nodes_lock); |
|
if (cluster->cl_nodes[tmp]) |
|
ret = -EEXIST; |
|
else if (test_and_set_bit(O2NM_NODE_ATTR_NUM, |
|
&node->nd_set_attributes)) |
|
ret = -EBUSY; |
|
else { |
|
cluster->cl_nodes[tmp] = node; |
|
node->nd_num = tmp; |
|
set_bit(tmp, cluster->cl_nodes_bitmap); |
|
} |
|
write_unlock(&cluster->cl_nodes_lock); |
|
o2nm_unlock_subsystem(); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
return count; |
|
} |
|
static ssize_t o2nm_node_ipv4_port_show(struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%u\n", ntohs(to_o2nm_node(item)->nd_ipv4_port)); |
|
} |
|
|
|
static ssize_t o2nm_node_ipv4_port_store(struct config_item *item, |
|
const char *page, size_t count) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
unsigned long tmp; |
|
char *p = (char *)page; |
|
|
|
tmp = simple_strtoul(p, &p, 0); |
|
if (!p || (*p && (*p != '\n'))) |
|
return -EINVAL; |
|
|
|
if (tmp == 0) |
|
return -EINVAL; |
|
if (tmp >= (u16)-1) |
|
return -ERANGE; |
|
|
|
if (test_and_set_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) |
|
return -EBUSY; |
|
node->nd_ipv4_port = htons(tmp); |
|
|
|
return count; |
|
} |
|
|
|
static ssize_t o2nm_node_ipv4_address_show(struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%pI4\n", &to_o2nm_node(item)->nd_ipv4_address); |
|
} |
|
|
|
static ssize_t o2nm_node_ipv4_address_store(struct config_item *item, |
|
const char *page, |
|
size_t count) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
struct o2nm_cluster *cluster; |
|
int ret, i; |
|
struct rb_node **p, *parent; |
|
unsigned int octets[4]; |
|
__be32 ipv4_addr = 0; |
|
|
|
ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2], |
|
&octets[1], &octets[0]); |
|
if (ret != 4) |
|
return -EINVAL; |
|
|
|
for (i = 0; i < ARRAY_SIZE(octets); i++) { |
|
if (octets[i] > 255) |
|
return -ERANGE; |
|
be32_add_cpu(&ipv4_addr, octets[i] << (i * 8)); |
|
} |
|
|
|
o2nm_lock_subsystem(); |
|
cluster = to_o2nm_cluster_from_node(node); |
|
if (!cluster) { |
|
o2nm_unlock_subsystem(); |
|
return -EINVAL; |
|
} |
|
|
|
ret = 0; |
|
write_lock(&cluster->cl_nodes_lock); |
|
if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent)) |
|
ret = -EEXIST; |
|
else if (test_and_set_bit(O2NM_NODE_ATTR_ADDRESS, |
|
&node->nd_set_attributes)) |
|
ret = -EBUSY; |
|
else { |
|
rb_link_node(&node->nd_ip_node, parent, p); |
|
rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree); |
|
} |
|
write_unlock(&cluster->cl_nodes_lock); |
|
o2nm_unlock_subsystem(); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr)); |
|
|
|
return count; |
|
} |
|
|
|
static ssize_t o2nm_node_local_show(struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%d\n", to_o2nm_node(item)->nd_local); |
|
} |
|
|
|
static ssize_t o2nm_node_local_store(struct config_item *item, const char *page, |
|
size_t count) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
struct o2nm_cluster *cluster; |
|
unsigned long tmp; |
|
char *p = (char *)page; |
|
ssize_t ret; |
|
|
|
tmp = simple_strtoul(p, &p, 0); |
|
if (!p || (*p && (*p != '\n'))) |
|
return -EINVAL; |
|
|
|
tmp = !!tmp; /* boolean of whether this node wants to be local */ |
|
|
|
/* setting local turns on networking rx for now so we require having |
|
* set everything else first */ |
|
if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) || |
|
!test_bit(O2NM_NODE_ATTR_NUM, &node->nd_set_attributes) || |
|
!test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes)) |
|
return -EINVAL; /* XXX */ |
|
|
|
o2nm_lock_subsystem(); |
|
cluster = to_o2nm_cluster_from_node(node); |
|
if (!cluster) { |
|
ret = -EINVAL; |
|
goto out; |
|
} |
|
|
|
/* the only failure case is trying to set a new local node |
|
* when a different one is already set */ |
|
if (tmp && tmp == cluster->cl_has_local && |
|
cluster->cl_local_node != node->nd_num) { |
|
ret = -EBUSY; |
|
goto out; |
|
} |
|
|
|
/* bring up the rx thread if we're setting the new local node. */ |
|
if (tmp && !cluster->cl_has_local) { |
|
ret = o2net_start_listening(node); |
|
if (ret) |
|
goto out; |
|
} |
|
|
|
if (!tmp && cluster->cl_has_local && |
|
cluster->cl_local_node == node->nd_num) { |
|
o2net_stop_listening(node); |
|
cluster->cl_local_node = O2NM_INVALID_NODE_NUM; |
|
} |
|
|
|
node->nd_local = tmp; |
|
if (node->nd_local) { |
|
cluster->cl_has_local = tmp; |
|
cluster->cl_local_node = node->nd_num; |
|
} |
|
|
|
ret = count; |
|
|
|
out: |
|
o2nm_unlock_subsystem(); |
|
return ret; |
|
} |
|
|
|
CONFIGFS_ATTR(o2nm_node_, num); |
|
CONFIGFS_ATTR(o2nm_node_, ipv4_port); |
|
CONFIGFS_ATTR(o2nm_node_, ipv4_address); |
|
CONFIGFS_ATTR(o2nm_node_, local); |
|
|
|
static struct configfs_attribute *o2nm_node_attrs[] = { |
|
&o2nm_node_attr_num, |
|
&o2nm_node_attr_ipv4_port, |
|
&o2nm_node_attr_ipv4_address, |
|
&o2nm_node_attr_local, |
|
NULL, |
|
}; |
|
|
|
static struct configfs_item_operations o2nm_node_item_ops = { |
|
.release = o2nm_node_release, |
|
}; |
|
|
|
static const struct config_item_type o2nm_node_type = { |
|
.ct_item_ops = &o2nm_node_item_ops, |
|
.ct_attrs = o2nm_node_attrs, |
|
.ct_owner = THIS_MODULE, |
|
}; |
|
|
|
/* node set */ |
|
|
|
struct o2nm_node_group { |
|
struct config_group ns_group; |
|
/* some stuff? */ |
|
}; |
|
|
|
#if 0 |
|
static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group) |
|
{ |
|
return group ? |
|
container_of(group, struct o2nm_node_group, ns_group) |
|
: NULL; |
|
} |
|
#endif |
|
|
|
static ssize_t o2nm_cluster_attr_write(const char *page, ssize_t count, |
|
unsigned int *val) |
|
{ |
|
unsigned long tmp; |
|
char *p = (char *)page; |
|
|
|
tmp = simple_strtoul(p, &p, 0); |
|
if (!p || (*p && (*p != '\n'))) |
|
return -EINVAL; |
|
|
|
if (tmp == 0) |
|
return -EINVAL; |
|
if (tmp >= (u32)-1) |
|
return -ERANGE; |
|
|
|
*val = tmp; |
|
|
|
return count; |
|
} |
|
|
|
static ssize_t o2nm_cluster_idle_timeout_ms_show(struct config_item *item, |
|
char *page) |
|
{ |
|
return sprintf(page, "%u\n", to_o2nm_cluster(item)->cl_idle_timeout_ms); |
|
} |
|
|
|
static ssize_t o2nm_cluster_idle_timeout_ms_store(struct config_item *item, |
|
const char *page, size_t count) |
|
{ |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item); |
|
ssize_t ret; |
|
unsigned int val; |
|
|
|
ret = o2nm_cluster_attr_write(page, count, &val); |
|
|
|
if (ret > 0) { |
|
if (cluster->cl_idle_timeout_ms != val |
|
&& o2net_num_connected_peers()) { |
|
mlog(ML_NOTICE, |
|
"o2net: cannot change idle timeout after " |
|
"the first peer has agreed to it." |
|
" %d connected peers\n", |
|
o2net_num_connected_peers()); |
|
ret = -EINVAL; |
|
} else if (val <= cluster->cl_keepalive_delay_ms) { |
|
mlog(ML_NOTICE, "o2net: idle timeout must be larger " |
|
"than keepalive delay\n"); |
|
ret = -EINVAL; |
|
} else { |
|
cluster->cl_idle_timeout_ms = val; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static ssize_t o2nm_cluster_keepalive_delay_ms_show( |
|
struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%u\n", |
|
to_o2nm_cluster(item)->cl_keepalive_delay_ms); |
|
} |
|
|
|
static ssize_t o2nm_cluster_keepalive_delay_ms_store( |
|
struct config_item *item, const char *page, size_t count) |
|
{ |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item); |
|
ssize_t ret; |
|
unsigned int val; |
|
|
|
ret = o2nm_cluster_attr_write(page, count, &val); |
|
|
|
if (ret > 0) { |
|
if (cluster->cl_keepalive_delay_ms != val |
|
&& o2net_num_connected_peers()) { |
|
mlog(ML_NOTICE, |
|
"o2net: cannot change keepalive delay after" |
|
" the first peer has agreed to it." |
|
" %d connected peers\n", |
|
o2net_num_connected_peers()); |
|
ret = -EINVAL; |
|
} else if (val >= cluster->cl_idle_timeout_ms) { |
|
mlog(ML_NOTICE, "o2net: keepalive delay must be " |
|
"smaller than idle timeout\n"); |
|
ret = -EINVAL; |
|
} else { |
|
cluster->cl_keepalive_delay_ms = val; |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static ssize_t o2nm_cluster_reconnect_delay_ms_show( |
|
struct config_item *item, char *page) |
|
{ |
|
return sprintf(page, "%u\n", |
|
to_o2nm_cluster(item)->cl_reconnect_delay_ms); |
|
} |
|
|
|
static ssize_t o2nm_cluster_reconnect_delay_ms_store( |
|
struct config_item *item, const char *page, size_t count) |
|
{ |
|
return o2nm_cluster_attr_write(page, count, |
|
&to_o2nm_cluster(item)->cl_reconnect_delay_ms); |
|
} |
|
|
|
static ssize_t o2nm_cluster_fence_method_show( |
|
struct config_item *item, char *page) |
|
{ |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item); |
|
ssize_t ret = 0; |
|
|
|
if (cluster) |
|
ret = sprintf(page, "%s\n", |
|
o2nm_fence_method_desc[cluster->cl_fence_method]); |
|
return ret; |
|
} |
|
|
|
static ssize_t o2nm_cluster_fence_method_store( |
|
struct config_item *item, const char *page, size_t count) |
|
{ |
|
unsigned int i; |
|
|
|
if (page[count - 1] != '\n') |
|
goto bail; |
|
|
|
for (i = 0; i < O2NM_FENCE_METHODS; ++i) { |
|
if (count != strlen(o2nm_fence_method_desc[i]) + 1) |
|
continue; |
|
if (strncasecmp(page, o2nm_fence_method_desc[i], count - 1)) |
|
continue; |
|
if (to_o2nm_cluster(item)->cl_fence_method != i) { |
|
printk(KERN_INFO "ocfs2: Changing fence method to %s\n", |
|
o2nm_fence_method_desc[i]); |
|
to_o2nm_cluster(item)->cl_fence_method = i; |
|
} |
|
return count; |
|
} |
|
|
|
bail: |
|
return -EINVAL; |
|
} |
|
|
|
CONFIGFS_ATTR(o2nm_cluster_, idle_timeout_ms); |
|
CONFIGFS_ATTR(o2nm_cluster_, keepalive_delay_ms); |
|
CONFIGFS_ATTR(o2nm_cluster_, reconnect_delay_ms); |
|
CONFIGFS_ATTR(o2nm_cluster_, fence_method); |
|
|
|
static struct configfs_attribute *o2nm_cluster_attrs[] = { |
|
&o2nm_cluster_attr_idle_timeout_ms, |
|
&o2nm_cluster_attr_keepalive_delay_ms, |
|
&o2nm_cluster_attr_reconnect_delay_ms, |
|
&o2nm_cluster_attr_fence_method, |
|
NULL, |
|
}; |
|
|
|
static struct config_item *o2nm_node_group_make_item(struct config_group *group, |
|
const char *name) |
|
{ |
|
struct o2nm_node *node = NULL; |
|
|
|
if (strlen(name) > O2NM_MAX_NAME_LEN) |
|
return ERR_PTR(-ENAMETOOLONG); |
|
|
|
node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL); |
|
if (node == NULL) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */ |
|
config_item_init_type_name(&node->nd_item, name, &o2nm_node_type); |
|
spin_lock_init(&node->nd_lock); |
|
|
|
mlog(ML_CLUSTER, "o2nm: Registering node %s\n", name); |
|
|
|
return &node->nd_item; |
|
} |
|
|
|
static void o2nm_node_group_drop_item(struct config_group *group, |
|
struct config_item *item) |
|
{ |
|
struct o2nm_node *node = to_o2nm_node(item); |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent); |
|
|
|
if (cluster->cl_nodes[node->nd_num] == node) { |
|
o2net_disconnect_node(node); |
|
|
|
if (cluster->cl_has_local && |
|
(cluster->cl_local_node == node->nd_num)) { |
|
cluster->cl_has_local = 0; |
|
cluster->cl_local_node = O2NM_INVALID_NODE_NUM; |
|
o2net_stop_listening(node); |
|
} |
|
} |
|
|
|
/* XXX call into net to stop this node from trading messages */ |
|
|
|
write_lock(&cluster->cl_nodes_lock); |
|
|
|
/* XXX sloppy */ |
|
if (node->nd_ipv4_address) |
|
rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree); |
|
|
|
/* nd_num might be 0 if the node number hasn't been set.. */ |
|
if (cluster->cl_nodes[node->nd_num] == node) { |
|
cluster->cl_nodes[node->nd_num] = NULL; |
|
clear_bit(node->nd_num, cluster->cl_nodes_bitmap); |
|
} |
|
write_unlock(&cluster->cl_nodes_lock); |
|
|
|
mlog(ML_CLUSTER, "o2nm: Unregistered node %s\n", |
|
config_item_name(&node->nd_item)); |
|
|
|
config_item_put(item); |
|
} |
|
|
|
static struct configfs_group_operations o2nm_node_group_group_ops = { |
|
.make_item = o2nm_node_group_make_item, |
|
.drop_item = o2nm_node_group_drop_item, |
|
}; |
|
|
|
static const struct config_item_type o2nm_node_group_type = { |
|
.ct_group_ops = &o2nm_node_group_group_ops, |
|
.ct_owner = THIS_MODULE, |
|
}; |
|
|
|
/* cluster */ |
|
|
|
static void o2nm_cluster_release(struct config_item *item) |
|
{ |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item); |
|
|
|
kfree(cluster); |
|
} |
|
|
|
static struct configfs_item_operations o2nm_cluster_item_ops = { |
|
.release = o2nm_cluster_release, |
|
}; |
|
|
|
static const struct config_item_type o2nm_cluster_type = { |
|
.ct_item_ops = &o2nm_cluster_item_ops, |
|
.ct_attrs = o2nm_cluster_attrs, |
|
.ct_owner = THIS_MODULE, |
|
}; |
|
|
|
/* cluster set */ |
|
|
|
struct o2nm_cluster_group { |
|
struct configfs_subsystem cs_subsys; |
|
/* some stuff? */ |
|
}; |
|
|
|
#if 0 |
|
static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group) |
|
{ |
|
return group ? |
|
container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys) |
|
: NULL; |
|
} |
|
#endif |
|
|
|
static struct config_group *o2nm_cluster_group_make_group(struct config_group *group, |
|
const char *name) |
|
{ |
|
struct o2nm_cluster *cluster = NULL; |
|
struct o2nm_node_group *ns = NULL; |
|
struct config_group *o2hb_group = NULL, *ret = NULL; |
|
|
|
/* this runs under the parent dir's i_rwsem; there can be only |
|
* one caller in here at a time */ |
|
if (o2nm_single_cluster) |
|
return ERR_PTR(-ENOSPC); |
|
|
|
cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL); |
|
ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL); |
|
o2hb_group = o2hb_alloc_hb_set(); |
|
if (cluster == NULL || ns == NULL || o2hb_group == NULL) |
|
goto out; |
|
|
|
config_group_init_type_name(&cluster->cl_group, name, |
|
&o2nm_cluster_type); |
|
configfs_add_default_group(&ns->ns_group, &cluster->cl_group); |
|
|
|
config_group_init_type_name(&ns->ns_group, "node", |
|
&o2nm_node_group_type); |
|
configfs_add_default_group(o2hb_group, &cluster->cl_group); |
|
|
|
rwlock_init(&cluster->cl_nodes_lock); |
|
cluster->cl_node_ip_tree = RB_ROOT; |
|
cluster->cl_reconnect_delay_ms = O2NET_RECONNECT_DELAY_MS_DEFAULT; |
|
cluster->cl_idle_timeout_ms = O2NET_IDLE_TIMEOUT_MS_DEFAULT; |
|
cluster->cl_keepalive_delay_ms = O2NET_KEEPALIVE_DELAY_MS_DEFAULT; |
|
cluster->cl_fence_method = O2NM_FENCE_RESET; |
|
|
|
ret = &cluster->cl_group; |
|
o2nm_single_cluster = cluster; |
|
|
|
out: |
|
if (ret == NULL) { |
|
kfree(cluster); |
|
kfree(ns); |
|
o2hb_free_hb_set(o2hb_group); |
|
ret = ERR_PTR(-ENOMEM); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item) |
|
{ |
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item); |
|
|
|
BUG_ON(o2nm_single_cluster != cluster); |
|
o2nm_single_cluster = NULL; |
|
|
|
configfs_remove_default_groups(&cluster->cl_group); |
|
config_item_put(item); |
|
} |
|
|
|
static struct configfs_group_operations o2nm_cluster_group_group_ops = { |
|
.make_group = o2nm_cluster_group_make_group, |
|
.drop_item = o2nm_cluster_group_drop_item, |
|
}; |
|
|
|
static const struct config_item_type o2nm_cluster_group_type = { |
|
.ct_group_ops = &o2nm_cluster_group_group_ops, |
|
.ct_owner = THIS_MODULE, |
|
}; |
|
|
|
static struct o2nm_cluster_group o2nm_cluster_group = { |
|
.cs_subsys = { |
|
.su_group = { |
|
.cg_item = { |
|
.ci_namebuf = "cluster", |
|
.ci_type = &o2nm_cluster_group_type, |
|
}, |
|
}, |
|
}, |
|
}; |
|
|
|
static inline void o2nm_lock_subsystem(void) |
|
{ |
|
mutex_lock(&o2nm_cluster_group.cs_subsys.su_mutex); |
|
} |
|
|
|
static inline void o2nm_unlock_subsystem(void) |
|
{ |
|
mutex_unlock(&o2nm_cluster_group.cs_subsys.su_mutex); |
|
} |
|
|
|
int o2nm_depend_item(struct config_item *item) |
|
{ |
|
return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item); |
|
} |
|
|
|
void o2nm_undepend_item(struct config_item *item) |
|
{ |
|
configfs_undepend_item(item); |
|
} |
|
|
|
int o2nm_depend_this_node(void) |
|
{ |
|
int ret = 0; |
|
struct o2nm_node *local_node; |
|
|
|
local_node = o2nm_get_node_by_num(o2nm_this_node()); |
|
if (!local_node) { |
|
ret = -EINVAL; |
|
goto out; |
|
} |
|
|
|
ret = o2nm_depend_item(&local_node->nd_item); |
|
o2nm_node_put(local_node); |
|
|
|
out: |
|
return ret; |
|
} |
|
|
|
void o2nm_undepend_this_node(void) |
|
{ |
|
struct o2nm_node *local_node; |
|
|
|
local_node = o2nm_get_node_by_num(o2nm_this_node()); |
|
BUG_ON(!local_node); |
|
|
|
o2nm_undepend_item(&local_node->nd_item); |
|
o2nm_node_put(local_node); |
|
} |
|
|
|
|
|
static void __exit exit_o2nm(void) |
|
{ |
|
/* XXX sync with hb callbacks and shut down hb? */ |
|
o2net_unregister_hb_callbacks(); |
|
configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys); |
|
o2cb_sys_shutdown(); |
|
|
|
o2net_exit(); |
|
o2hb_exit(); |
|
} |
|
|
|
static int __init init_o2nm(void) |
|
{ |
|
int ret; |
|
|
|
o2hb_init(); |
|
|
|
ret = o2net_init(); |
|
if (ret) |
|
goto out_o2hb; |
|
|
|
ret = o2net_register_hb_callbacks(); |
|
if (ret) |
|
goto out_o2net; |
|
|
|
config_group_init(&o2nm_cluster_group.cs_subsys.su_group); |
|
mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex); |
|
ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys); |
|
if (ret) { |
|
printk(KERN_ERR "nodemanager: Registration returned %d\n", ret); |
|
goto out_callbacks; |
|
} |
|
|
|
ret = o2cb_sys_init(); |
|
if (!ret) |
|
goto out; |
|
|
|
configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys); |
|
out_callbacks: |
|
o2net_unregister_hb_callbacks(); |
|
out_o2net: |
|
o2net_exit(); |
|
out_o2hb: |
|
o2hb_exit(); |
|
out: |
|
return ret; |
|
} |
|
|
|
MODULE_AUTHOR("Oracle"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_DESCRIPTION("OCFS2 cluster management"); |
|
|
|
module_init(init_o2nm) |
|
module_exit(exit_o2nm)
|
|
|