2019-05-24 10:04:05 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2021-05-07 01:06:44 +00:00
|
|
|
/*
|
2005-12-15 22:31:23 +00:00
|
|
|
* Copyright (C) 2004, 2005 Oracle. All rights reserved.
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-12-15 22:31:23 +00:00
|
|
|
#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 */
|
2006-12-04 13:04:53 +00:00
|
|
|
struct o2nm_cluster *o2nm_single_cluster = NULL;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2018-08-17 22:44:31 +00:00
|
|
|
static const char *o2nm_fence_method_desc[O2NM_FENCE_METHODS] = {
|
|
|
|
"reset", /* O2NM_FENCE_RESET */
|
|
|
|
"panic", /* O2NM_FENCE_PANIC */
|
2009-11-18 00:29:19 +00:00
|
|
|
};
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
static inline void o2nm_lock_subsystem(void);
|
|
|
|
static inline void o2nm_unlock_subsystem(void);
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
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) {
|
2006-10-12 05:29:33 +00:00
|
|
|
int cmp;
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
parent = *p;
|
|
|
|
node = rb_entry(parent, struct o2nm_node, nd_ip_node);
|
|
|
|
|
2006-10-12 05:29:33 +00:00
|
|
|
cmp = memcmp(&ip_needle, &node->nd_ipv4_address,
|
|
|
|
sizeof(ip_needle));
|
|
|
|
if (cmp < 0)
|
2005-12-15 22:31:23 +00:00
|
|
|
p = &(*p)->rb_left;
|
2006-10-12 05:29:33 +00:00
|
|
|
else if (cmp > 0)
|
2005-12-15 22:31:23 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_num_show(struct config_item *item, char *page)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%d\n", to_o2nm_node(item)->nd_num);
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
2017-11-16 01:31:48 +00:00
|
|
|
if (node->nd_item.ci_parent)
|
|
|
|
return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
|
|
|
|
else
|
|
|
|
return NULL;
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
enum {
|
|
|
|
O2NM_NODE_ATTR_NUM = 0,
|
|
|
|
O2NM_NODE_ATTR_PORT,
|
|
|
|
O2NM_NODE_ATTR_ADDRESS,
|
|
|
|
};
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_num_store(struct config_item *item, const char *page,
|
2005-12-15 22:31:23 +00:00
|
|
|
size_t count)
|
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_node *node = to_o2nm_node(item);
|
2017-11-16 01:31:48 +00:00
|
|
|
struct o2nm_cluster *cluster;
|
2005-12-15 22:31:23 +00:00
|
|
|
unsigned long tmp;
|
|
|
|
char *p = (char *)page;
|
2015-10-03 13:32:57 +00:00
|
|
|
int ret = 0;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
o2nm_lock_subsystem();
|
|
|
|
cluster = to_o2nm_cluster_from_node(node);
|
|
|
|
if (!cluster) {
|
|
|
|
o2nm_unlock_subsystem();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
write_lock(&cluster->cl_nodes_lock);
|
|
|
|
if (cluster->cl_nodes[tmp])
|
2015-10-03 13:32:57 +00:00
|
|
|
ret = -EEXIST;
|
|
|
|
else if (test_and_set_bit(O2NM_NODE_ATTR_NUM,
|
|
|
|
&node->nd_set_attributes))
|
|
|
|
ret = -EBUSY;
|
2005-12-15 22:31:23 +00:00
|
|
|
else {
|
|
|
|
cluster->cl_nodes[tmp] = node;
|
|
|
|
node->nd_num = tmp;
|
|
|
|
set_bit(tmp, cluster->cl_nodes_bitmap);
|
|
|
|
}
|
|
|
|
write_unlock(&cluster->cl_nodes_lock);
|
2017-11-16 01:31:48 +00:00
|
|
|
o2nm_unlock_subsystem();
|
|
|
|
|
2015-10-03 13:32:57 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_ipv4_port_show(struct config_item *item, char *page)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%u\n", ntohs(to_o2nm_node(item)->nd_ipv4_port));
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_ipv4_port_store(struct config_item *item,
|
2005-12-15 22:31:23 +00:00
|
|
|
const char *page, size_t count)
|
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_node *node = to_o2nm_node(item);
|
2005-12-15 22:31:23 +00:00
|
|
|
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;
|
|
|
|
|
2015-10-03 13:32:57 +00:00
|
|
|
if (test_and_set_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
|
|
|
|
return -EBUSY;
|
2005-12-15 22:31:23 +00:00
|
|
|
node->nd_ipv4_port = htons(tmp);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_ipv4_address_show(struct config_item *item, char *page)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%pI4\n", &to_o2nm_node(item)->nd_ipv4_address);
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_ipv4_address_store(struct config_item *item,
|
2005-12-15 22:31:23 +00:00
|
|
|
const char *page,
|
|
|
|
size_t count)
|
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_node *node = to_o2nm_node(item);
|
2017-11-16 01:31:48 +00:00
|
|
|
struct o2nm_cluster *cluster;
|
2005-12-15 22:31:23 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
o2nm_lock_subsystem();
|
|
|
|
cluster = to_o2nm_cluster_from_node(node);
|
|
|
|
if (!cluster) {
|
|
|
|
o2nm_unlock_subsystem();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
ret = 0;
|
|
|
|
write_lock(&cluster->cl_nodes_lock);
|
|
|
|
if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
|
|
|
|
ret = -EEXIST;
|
2015-10-03 13:32:57 +00:00
|
|
|
else if (test_and_set_bit(O2NM_NODE_ATTR_ADDRESS,
|
|
|
|
&node->nd_set_attributes))
|
|
|
|
ret = -EBUSY;
|
2005-12-15 22:31:23 +00:00
|
|
|
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);
|
2017-11-16 01:31:48 +00:00
|
|
|
o2nm_unlock_subsystem();
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr));
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_local_show(struct config_item *item, char *page)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%d\n", to_o2nm_node(item)->nd_local);
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_node_local_store(struct config_item *item, const char *page,
|
2005-12-15 22:31:23 +00:00
|
|
|
size_t count)
|
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_node *node = to_o2nm_node(item);
|
2017-11-16 01:31:48 +00:00
|
|
|
struct o2nm_cluster *cluster;
|
2005-12-15 22:31:23 +00:00
|
|
|
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 */
|
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
o2nm_lock_subsystem();
|
|
|
|
cluster = to_o2nm_cluster_from_node(node);
|
|
|
|
if (!cluster) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
/* 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 &&
|
2017-11-16 01:31:48 +00:00
|
|
|
cluster->cl_local_node != node->nd_num) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
/* 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)
|
2017-11-16 01:31:48 +00:00
|
|
|
goto out;
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
ret = count;
|
|
|
|
|
|
|
|
out:
|
|
|
|
o2nm_unlock_subsystem();
|
|
|
|
return ret;
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
CONFIGFS_ATTR(o2nm_node_, num);
|
|
|
|
CONFIGFS_ATTR(o2nm_node_, ipv4_port);
|
|
|
|
CONFIGFS_ATTR(o2nm_node_, ipv4_address);
|
|
|
|
CONFIGFS_ATTR(o2nm_node_, local);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
static struct configfs_attribute *o2nm_node_attrs[] = {
|
2015-10-03 13:32:58 +00:00
|
|
|
&o2nm_node_attr_num,
|
|
|
|
&o2nm_node_attr_ipv4_port,
|
|
|
|
&o2nm_node_attr_ipv4_address,
|
|
|
|
&o2nm_node_attr_local,
|
2005-12-15 22:31:23 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct configfs_item_operations o2nm_node_item_ops = {
|
|
|
|
.release = o2nm_node_release,
|
|
|
|
};
|
|
|
|
|
2017-10-16 15:18:44 +00:00
|
|
|
static const struct config_item_type o2nm_node_type = {
|
2005-12-15 22:31:23 +00:00
|
|
|
.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
|
|
|
|
|
2006-12-04 13:04:54 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_idle_timeout_ms_show(struct config_item *item,
|
|
|
|
char *page)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%u\n", to_o2nm_cluster(item)->cl_idle_timeout_ms);
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_idle_timeout_ms_store(struct config_item *item,
|
|
|
|
const char *page, size_t count)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item);
|
2006-12-04 13:04:54 +00:00
|
|
|
ssize_t ret;
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
ret = o2nm_cluster_attr_write(page, count, &val);
|
|
|
|
|
|
|
|
if (ret > 0) {
|
2006-12-04 13:04:55 +00:00
|
|
|
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) {
|
2006-12-04 13:04:54 +00:00
|
|
|
mlog(ML_NOTICE, "o2net: idle timeout must be larger "
|
|
|
|
"than keepalive delay\n");
|
2006-12-04 13:04:55 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
} else {
|
|
|
|
cluster->cl_idle_timeout_ms = val;
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_keepalive_delay_ms_show(
|
|
|
|
struct config_item *item, char *page)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%u\n",
|
|
|
|
to_o2nm_cluster(item)->cl_keepalive_delay_ms);
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_keepalive_delay_ms_store(
|
|
|
|
struct config_item *item, const char *page, size_t count)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item);
|
2006-12-04 13:04:54 +00:00
|
|
|
ssize_t ret;
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
ret = o2nm_cluster_attr_write(page, count, &val);
|
|
|
|
|
|
|
|
if (ret > 0) {
|
2006-12-04 13:04:55 +00:00
|
|
|
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) {
|
2006-12-04 13:04:54 +00:00
|
|
|
mlog(ML_NOTICE, "o2net: keepalive delay must be "
|
|
|
|
"smaller than idle timeout\n");
|
2006-12-04 13:04:55 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
} else {
|
|
|
|
cluster->cl_keepalive_delay_ms = val;
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_reconnect_delay_ms_show(
|
|
|
|
struct config_item *item, char *page)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
return sprintf(page, "%u\n",
|
|
|
|
to_o2nm_cluster(item)->cl_reconnect_delay_ms);
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_reconnect_delay_ms_store(
|
|
|
|
struct config_item *item, const char *page, size_t count)
|
2006-12-04 13:04:54 +00:00
|
|
|
{
|
|
|
|
return o2nm_cluster_attr_write(page, count,
|
2015-10-03 13:32:58 +00:00
|
|
|
&to_o2nm_cluster(item)->cl_reconnect_delay_ms);
|
2006-12-04 13:04:54 +00:00
|
|
|
}
|
2009-11-18 00:29:19 +00:00
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_fence_method_show(
|
|
|
|
struct config_item *item, char *page)
|
2009-11-18 00:29:19 +00:00
|
|
|
{
|
2015-10-03 13:32:58 +00:00
|
|
|
struct o2nm_cluster *cluster = to_o2nm_cluster(item);
|
2009-11-18 00:29:19 +00:00
|
|
|
ssize_t ret = 0;
|
|
|
|
|
|
|
|
if (cluster)
|
|
|
|
ret = sprintf(page, "%s\n",
|
|
|
|
o2nm_fence_method_desc[cluster->cl_fence_method]);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
static ssize_t o2nm_cluster_fence_method_store(
|
|
|
|
struct config_item *item, const char *page, size_t count)
|
2009-11-18 00:29:19 +00:00
|
|
|
{
|
|
|
|
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;
|
2015-10-03 13:32:58 +00:00
|
|
|
if (to_o2nm_cluster(item)->cl_fence_method != i) {
|
2009-11-18 00:29:19 +00:00
|
|
|
printk(KERN_INFO "ocfs2: Changing fence method to %s\n",
|
|
|
|
o2nm_fence_method_desc[i]);
|
2015-10-03 13:32:58 +00:00
|
|
|
to_o2nm_cluster(item)->cl_fence_method = i;
|
2009-11-18 00:29:19 +00:00
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
bail:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-10-03 13:32:58 +00:00
|
|
|
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);
|
2009-11-18 00:29:19 +00:00
|
|
|
|
2006-12-04 13:04:54 +00:00
|
|
|
static struct configfs_attribute *o2nm_cluster_attrs[] = {
|
2015-10-03 13:32:58 +00:00
|
|
|
&o2nm_cluster_attr_idle_timeout_ms,
|
|
|
|
&o2nm_cluster_attr_keepalive_delay_ms,
|
|
|
|
&o2nm_cluster_attr_reconnect_delay_ms,
|
|
|
|
&o2nm_cluster_attr_fence_method,
|
2006-12-04 13:04:54 +00:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2008-07-17 21:53:48 +00:00
|
|
|
static struct config_item *o2nm_node_group_make_item(struct config_group *group,
|
|
|
|
const char *name)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
|
|
|
struct o2nm_node *node = NULL;
|
|
|
|
|
2008-07-17 21:53:48 +00:00
|
|
|
if (strlen(name) > O2NM_MAX_NAME_LEN)
|
2008-07-17 22:21:29 +00:00
|
|
|
return ERR_PTR(-ENAMETOOLONG);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2006-12-13 08:34:52 +00:00
|
|
|
node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL);
|
2008-07-17 21:53:48 +00:00
|
|
|
if (node == NULL)
|
2008-07-17 22:21:29 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2010-10-08 00:30:17 +00:00
|
|
|
mlog(ML_CLUSTER, "o2nm: Registering node %s\n", name);
|
|
|
|
|
2008-07-17 22:21:29 +00:00
|
|
|
return &node->nd_item;
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2019-03-05 23:41:41 +00:00
|
|
|
if (cluster->cl_nodes[node->nd_num] == node) {
|
|
|
|
o2net_disconnect_node(node);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2019-03-05 23:41:41 +00:00
|
|
|
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);
|
|
|
|
}
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2010-10-08 00:30:17 +00:00
|
|
|
mlog(ML_CLUSTER, "o2nm: Unregistered node %s\n",
|
|
|
|
config_item_name(&node->nd_item));
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
2017-10-16 15:18:44 +00:00
|
|
|
static const struct config_item_type o2nm_node_group_type = {
|
2005-12-15 22:31:23 +00:00
|
|
|
.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,
|
|
|
|
};
|
|
|
|
|
2017-10-16 15:18:44 +00:00
|
|
|
static const struct config_item_type o2nm_cluster_type = {
|
2005-12-15 22:31:23 +00:00
|
|
|
.ct_item_ops = &o2nm_cluster_item_ops,
|
2006-12-04 13:04:54 +00:00
|
|
|
.ct_attrs = o2nm_cluster_attrs,
|
2005-12-15 22:31:23 +00:00
|
|
|
.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
|
|
|
|
|
2008-07-17 21:53:48 +00:00
|
|
|
static struct config_group *o2nm_cluster_group_make_group(struct config_group *group,
|
|
|
|
const char *name)
|
2005-12-15 22:31:23 +00:00
|
|
|
{
|
|
|
|
struct o2nm_cluster *cluster = NULL;
|
|
|
|
struct o2nm_node_group *ns = NULL;
|
2008-07-17 21:53:48 +00:00
|
|
|
struct config_group *o2hb_group = NULL, *ret = NULL;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2006-01-09 23:59:24 +00:00
|
|
|
/* this runs under the parent dir's i_mutex; there can be only
|
2005-12-15 22:31:23 +00:00
|
|
|
* one caller in here at a time */
|
2008-07-17 21:53:48 +00:00
|
|
|
if (o2nm_single_cluster)
|
2008-07-17 22:21:29 +00:00
|
|
|
return ERR_PTR(-ENOSPC);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2006-12-13 08:34:52 +00:00
|
|
|
cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL);
|
|
|
|
ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL);
|
2005-12-15 22:31:23 +00:00
|
|
|
o2hb_group = o2hb_alloc_hb_set();
|
2016-02-26 10:02:14 +00:00
|
|
|
if (cluster == NULL || ns == NULL || o2hb_group == NULL)
|
2005-12-15 22:31:23 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
config_group_init_type_name(&cluster->cl_group, name,
|
|
|
|
&o2nm_cluster_type);
|
2016-02-26 10:02:14 +00:00
|
|
|
configfs_add_default_group(&ns->ns_group, &cluster->cl_group);
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
config_group_init_type_name(&ns->ns_group, "node",
|
|
|
|
&o2nm_node_group_type);
|
2016-02-26 10:02:14 +00:00
|
|
|
configfs_add_default_group(o2hb_group, &cluster->cl_group);
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
rwlock_init(&cluster->cl_nodes_lock);
|
|
|
|
cluster->cl_node_ip_tree = RB_ROOT;
|
2006-12-04 13:04:54 +00:00
|
|
|
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;
|
2009-11-18 00:29:19 +00:00
|
|
|
cluster->cl_fence_method = O2NM_FENCE_RESET;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2008-07-17 21:53:48 +00:00
|
|
|
ret = &cluster->cl_group;
|
2005-12-15 22:31:23 +00:00
|
|
|
o2nm_single_cluster = cluster;
|
|
|
|
|
|
|
|
out:
|
2008-07-17 21:53:48 +00:00
|
|
|
if (ret == NULL) {
|
2005-12-15 22:31:23 +00:00
|
|
|
kfree(cluster);
|
|
|
|
kfree(ns);
|
|
|
|
o2hb_free_hb_set(o2hb_group);
|
2008-07-17 22:21:29 +00:00
|
|
|
ret = ERR_PTR(-ENOMEM);
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2016-02-26 10:02:14 +00:00
|
|
|
configfs_remove_default_groups(&cluster->cl_group);
|
2005-12-15 22:31:23 +00:00
|
|
|
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,
|
|
|
|
};
|
|
|
|
|
2017-10-16 15:18:44 +00:00
|
|
|
static const struct config_item_type o2nm_cluster_group_type = {
|
2005-12-15 22:31:23 +00:00
|
|
|
.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,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2017-11-16 01:31:48 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-06-15 04:40:49 +00:00
|
|
|
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)
|
|
|
|
{
|
2015-12-11 15:06:09 +00:00
|
|
|
configfs_undepend_item(item);
|
2007-06-15 04:40:49 +00:00
|
|
|
}
|
|
|
|
|
2007-06-19 18:34:03 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-12-15 22:31:23 +00:00
|
|
|
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();
|
2008-12-17 22:17:42 +00:00
|
|
|
o2hb_exit();
|
2005-12-15 22:31:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int __init init_o2nm(void)
|
|
|
|
{
|
2021-06-29 02:34:14 +00:00
|
|
|
int ret;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
2019-07-12 03:53:12 +00:00
|
|
|
o2hb_init();
|
2008-04-14 17:46:19 +00:00
|
|
|
|
|
|
|
ret = o2net_init();
|
|
|
|
if (ret)
|
2008-12-17 22:17:42 +00:00
|
|
|
goto out_o2hb;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
ret = o2net_register_hb_callbacks();
|
|
|
|
if (ret)
|
2008-05-30 22:30:49 +00:00
|
|
|
goto out_o2net;
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
|
2007-07-07 06:33:17 +00:00
|
|
|
mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex);
|
2005-12-15 22:31:23 +00:00
|
|
|
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();
|
2006-02-22 00:54:00 +00:00
|
|
|
out_o2net:
|
|
|
|
o2net_exit();
|
2008-12-17 22:17:42 +00:00
|
|
|
out_o2hb:
|
|
|
|
o2hb_exit();
|
2005-12-15 22:31:23 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Oracle");
|
|
|
|
MODULE_LICENSE("GPL");
|
2014-01-21 23:48:20 +00:00
|
|
|
MODULE_DESCRIPTION("OCFS2 cluster management");
|
2005-12-15 22:31:23 +00:00
|
|
|
|
|
|
|
module_init(init_o2nm)
|
|
|
|
module_exit(exit_o2nm)
|