1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
4 * Copyright (C) 2004, 2005 Oracle. All rights reserved.
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.
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.
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.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/configfs.h>
27 #include "nodemanager.h"
28 #include "heartbeat.h"
33 /* for now we operate under the assertion that there can be only one
34 * cluster active at a time. Changing this will require trickling
35 * cluster references throughout where nodes are looked up */
36 struct o2nm_cluster
*o2nm_single_cluster
= NULL
;
39 struct o2nm_node
*o2nm_get_node_by_num(u8 node_num
)
41 struct o2nm_node
*node
= NULL
;
43 if (node_num
>= O2NM_MAX_NODES
|| o2nm_single_cluster
== NULL
)
46 read_lock(&o2nm_single_cluster
->cl_nodes_lock
);
47 node
= o2nm_single_cluster
->cl_nodes
[node_num
];
49 config_item_get(&node
->nd_item
);
50 read_unlock(&o2nm_single_cluster
->cl_nodes_lock
);
54 EXPORT_SYMBOL_GPL(o2nm_get_node_by_num
);
56 int o2nm_configured_node_map(unsigned long *map
, unsigned bytes
)
58 struct o2nm_cluster
*cluster
= o2nm_single_cluster
;
60 BUG_ON(bytes
< (sizeof(cluster
->cl_nodes_bitmap
)));
65 read_lock(&cluster
->cl_nodes_lock
);
66 memcpy(map
, cluster
->cl_nodes_bitmap
, sizeof(cluster
->cl_nodes_bitmap
));
67 read_unlock(&cluster
->cl_nodes_lock
);
71 EXPORT_SYMBOL_GPL(o2nm_configured_node_map
);
73 static struct o2nm_node
*o2nm_node_ip_tree_lookup(struct o2nm_cluster
*cluster
,
75 struct rb_node
***ret_p
,
76 struct rb_node
**ret_parent
)
78 struct rb_node
**p
= &cluster
->cl_node_ip_tree
.rb_node
;
79 struct rb_node
*parent
= NULL
;
80 struct o2nm_node
*node
, *ret
= NULL
;
86 node
= rb_entry(parent
, struct o2nm_node
, nd_ip_node
);
88 cmp
= memcmp(&ip_needle
, &node
->nd_ipv4_address
,
102 if (ret_parent
!= NULL
)
103 *ret_parent
= parent
;
108 struct o2nm_node
*o2nm_get_node_by_ip(__be32 addr
)
110 struct o2nm_node
*node
= NULL
;
111 struct o2nm_cluster
*cluster
= o2nm_single_cluster
;
116 read_lock(&cluster
->cl_nodes_lock
);
117 node
= o2nm_node_ip_tree_lookup(cluster
, addr
, NULL
, NULL
);
119 config_item_get(&node
->nd_item
);
120 read_unlock(&cluster
->cl_nodes_lock
);
125 EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip
);
127 void o2nm_node_put(struct o2nm_node
*node
)
129 config_item_put(&node
->nd_item
);
131 EXPORT_SYMBOL_GPL(o2nm_node_put
);
133 void o2nm_node_get(struct o2nm_node
*node
)
135 config_item_get(&node
->nd_item
);
137 EXPORT_SYMBOL_GPL(o2nm_node_get
);
139 u8
o2nm_this_node(void)
141 u8 node_num
= O2NM_MAX_NODES
;
143 if (o2nm_single_cluster
&& o2nm_single_cluster
->cl_has_local
)
144 node_num
= o2nm_single_cluster
->cl_local_node
;
148 EXPORT_SYMBOL_GPL(o2nm_this_node
);
150 /* node configfs bits */
152 static struct o2nm_cluster
*to_o2nm_cluster(struct config_item
*item
)
155 container_of(to_config_group(item
), struct o2nm_cluster
,
160 static struct o2nm_node
*to_o2nm_node(struct config_item
*item
)
162 return item
? container_of(item
, struct o2nm_node
, nd_item
) : NULL
;
165 static void o2nm_node_release(struct config_item
*item
)
167 struct o2nm_node
*node
= to_o2nm_node(item
);
171 static ssize_t
o2nm_node_num_read(struct o2nm_node
*node
, char *page
)
173 return sprintf(page
, "%d\n", node
->nd_num
);
176 static struct o2nm_cluster
*to_o2nm_cluster_from_node(struct o2nm_node
*node
)
178 /* through the first node_set .parent
179 * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */
180 return to_o2nm_cluster(node
->nd_item
.ci_parent
->ci_parent
);
184 O2NM_NODE_ATTR_NUM
= 0,
186 O2NM_NODE_ATTR_ADDRESS
,
187 O2NM_NODE_ATTR_LOCAL
,
190 static ssize_t
o2nm_node_num_write(struct o2nm_node
*node
, const char *page
,
193 struct o2nm_cluster
*cluster
= to_o2nm_cluster_from_node(node
);
195 char *p
= (char *)page
;
197 tmp
= simple_strtoul(p
, &p
, 0);
198 if (!p
|| (*p
&& (*p
!= '\n')))
201 if (tmp
>= O2NM_MAX_NODES
)
204 /* once we're in the cl_nodes tree networking can look us up by
205 * node number and try to use our address and port attributes
206 * to connect to this node.. make sure that they've been set
207 * before writing the node attribute? */
208 if (!test_bit(O2NM_NODE_ATTR_ADDRESS
, &node
->nd_set_attributes
) ||
209 !test_bit(O2NM_NODE_ATTR_PORT
, &node
->nd_set_attributes
))
210 return -EINVAL
; /* XXX */
212 write_lock(&cluster
->cl_nodes_lock
);
213 if (cluster
->cl_nodes
[tmp
])
216 cluster
->cl_nodes
[tmp
] = node
;
218 set_bit(tmp
, cluster
->cl_nodes_bitmap
);
220 write_unlock(&cluster
->cl_nodes_lock
);
226 static ssize_t
o2nm_node_ipv4_port_read(struct o2nm_node
*node
, char *page
)
228 return sprintf(page
, "%u\n", ntohs(node
->nd_ipv4_port
));
231 static ssize_t
o2nm_node_ipv4_port_write(struct o2nm_node
*node
,
232 const char *page
, size_t count
)
235 char *p
= (char *)page
;
237 tmp
= simple_strtoul(p
, &p
, 0);
238 if (!p
|| (*p
&& (*p
!= '\n')))
246 node
->nd_ipv4_port
= htons(tmp
);
251 static ssize_t
o2nm_node_ipv4_address_read(struct o2nm_node
*node
, char *page
)
253 return sprintf(page
, "%u.%u.%u.%u\n", NIPQUAD(node
->nd_ipv4_address
));
256 static ssize_t
o2nm_node_ipv4_address_write(struct o2nm_node
*node
,
260 struct o2nm_cluster
*cluster
= to_o2nm_cluster_from_node(node
);
262 struct rb_node
**p
, *parent
;
263 unsigned int octets
[4];
264 __be32 ipv4_addr
= 0;
266 ret
= sscanf(page
, "%3u.%3u.%3u.%3u", &octets
[3], &octets
[2],
267 &octets
[1], &octets
[0]);
271 for (i
= 0; i
< ARRAY_SIZE(octets
); i
++) {
274 be32_add_cpu(&ipv4_addr
, octets
[i
] << (i
* 8));
278 write_lock(&cluster
->cl_nodes_lock
);
279 if (o2nm_node_ip_tree_lookup(cluster
, ipv4_addr
, &p
, &parent
))
282 rb_link_node(&node
->nd_ip_node
, parent
, p
);
283 rb_insert_color(&node
->nd_ip_node
, &cluster
->cl_node_ip_tree
);
285 write_unlock(&cluster
->cl_nodes_lock
);
289 memcpy(&node
->nd_ipv4_address
, &ipv4_addr
, sizeof(ipv4_addr
));
294 static ssize_t
o2nm_node_local_read(struct o2nm_node
*node
, char *page
)
296 return sprintf(page
, "%d\n", node
->nd_local
);
299 static ssize_t
o2nm_node_local_write(struct o2nm_node
*node
, const char *page
,
302 struct o2nm_cluster
*cluster
= to_o2nm_cluster_from_node(node
);
304 char *p
= (char *)page
;
307 tmp
= simple_strtoul(p
, &p
, 0);
308 if (!p
|| (*p
&& (*p
!= '\n')))
311 tmp
= !!tmp
; /* boolean of whether this node wants to be local */
313 /* setting local turns on networking rx for now so we require having
314 * set everything else first */
315 if (!test_bit(O2NM_NODE_ATTR_ADDRESS
, &node
->nd_set_attributes
) ||
316 !test_bit(O2NM_NODE_ATTR_NUM
, &node
->nd_set_attributes
) ||
317 !test_bit(O2NM_NODE_ATTR_PORT
, &node
->nd_set_attributes
))
318 return -EINVAL
; /* XXX */
320 /* the only failure case is trying to set a new local node
321 * when a different one is already set */
322 if (tmp
&& tmp
== cluster
->cl_has_local
&&
323 cluster
->cl_local_node
!= node
->nd_num
)
326 /* bring up the rx thread if we're setting the new local node. */
327 if (tmp
&& !cluster
->cl_has_local
) {
328 ret
= o2net_start_listening(node
);
333 if (!tmp
&& cluster
->cl_has_local
&&
334 cluster
->cl_local_node
== node
->nd_num
) {
335 o2net_stop_listening(node
);
336 cluster
->cl_local_node
= O2NM_INVALID_NODE_NUM
;
339 node
->nd_local
= tmp
;
340 if (node
->nd_local
) {
341 cluster
->cl_has_local
= tmp
;
342 cluster
->cl_local_node
= node
->nd_num
;
348 struct o2nm_node_attribute
{
349 struct configfs_attribute attr
;
350 ssize_t (*show
)(struct o2nm_node
*, char *);
351 ssize_t (*store
)(struct o2nm_node
*, const char *, size_t);
354 static struct o2nm_node_attribute o2nm_node_attr_num
= {
355 .attr
= { .ca_owner
= THIS_MODULE
,
357 .ca_mode
= S_IRUGO
| S_IWUSR
},
358 .show
= o2nm_node_num_read
,
359 .store
= o2nm_node_num_write
,
362 static struct o2nm_node_attribute o2nm_node_attr_ipv4_port
= {
363 .attr
= { .ca_owner
= THIS_MODULE
,
364 .ca_name
= "ipv4_port",
365 .ca_mode
= S_IRUGO
| S_IWUSR
},
366 .show
= o2nm_node_ipv4_port_read
,
367 .store
= o2nm_node_ipv4_port_write
,
370 static struct o2nm_node_attribute o2nm_node_attr_ipv4_address
= {
371 .attr
= { .ca_owner
= THIS_MODULE
,
372 .ca_name
= "ipv4_address",
373 .ca_mode
= S_IRUGO
| S_IWUSR
},
374 .show
= o2nm_node_ipv4_address_read
,
375 .store
= o2nm_node_ipv4_address_write
,
378 static struct o2nm_node_attribute o2nm_node_attr_local
= {
379 .attr
= { .ca_owner
= THIS_MODULE
,
381 .ca_mode
= S_IRUGO
| S_IWUSR
},
382 .show
= o2nm_node_local_read
,
383 .store
= o2nm_node_local_write
,
386 static struct configfs_attribute
*o2nm_node_attrs
[] = {
387 [O2NM_NODE_ATTR_NUM
] = &o2nm_node_attr_num
.attr
,
388 [O2NM_NODE_ATTR_PORT
] = &o2nm_node_attr_ipv4_port
.attr
,
389 [O2NM_NODE_ATTR_ADDRESS
] = &o2nm_node_attr_ipv4_address
.attr
,
390 [O2NM_NODE_ATTR_LOCAL
] = &o2nm_node_attr_local
.attr
,
394 static int o2nm_attr_index(struct configfs_attribute
*attr
)
397 for (i
= 0; i
< ARRAY_SIZE(o2nm_node_attrs
); i
++) {
398 if (attr
== o2nm_node_attrs
[i
])
405 static ssize_t
o2nm_node_show(struct config_item
*item
,
406 struct configfs_attribute
*attr
,
409 struct o2nm_node
*node
= to_o2nm_node(item
);
410 struct o2nm_node_attribute
*o2nm_node_attr
=
411 container_of(attr
, struct o2nm_node_attribute
, attr
);
414 if (o2nm_node_attr
->show
)
415 ret
= o2nm_node_attr
->show(node
, page
);
419 static ssize_t
o2nm_node_store(struct config_item
*item
,
420 struct configfs_attribute
*attr
,
421 const char *page
, size_t count
)
423 struct o2nm_node
*node
= to_o2nm_node(item
);
424 struct o2nm_node_attribute
*o2nm_node_attr
=
425 container_of(attr
, struct o2nm_node_attribute
, attr
);
427 int attr_index
= o2nm_attr_index(attr
);
429 if (o2nm_node_attr
->store
== NULL
) {
434 if (test_bit(attr_index
, &node
->nd_set_attributes
))
437 ret
= o2nm_node_attr
->store(node
, page
, count
);
441 set_bit(attr_index
, &node
->nd_set_attributes
);
446 static struct configfs_item_operations o2nm_node_item_ops
= {
447 .release
= o2nm_node_release
,
448 .show_attribute
= o2nm_node_show
,
449 .store_attribute
= o2nm_node_store
,
452 static struct config_item_type o2nm_node_type
= {
453 .ct_item_ops
= &o2nm_node_item_ops
,
454 .ct_attrs
= o2nm_node_attrs
,
455 .ct_owner
= THIS_MODULE
,
460 struct o2nm_node_group
{
461 struct config_group ns_group
;
466 static struct o2nm_node_group
*to_o2nm_node_group(struct config_group
*group
)
469 container_of(group
, struct o2nm_node_group
, ns_group
)
474 struct o2nm_cluster_attribute
{
475 struct configfs_attribute attr
;
476 ssize_t (*show
)(struct o2nm_cluster
*, char *);
477 ssize_t (*store
)(struct o2nm_cluster
*, const char *, size_t);
480 static ssize_t
o2nm_cluster_attr_write(const char *page
, ssize_t count
,
484 char *p
= (char *)page
;
486 tmp
= simple_strtoul(p
, &p
, 0);
487 if (!p
|| (*p
&& (*p
!= '\n')))
500 static ssize_t
o2nm_cluster_attr_idle_timeout_ms_read(
501 struct o2nm_cluster
*cluster
, char *page
)
503 return sprintf(page
, "%u\n", cluster
->cl_idle_timeout_ms
);
506 static ssize_t
o2nm_cluster_attr_idle_timeout_ms_write(
507 struct o2nm_cluster
*cluster
, const char *page
, size_t count
)
512 ret
= o2nm_cluster_attr_write(page
, count
, &val
);
515 if (cluster
->cl_idle_timeout_ms
!= val
516 && o2net_num_connected_peers()) {
518 "o2net: cannot change idle timeout after "
519 "the first peer has agreed to it."
520 " %d connected peers\n",
521 o2net_num_connected_peers());
523 } else if (val
<= cluster
->cl_keepalive_delay_ms
) {
524 mlog(ML_NOTICE
, "o2net: idle timeout must be larger "
525 "than keepalive delay\n");
528 cluster
->cl_idle_timeout_ms
= val
;
535 static ssize_t
o2nm_cluster_attr_keepalive_delay_ms_read(
536 struct o2nm_cluster
*cluster
, char *page
)
538 return sprintf(page
, "%u\n", cluster
->cl_keepalive_delay_ms
);
541 static ssize_t
o2nm_cluster_attr_keepalive_delay_ms_write(
542 struct o2nm_cluster
*cluster
, const char *page
, size_t count
)
547 ret
= o2nm_cluster_attr_write(page
, count
, &val
);
550 if (cluster
->cl_keepalive_delay_ms
!= val
551 && o2net_num_connected_peers()) {
553 "o2net: cannot change keepalive delay after"
554 " the first peer has agreed to it."
555 " %d connected peers\n",
556 o2net_num_connected_peers());
558 } else if (val
>= cluster
->cl_idle_timeout_ms
) {
559 mlog(ML_NOTICE
, "o2net: keepalive delay must be "
560 "smaller than idle timeout\n");
563 cluster
->cl_keepalive_delay_ms
= val
;
570 static ssize_t
o2nm_cluster_attr_reconnect_delay_ms_read(
571 struct o2nm_cluster
*cluster
, char *page
)
573 return sprintf(page
, "%u\n", cluster
->cl_reconnect_delay_ms
);
576 static ssize_t
o2nm_cluster_attr_reconnect_delay_ms_write(
577 struct o2nm_cluster
*cluster
, const char *page
, size_t count
)
579 return o2nm_cluster_attr_write(page
, count
,
580 &cluster
->cl_reconnect_delay_ms
);
582 static struct o2nm_cluster_attribute o2nm_cluster_attr_idle_timeout_ms
= {
583 .attr
= { .ca_owner
= THIS_MODULE
,
584 .ca_name
= "idle_timeout_ms",
585 .ca_mode
= S_IRUGO
| S_IWUSR
},
586 .show
= o2nm_cluster_attr_idle_timeout_ms_read
,
587 .store
= o2nm_cluster_attr_idle_timeout_ms_write
,
590 static struct o2nm_cluster_attribute o2nm_cluster_attr_keepalive_delay_ms
= {
591 .attr
= { .ca_owner
= THIS_MODULE
,
592 .ca_name
= "keepalive_delay_ms",
593 .ca_mode
= S_IRUGO
| S_IWUSR
},
594 .show
= o2nm_cluster_attr_keepalive_delay_ms_read
,
595 .store
= o2nm_cluster_attr_keepalive_delay_ms_write
,
598 static struct o2nm_cluster_attribute o2nm_cluster_attr_reconnect_delay_ms
= {
599 .attr
= { .ca_owner
= THIS_MODULE
,
600 .ca_name
= "reconnect_delay_ms",
601 .ca_mode
= S_IRUGO
| S_IWUSR
},
602 .show
= o2nm_cluster_attr_reconnect_delay_ms_read
,
603 .store
= o2nm_cluster_attr_reconnect_delay_ms_write
,
606 static struct configfs_attribute
*o2nm_cluster_attrs
[] = {
607 &o2nm_cluster_attr_idle_timeout_ms
.attr
,
608 &o2nm_cluster_attr_keepalive_delay_ms
.attr
,
609 &o2nm_cluster_attr_reconnect_delay_ms
.attr
,
612 static ssize_t
o2nm_cluster_show(struct config_item
*item
,
613 struct configfs_attribute
*attr
,
616 struct o2nm_cluster
*cluster
= to_o2nm_cluster(item
);
617 struct o2nm_cluster_attribute
*o2nm_cluster_attr
=
618 container_of(attr
, struct o2nm_cluster_attribute
, attr
);
621 if (o2nm_cluster_attr
->show
)
622 ret
= o2nm_cluster_attr
->show(cluster
, page
);
626 static ssize_t
o2nm_cluster_store(struct config_item
*item
,
627 struct configfs_attribute
*attr
,
628 const char *page
, size_t count
)
630 struct o2nm_cluster
*cluster
= to_o2nm_cluster(item
);
631 struct o2nm_cluster_attribute
*o2nm_cluster_attr
=
632 container_of(attr
, struct o2nm_cluster_attribute
, attr
);
635 if (o2nm_cluster_attr
->store
== NULL
) {
640 ret
= o2nm_cluster_attr
->store(cluster
, page
, count
);
647 static int o2nm_node_group_make_item(struct config_group
*group
,
649 struct config_item
**new_item
)
651 struct o2nm_node
*node
= NULL
;
654 if (strlen(name
) > O2NM_MAX_NAME_LEN
) {
659 node
= kzalloc(sizeof(struct o2nm_node
), GFP_KERNEL
);
665 strcpy(node
->nd_name
, name
); /* use item.ci_namebuf instead? */
666 config_item_init_type_name(&node
->nd_item
, name
, &o2nm_node_type
);
667 spin_lock_init(&node
->nd_lock
);
669 *new_item
= &node
->nd_item
;
678 static void o2nm_node_group_drop_item(struct config_group
*group
,
679 struct config_item
*item
)
681 struct o2nm_node
*node
= to_o2nm_node(item
);
682 struct o2nm_cluster
*cluster
= to_o2nm_cluster(group
->cg_item
.ci_parent
);
684 o2net_disconnect_node(node
);
686 if (cluster
->cl_has_local
&&
687 (cluster
->cl_local_node
== node
->nd_num
)) {
688 cluster
->cl_has_local
= 0;
689 cluster
->cl_local_node
= O2NM_INVALID_NODE_NUM
;
690 o2net_stop_listening(node
);
693 /* XXX call into net to stop this node from trading messages */
695 write_lock(&cluster
->cl_nodes_lock
);
698 if (node
->nd_ipv4_address
)
699 rb_erase(&node
->nd_ip_node
, &cluster
->cl_node_ip_tree
);
701 /* nd_num might be 0 if the node number hasn't been set.. */
702 if (cluster
->cl_nodes
[node
->nd_num
] == node
) {
703 cluster
->cl_nodes
[node
->nd_num
] = NULL
;
704 clear_bit(node
->nd_num
, cluster
->cl_nodes_bitmap
);
706 write_unlock(&cluster
->cl_nodes_lock
);
708 config_item_put(item
);
711 static struct configfs_group_operations o2nm_node_group_group_ops
= {
712 .make_item
= o2nm_node_group_make_item
,
713 .drop_item
= o2nm_node_group_drop_item
,
716 static struct config_item_type o2nm_node_group_type
= {
717 .ct_group_ops
= &o2nm_node_group_group_ops
,
718 .ct_owner
= THIS_MODULE
,
723 static void o2nm_cluster_release(struct config_item
*item
)
725 struct o2nm_cluster
*cluster
= to_o2nm_cluster(item
);
727 kfree(cluster
->cl_group
.default_groups
);
731 static struct configfs_item_operations o2nm_cluster_item_ops
= {
732 .release
= o2nm_cluster_release
,
733 .show_attribute
= o2nm_cluster_show
,
734 .store_attribute
= o2nm_cluster_store
,
737 static struct config_item_type o2nm_cluster_type
= {
738 .ct_item_ops
= &o2nm_cluster_item_ops
,
739 .ct_attrs
= o2nm_cluster_attrs
,
740 .ct_owner
= THIS_MODULE
,
745 struct o2nm_cluster_group
{
746 struct configfs_subsystem cs_subsys
;
751 static struct o2nm_cluster_group
*to_o2nm_cluster_group(struct config_group
*group
)
754 container_of(to_configfs_subsystem(group
), struct o2nm_cluster_group
, cs_subsys
)
759 static int o2nm_cluster_group_make_group(struct config_group
*group
,
761 struct config_group
**new_group
)
763 struct o2nm_cluster
*cluster
= NULL
;
764 struct o2nm_node_group
*ns
= NULL
;
765 struct config_group
*o2hb_group
= NULL
;
769 /* this runs under the parent dir's i_mutex; there can be only
770 * one caller in here at a time */
771 if (o2nm_single_cluster
) {
776 cluster
= kzalloc(sizeof(struct o2nm_cluster
), GFP_KERNEL
);
777 ns
= kzalloc(sizeof(struct o2nm_node_group
), GFP_KERNEL
);
778 defs
= kcalloc(3, sizeof(struct config_group
*), GFP_KERNEL
);
779 o2hb_group
= o2hb_alloc_hb_set();
780 if (cluster
== NULL
|| ns
== NULL
|| o2hb_group
== NULL
|| defs
== NULL
) {
785 config_group_init_type_name(&cluster
->cl_group
, name
,
787 config_group_init_type_name(&ns
->ns_group
, "node",
788 &o2nm_node_group_type
);
790 cluster
->cl_group
.default_groups
= defs
;
791 cluster
->cl_group
.default_groups
[0] = &ns
->ns_group
;
792 cluster
->cl_group
.default_groups
[1] = o2hb_group
;
793 cluster
->cl_group
.default_groups
[2] = NULL
;
794 rwlock_init(&cluster
->cl_nodes_lock
);
795 cluster
->cl_node_ip_tree
= RB_ROOT
;
796 cluster
->cl_reconnect_delay_ms
= O2NET_RECONNECT_DELAY_MS_DEFAULT
;
797 cluster
->cl_idle_timeout_ms
= O2NET_IDLE_TIMEOUT_MS_DEFAULT
;
798 cluster
->cl_keepalive_delay_ms
= O2NET_KEEPALIVE_DELAY_MS_DEFAULT
;
800 *new_group
= &cluster
->cl_group
;
801 o2nm_single_cluster
= cluster
;
807 o2hb_free_hb_set(o2hb_group
);
814 static void o2nm_cluster_group_drop_item(struct config_group
*group
, struct config_item
*item
)
816 struct o2nm_cluster
*cluster
= to_o2nm_cluster(item
);
818 struct config_item
*killme
;
820 BUG_ON(o2nm_single_cluster
!= cluster
);
821 o2nm_single_cluster
= NULL
;
823 for (i
= 0; cluster
->cl_group
.default_groups
[i
]; i
++) {
824 killme
= &cluster
->cl_group
.default_groups
[i
]->cg_item
;
825 cluster
->cl_group
.default_groups
[i
] = NULL
;
826 config_item_put(killme
);
829 config_item_put(item
);
832 static struct configfs_group_operations o2nm_cluster_group_group_ops
= {
833 .make_group
= o2nm_cluster_group_make_group
,
834 .drop_item
= o2nm_cluster_group_drop_item
,
837 static struct config_item_type o2nm_cluster_group_type
= {
838 .ct_group_ops
= &o2nm_cluster_group_group_ops
,
839 .ct_owner
= THIS_MODULE
,
842 static struct o2nm_cluster_group o2nm_cluster_group
= {
846 .ci_namebuf
= "cluster",
847 .ci_type
= &o2nm_cluster_group_type
,
853 int o2nm_depend_item(struct config_item
*item
)
855 return configfs_depend_item(&o2nm_cluster_group
.cs_subsys
, item
);
858 void o2nm_undepend_item(struct config_item
*item
)
860 configfs_undepend_item(&o2nm_cluster_group
.cs_subsys
, item
);
863 int o2nm_depend_this_node(void)
866 struct o2nm_node
*local_node
;
868 local_node
= o2nm_get_node_by_num(o2nm_this_node());
874 ret
= o2nm_depend_item(&local_node
->nd_item
);
875 o2nm_node_put(local_node
);
881 void o2nm_undepend_this_node(void)
883 struct o2nm_node
*local_node
;
885 local_node
= o2nm_get_node_by_num(o2nm_this_node());
888 o2nm_undepend_item(&local_node
->nd_item
);
889 o2nm_node_put(local_node
);
893 static void __exit
exit_o2nm(void)
895 /* XXX sync with hb callbacks and shut down hb? */
896 o2net_unregister_hb_callbacks();
897 configfs_unregister_subsystem(&o2nm_cluster_group
.cs_subsys
);
903 static int __init
init_o2nm(void)
907 cluster_print_version();
915 ret
= o2net_register_hb_callbacks();
919 config_group_init(&o2nm_cluster_group
.cs_subsys
.su_group
);
920 mutex_init(&o2nm_cluster_group
.cs_subsys
.su_mutex
);
921 ret
= configfs_register_subsystem(&o2nm_cluster_group
.cs_subsys
);
923 printk(KERN_ERR
"nodemanager: Registration returned %d\n", ret
);
927 ret
= o2cb_sys_init();
931 configfs_unregister_subsystem(&o2nm_cluster_group
.cs_subsys
);
933 o2net_unregister_hb_callbacks();
940 MODULE_AUTHOR("Oracle");
941 MODULE_LICENSE("GPL");
943 module_init(init_o2nm
)
944 module_exit(exit_o2nm
)