Merge branch 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[linux-2.6.git] / fs / ocfs2 / cluster / nodemanager.c
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * Copyright (C) 2004, 2005 Oracle.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public
17  * License along with this program; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 021110-1307, USA.
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/sysctl.h>
25 #include <linux/configfs.h>
26
27 #include "endian.h"
28 #include "tcp.h"
29 #include "nodemanager.h"
30 #include "heartbeat.h"
31 #include "masklog.h"
32 #include "sys.h"
33 #include "ver.h"
34
35 /* for now we operate under the assertion that there can be only one
36  * cluster active at a time.  Changing this will require trickling
37  * cluster references throughout where nodes are looked up */
38 static struct o2nm_cluster *o2nm_single_cluster = NULL;
39
40 #define OCFS2_MAX_HB_CTL_PATH 256
41 static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
42
43 static ctl_table ocfs2_nm_table[] = {
44         {
45                 .ctl_name       = 1,
46                 .procname       = "hb_ctl_path",
47                 .data           = ocfs2_hb_ctl_path,
48                 .maxlen         = OCFS2_MAX_HB_CTL_PATH,
49                 .mode           = 0644,
50                 .proc_handler   = &proc_dostring,
51                 .strategy       = &sysctl_string,
52         },
53         { .ctl_name = 0 }
54 };
55
56 static ctl_table ocfs2_mod_table[] = {
57         {
58                 .ctl_name       = KERN_OCFS2_NM,
59                 .procname       = "nm",
60                 .data           = NULL,
61                 .maxlen         = 0,
62                 .mode           = 0555,
63                 .child          = ocfs2_nm_table
64         },
65         { .ctl_name = 0}
66 };
67
68 static ctl_table ocfs2_kern_table[] = {
69         {
70                 .ctl_name       = KERN_OCFS2,
71                 .procname       = "ocfs2",
72                 .data           = NULL,
73                 .maxlen         = 0,
74                 .mode           = 0555,
75                 .child          = ocfs2_mod_table
76         },
77         { .ctl_name = 0}
78 };
79
80 static ctl_table ocfs2_root_table[] = {
81         {
82                 .ctl_name       = CTL_FS,
83                 .procname       = "fs",
84                 .data           = NULL,
85                 .maxlen         = 0,
86                 .mode           = 0555,
87                 .child          = ocfs2_kern_table
88         },
89         { .ctl_name = 0 }
90 };
91
92 static struct ctl_table_header *ocfs2_table_header = NULL;
93
94 const char *o2nm_get_hb_ctl_path(void)
95 {
96         return ocfs2_hb_ctl_path;
97 }
98 EXPORT_SYMBOL_GPL(o2nm_get_hb_ctl_path);
99
100 struct o2nm_cluster {
101         struct config_group     cl_group;
102         unsigned                cl_has_local:1;
103         u8                      cl_local_node;
104         rwlock_t                cl_nodes_lock;
105         struct o2nm_node        *cl_nodes[O2NM_MAX_NODES];
106         struct rb_root          cl_node_ip_tree;
107         /* this bitmap is part of a hack for disk bitmap.. will go eventually. - zab */
108         unsigned long   cl_nodes_bitmap[BITS_TO_LONGS(O2NM_MAX_NODES)];
109 };
110
111 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
112 {
113         struct o2nm_node *node = NULL;
114
115         if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL)
116                 goto out;
117
118         read_lock(&o2nm_single_cluster->cl_nodes_lock);
119         node = o2nm_single_cluster->cl_nodes[node_num];
120         if (node)
121                 config_item_get(&node->nd_item);
122         read_unlock(&o2nm_single_cluster->cl_nodes_lock);
123 out:
124         return node;
125 }
126 EXPORT_SYMBOL_GPL(o2nm_get_node_by_num);
127
128 int o2nm_configured_node_map(unsigned long *map, unsigned bytes)
129 {
130         struct o2nm_cluster *cluster = o2nm_single_cluster;
131
132         BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap)));
133
134         if (cluster == NULL)
135                 return -EINVAL;
136
137         read_lock(&cluster->cl_nodes_lock);
138         memcpy(map, cluster->cl_nodes_bitmap, sizeof(cluster->cl_nodes_bitmap));
139         read_unlock(&cluster->cl_nodes_lock);
140
141         return 0;
142 }
143 EXPORT_SYMBOL_GPL(o2nm_configured_node_map);
144
145 static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster,
146                                                   __be32 ip_needle,
147                                                   struct rb_node ***ret_p,
148                                                   struct rb_node **ret_parent)
149 {
150         struct rb_node **p = &cluster->cl_node_ip_tree.rb_node;
151         struct rb_node *parent = NULL;
152         struct o2nm_node *node, *ret = NULL;
153
154         while (*p) {
155                 int cmp;
156
157                 parent = *p;
158                 node = rb_entry(parent, struct o2nm_node, nd_ip_node);
159
160                 cmp = memcmp(&ip_needle, &node->nd_ipv4_address,
161                                 sizeof(ip_needle));
162                 if (cmp < 0)
163                         p = &(*p)->rb_left;
164                 else if (cmp > 0)
165                         p = &(*p)->rb_right;
166                 else {
167                         ret = node;
168                         break;
169                 }
170         }
171
172         if (ret_p != NULL)
173                 *ret_p = p;
174         if (ret_parent != NULL)
175                 *ret_parent = parent;
176
177         return ret;
178 }
179
180 struct o2nm_node *o2nm_get_node_by_ip(__be32 addr)
181 {
182         struct o2nm_node *node = NULL;
183         struct o2nm_cluster *cluster = o2nm_single_cluster;
184
185         if (cluster == NULL)
186                 goto out;
187
188         read_lock(&cluster->cl_nodes_lock);
189         node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL);
190         if (node)
191                 config_item_get(&node->nd_item);
192         read_unlock(&cluster->cl_nodes_lock);
193
194 out:
195         return node;
196 }
197 EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip);
198
199 void o2nm_node_put(struct o2nm_node *node)
200 {
201         config_item_put(&node->nd_item);
202 }
203 EXPORT_SYMBOL_GPL(o2nm_node_put);
204
205 void o2nm_node_get(struct o2nm_node *node)
206 {
207         config_item_get(&node->nd_item);
208 }
209 EXPORT_SYMBOL_GPL(o2nm_node_get);
210
211 u8 o2nm_this_node(void)
212 {
213         u8 node_num = O2NM_MAX_NODES;
214
215         if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local)
216                 node_num = o2nm_single_cluster->cl_local_node;
217
218         return node_num;
219 }
220 EXPORT_SYMBOL_GPL(o2nm_this_node);
221
222 /* node configfs bits */
223
224 static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item)
225 {
226         return item ?
227                 container_of(to_config_group(item), struct o2nm_cluster,
228                              cl_group)
229                 : NULL;
230 }
231
232 static struct o2nm_node *to_o2nm_node(struct config_item *item)
233 {
234         return item ? container_of(item, struct o2nm_node, nd_item) : NULL;
235 }
236
237 static void o2nm_node_release(struct config_item *item)
238 {
239         struct o2nm_node *node = to_o2nm_node(item);
240         kfree(node);
241 }
242
243 static ssize_t o2nm_node_num_read(struct o2nm_node *node, char *page)
244 {
245         return sprintf(page, "%d\n", node->nd_num);
246 }
247
248 static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node)
249 {
250         /* through the first node_set .parent
251          * mycluster/nodes/mynode == o2nm_cluster->o2nm_node_group->o2nm_node */
252         return to_o2nm_cluster(node->nd_item.ci_parent->ci_parent);
253 }
254
255 enum {
256         O2NM_NODE_ATTR_NUM = 0,
257         O2NM_NODE_ATTR_PORT,
258         O2NM_NODE_ATTR_ADDRESS,
259         O2NM_NODE_ATTR_LOCAL,
260 };
261
262 static ssize_t o2nm_node_num_write(struct o2nm_node *node, const char *page,
263                                    size_t count)
264 {
265         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
266         unsigned long tmp;
267         char *p = (char *)page;
268
269         tmp = simple_strtoul(p, &p, 0);
270         if (!p || (*p && (*p != '\n')))
271                 return -EINVAL;
272
273         if (tmp >= O2NM_MAX_NODES)
274                 return -ERANGE;
275
276         /* once we're in the cl_nodes tree networking can look us up by
277          * node number and try to use our address and port attributes
278          * to connect to this node.. make sure that they've been set
279          * before writing the node attribute? */
280         if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
281             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
282                 return -EINVAL; /* XXX */
283
284         write_lock(&cluster->cl_nodes_lock);
285         if (cluster->cl_nodes[tmp])
286                 p = NULL;
287         else  {
288                 cluster->cl_nodes[tmp] = node;
289                 node->nd_num = tmp;
290                 set_bit(tmp, cluster->cl_nodes_bitmap);
291         }
292         write_unlock(&cluster->cl_nodes_lock);
293         if (p == NULL)
294                 return -EEXIST;
295
296         return count;
297 }
298 static ssize_t o2nm_node_ipv4_port_read(struct o2nm_node *node, char *page)
299 {
300         return sprintf(page, "%u\n", ntohs(node->nd_ipv4_port));
301 }
302
303 static ssize_t o2nm_node_ipv4_port_write(struct o2nm_node *node,
304                                          const char *page, size_t count)
305 {
306         unsigned long tmp;
307         char *p = (char *)page;
308
309         tmp = simple_strtoul(p, &p, 0);
310         if (!p || (*p && (*p != '\n')))
311                 return -EINVAL;
312
313         if (tmp == 0)
314                 return -EINVAL;
315         if (tmp >= (u16)-1)
316                 return -ERANGE;
317
318         node->nd_ipv4_port = htons(tmp);
319
320         return count;
321 }
322
323 static ssize_t o2nm_node_ipv4_address_read(struct o2nm_node *node, char *page)
324 {
325         return sprintf(page, "%u.%u.%u.%u\n", NIPQUAD(node->nd_ipv4_address));
326 }
327
328 static ssize_t o2nm_node_ipv4_address_write(struct o2nm_node *node,
329                                             const char *page,
330                                             size_t count)
331 {
332         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
333         int ret, i;
334         struct rb_node **p, *parent;
335         unsigned int octets[4];
336         __be32 ipv4_addr = 0;
337
338         ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2],
339                      &octets[1], &octets[0]);
340         if (ret != 4)
341                 return -EINVAL;
342
343         for (i = 0; i < ARRAY_SIZE(octets); i++) {
344                 if (octets[i] > 255)
345                         return -ERANGE;
346                 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8));
347         }
348
349         ret = 0;
350         write_lock(&cluster->cl_nodes_lock);
351         if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
352                 ret = -EEXIST;
353         else {
354                 rb_link_node(&node->nd_ip_node, parent, p);
355                 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree);
356         }
357         write_unlock(&cluster->cl_nodes_lock);
358         if (ret)
359                 return ret;
360
361         memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr));
362
363         return count;
364 }
365
366 static ssize_t o2nm_node_local_read(struct o2nm_node *node, char *page)
367 {
368         return sprintf(page, "%d\n", node->nd_local);
369 }
370
371 static ssize_t o2nm_node_local_write(struct o2nm_node *node, const char *page,
372                                      size_t count)
373 {
374         struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
375         unsigned long tmp;
376         char *p = (char *)page;
377         ssize_t ret;
378
379         tmp = simple_strtoul(p, &p, 0);
380         if (!p || (*p && (*p != '\n')))
381                 return -EINVAL;
382
383         tmp = !!tmp; /* boolean of whether this node wants to be local */
384
385         /* setting local turns on networking rx for now so we require having
386          * set everything else first */
387         if (!test_bit(O2NM_NODE_ATTR_ADDRESS, &node->nd_set_attributes) ||
388             !test_bit(O2NM_NODE_ATTR_NUM, &node->nd_set_attributes) ||
389             !test_bit(O2NM_NODE_ATTR_PORT, &node->nd_set_attributes))
390                 return -EINVAL; /* XXX */
391
392         /* the only failure case is trying to set a new local node
393          * when a different one is already set */
394         if (tmp && tmp == cluster->cl_has_local &&
395             cluster->cl_local_node != node->nd_num)
396                 return -EBUSY;
397
398         /* bring up the rx thread if we're setting the new local node. */
399         if (tmp && !cluster->cl_has_local) {
400                 ret = o2net_start_listening(node);
401                 if (ret)
402                         return ret;
403         }
404
405         if (!tmp && cluster->cl_has_local &&
406             cluster->cl_local_node == node->nd_num) {
407                 o2net_stop_listening(node);
408                 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
409         }
410
411         node->nd_local = tmp;
412         if (node->nd_local) {
413                 cluster->cl_has_local = tmp;
414                 cluster->cl_local_node = node->nd_num;
415         }
416
417         return count;
418 }
419
420 struct o2nm_node_attribute {
421         struct configfs_attribute attr;
422         ssize_t (*show)(struct o2nm_node *, char *);
423         ssize_t (*store)(struct o2nm_node *, const char *, size_t);
424 };
425
426 static struct o2nm_node_attribute o2nm_node_attr_num = {
427         .attr   = { .ca_owner = THIS_MODULE,
428                     .ca_name = "num",
429                     .ca_mode = S_IRUGO | S_IWUSR },
430         .show   = o2nm_node_num_read,
431         .store  = o2nm_node_num_write,
432 };
433
434 static struct o2nm_node_attribute o2nm_node_attr_ipv4_port = {
435         .attr   = { .ca_owner = THIS_MODULE,
436                     .ca_name = "ipv4_port",
437                     .ca_mode = S_IRUGO | S_IWUSR },
438         .show   = o2nm_node_ipv4_port_read,
439         .store  = o2nm_node_ipv4_port_write,
440 };
441
442 static struct o2nm_node_attribute o2nm_node_attr_ipv4_address = {
443         .attr   = { .ca_owner = THIS_MODULE,
444                     .ca_name = "ipv4_address",
445                     .ca_mode = S_IRUGO | S_IWUSR },
446         .show   = o2nm_node_ipv4_address_read,
447         .store  = o2nm_node_ipv4_address_write,
448 };
449
450 static struct o2nm_node_attribute o2nm_node_attr_local = {
451         .attr   = { .ca_owner = THIS_MODULE,
452                     .ca_name = "local",
453                     .ca_mode = S_IRUGO | S_IWUSR },
454         .show   = o2nm_node_local_read,
455         .store  = o2nm_node_local_write,
456 };
457
458 static struct configfs_attribute *o2nm_node_attrs[] = {
459         [O2NM_NODE_ATTR_NUM] = &o2nm_node_attr_num.attr,
460         [O2NM_NODE_ATTR_PORT] = &o2nm_node_attr_ipv4_port.attr,
461         [O2NM_NODE_ATTR_ADDRESS] = &o2nm_node_attr_ipv4_address.attr,
462         [O2NM_NODE_ATTR_LOCAL] = &o2nm_node_attr_local.attr,
463         NULL,
464 };
465
466 static int o2nm_attr_index(struct configfs_attribute *attr)
467 {
468         int i;
469         for (i = 0; i < ARRAY_SIZE(o2nm_node_attrs); i++) {
470                 if (attr == o2nm_node_attrs[i])
471                         return i;
472         }
473         BUG();
474         return 0;
475 }
476
477 static ssize_t o2nm_node_show(struct config_item *item,
478                               struct configfs_attribute *attr,
479                               char *page)
480 {
481         struct o2nm_node *node = to_o2nm_node(item);
482         struct o2nm_node_attribute *o2nm_node_attr =
483                 container_of(attr, struct o2nm_node_attribute, attr);
484         ssize_t ret = 0;
485
486         if (o2nm_node_attr->show)
487                 ret = o2nm_node_attr->show(node, page);
488         return ret;
489 }
490
491 static ssize_t o2nm_node_store(struct config_item *item,
492                                struct configfs_attribute *attr,
493                                const char *page, size_t count)
494 {
495         struct o2nm_node *node = to_o2nm_node(item);
496         struct o2nm_node_attribute *o2nm_node_attr =
497                 container_of(attr, struct o2nm_node_attribute, attr);
498         ssize_t ret;
499         int attr_index = o2nm_attr_index(attr);
500
501         if (o2nm_node_attr->store == NULL) {
502                 ret = -EINVAL;
503                 goto out;
504         }
505
506         if (test_bit(attr_index, &node->nd_set_attributes))
507                 return -EBUSY;
508
509         ret = o2nm_node_attr->store(node, page, count);
510         if (ret < count)
511                 goto out;
512
513         set_bit(attr_index, &node->nd_set_attributes);
514 out:
515         return ret;
516 }
517
518 static struct configfs_item_operations o2nm_node_item_ops = {
519         .release                = o2nm_node_release,
520         .show_attribute         = o2nm_node_show,
521         .store_attribute        = o2nm_node_store,
522 };
523
524 static struct config_item_type o2nm_node_type = {
525         .ct_item_ops    = &o2nm_node_item_ops,
526         .ct_attrs       = o2nm_node_attrs,
527         .ct_owner       = THIS_MODULE,
528 };
529
530 /* node set */
531
532 struct o2nm_node_group {
533         struct config_group ns_group;
534         /* some stuff? */
535 };
536
537 #if 0
538 static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group)
539 {
540         return group ?
541                 container_of(group, struct o2nm_node_group, ns_group)
542                 : NULL;
543 }
544 #endif
545
546 static struct config_item *o2nm_node_group_make_item(struct config_group *group,
547                                                      const char *name)
548 {
549         struct o2nm_node *node = NULL;
550         struct config_item *ret = NULL;
551
552         if (strlen(name) > O2NM_MAX_NAME_LEN)
553                 goto out; /* ENAMETOOLONG */
554
555         node = kcalloc(1, sizeof(struct o2nm_node), GFP_KERNEL);
556         if (node == NULL)
557                 goto out; /* ENOMEM */
558
559         strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */
560         config_item_init_type_name(&node->nd_item, name, &o2nm_node_type);
561         spin_lock_init(&node->nd_lock);
562
563         ret = &node->nd_item;
564
565 out:
566         if (ret == NULL)
567                 kfree(node);
568
569         return ret;
570 }
571
572 static void o2nm_node_group_drop_item(struct config_group *group,
573                                       struct config_item *item)
574 {
575         struct o2nm_node *node = to_o2nm_node(item);
576         struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent);
577
578         o2net_disconnect_node(node);
579
580         if (cluster->cl_has_local &&
581             (cluster->cl_local_node == node->nd_num)) {
582                 cluster->cl_has_local = 0;
583                 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
584                 o2net_stop_listening(node);
585         }
586
587         /* XXX call into net to stop this node from trading messages */
588
589         write_lock(&cluster->cl_nodes_lock);
590
591         /* XXX sloppy */
592         if (node->nd_ipv4_address)
593                 rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree);
594
595         /* nd_num might be 0 if the node number hasn't been set.. */
596         if (cluster->cl_nodes[node->nd_num] == node) {
597                 cluster->cl_nodes[node->nd_num] = NULL;
598                 clear_bit(node->nd_num, cluster->cl_nodes_bitmap);
599         }
600         write_unlock(&cluster->cl_nodes_lock);
601
602         config_item_put(item);
603 }
604
605 static struct configfs_group_operations o2nm_node_group_group_ops = {
606         .make_item      = o2nm_node_group_make_item,
607         .drop_item      = o2nm_node_group_drop_item,
608 };
609
610 static struct config_item_type o2nm_node_group_type = {
611         .ct_group_ops   = &o2nm_node_group_group_ops,
612         .ct_owner       = THIS_MODULE,
613 };
614
615 /* cluster */
616
617 static void o2nm_cluster_release(struct config_item *item)
618 {
619         struct o2nm_cluster *cluster = to_o2nm_cluster(item);
620
621         kfree(cluster->cl_group.default_groups);
622         kfree(cluster);
623 }
624
625 static struct configfs_item_operations o2nm_cluster_item_ops = {
626         .release        = o2nm_cluster_release,
627 };
628
629 static struct config_item_type o2nm_cluster_type = {
630         .ct_item_ops    = &o2nm_cluster_item_ops,
631         .ct_owner       = THIS_MODULE,
632 };
633
634 /* cluster set */
635
636 struct o2nm_cluster_group {
637         struct configfs_subsystem cs_subsys;
638         /* some stuff? */
639 };
640
641 #if 0
642 static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group)
643 {
644         return group ?
645                 container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys)
646                : NULL;
647 }
648 #endif
649
650 static struct config_group *o2nm_cluster_group_make_group(struct config_group *group,
651                                                           const char *name)
652 {
653         struct o2nm_cluster *cluster = NULL;
654         struct o2nm_node_group *ns = NULL;
655         struct config_group *o2hb_group = NULL, *ret = NULL;
656         void *defs = NULL;
657
658         /* this runs under the parent dir's i_mutex; there can be only
659          * one caller in here at a time */
660         if (o2nm_single_cluster)
661                 goto out; /* ENOSPC */
662
663         cluster = kcalloc(1, sizeof(struct o2nm_cluster), GFP_KERNEL);
664         ns = kcalloc(1, sizeof(struct o2nm_node_group), GFP_KERNEL);
665         defs = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
666         o2hb_group = o2hb_alloc_hb_set();
667         if (cluster == NULL || ns == NULL || o2hb_group == NULL || defs == NULL)
668                 goto out;
669
670         config_group_init_type_name(&cluster->cl_group, name,
671                                     &o2nm_cluster_type);
672         config_group_init_type_name(&ns->ns_group, "node",
673                                     &o2nm_node_group_type);
674
675         cluster->cl_group.default_groups = defs;
676         cluster->cl_group.default_groups[0] = &ns->ns_group;
677         cluster->cl_group.default_groups[1] = o2hb_group;
678         cluster->cl_group.default_groups[2] = NULL;
679         rwlock_init(&cluster->cl_nodes_lock);
680         cluster->cl_node_ip_tree = RB_ROOT;
681
682         ret = &cluster->cl_group;
683         o2nm_single_cluster = cluster;
684
685 out:
686         if (ret == NULL) {
687                 kfree(cluster);
688                 kfree(ns);
689                 o2hb_free_hb_set(o2hb_group);
690                 kfree(defs);
691         }
692
693         return ret;
694 }
695
696 static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item)
697 {
698         struct o2nm_cluster *cluster = to_o2nm_cluster(item);
699         int i;
700         struct config_item *killme;
701
702         BUG_ON(o2nm_single_cluster != cluster);
703         o2nm_single_cluster = NULL;
704
705         for (i = 0; cluster->cl_group.default_groups[i]; i++) {
706                 killme = &cluster->cl_group.default_groups[i]->cg_item;
707                 cluster->cl_group.default_groups[i] = NULL;
708                 config_item_put(killme);
709         }
710
711         config_item_put(item);
712 }
713
714 static struct configfs_group_operations o2nm_cluster_group_group_ops = {
715         .make_group     = o2nm_cluster_group_make_group,
716         .drop_item      = o2nm_cluster_group_drop_item,
717 };
718
719 static struct config_item_type o2nm_cluster_group_type = {
720         .ct_group_ops   = &o2nm_cluster_group_group_ops,
721         .ct_owner       = THIS_MODULE,
722 };
723
724 static struct o2nm_cluster_group o2nm_cluster_group = {
725         .cs_subsys = {
726                 .su_group = {
727                         .cg_item = {
728                                 .ci_namebuf = "cluster",
729                                 .ci_type = &o2nm_cluster_group_type,
730                         },
731                 },
732         },
733 };
734
735 static void __exit exit_o2nm(void)
736 {
737         if (ocfs2_table_header)
738                 unregister_sysctl_table(ocfs2_table_header);
739
740         /* XXX sync with hb callbacks and shut down hb? */
741         o2net_unregister_hb_callbacks();
742         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
743         o2cb_sys_shutdown();
744
745         o2net_exit();
746 }
747
748 static int __init init_o2nm(void)
749 {
750         int ret = -1;
751
752         cluster_print_version();
753
754         o2hb_init();
755         o2net_init();
756
757         ocfs2_table_header = register_sysctl_table(ocfs2_root_table, 0);
758         if (!ocfs2_table_header) {
759                 printk(KERN_ERR "nodemanager: unable to register sysctl\n");
760                 ret = -ENOMEM; /* or something. */
761                 goto out_o2net;
762         }
763
764         ret = o2net_register_hb_callbacks();
765         if (ret)
766                 goto out_sysctl;
767
768         config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
769         init_MUTEX(&o2nm_cluster_group.cs_subsys.su_sem);
770         ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys);
771         if (ret) {
772                 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
773                 goto out_callbacks;
774         }
775
776         ret = o2cb_sys_init();
777         if (!ret)
778                 goto out;
779
780         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
781 out_callbacks:
782         o2net_unregister_hb_callbacks();
783 out_sysctl:
784         unregister_sysctl_table(ocfs2_table_header);
785 out_o2net:
786         o2net_exit();
787 out:
788         return ret;
789 }
790
791 MODULE_AUTHOR("Oracle");
792 MODULE_LICENSE("GPL");
793
794 module_init(init_o2nm)
795 module_exit(exit_o2nm)