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/configfs.h>
25
26 #include "tcp.h"
27 #include "nodemanager.h"
28 #include "heartbeat.h"
29 #include "masklog.h"
30 #include "sys.h"
31 #include "ver.h"
32
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;
37
38
39 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
40 {
41 struct o2nm_node *node = NULL;
42
43 if (node_num >= O2NM_MAX_NODES || o2nm_single_cluster == NULL)
44 goto out;
45
46 read_lock(&o2nm_single_cluster->cl_nodes_lock);
47 node = o2nm_single_cluster->cl_nodes[node_num];
48 if (node)
49 config_item_get(&node->nd_item);
50 read_unlock(&o2nm_single_cluster->cl_nodes_lock);
51 out:
52 return node;
53 }
54 EXPORT_SYMBOL_GPL(o2nm_get_node_by_num);
55
56 int o2nm_configured_node_map(unsigned long *map, unsigned bytes)
57 {
58 struct o2nm_cluster *cluster = o2nm_single_cluster;
59
60 BUG_ON(bytes < (sizeof(cluster->cl_nodes_bitmap)));
61
62 if (cluster == NULL)
63 return -EINVAL;
64
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);
68
69 return 0;
70 }
71 EXPORT_SYMBOL_GPL(o2nm_configured_node_map);
72
73 static struct o2nm_node *o2nm_node_ip_tree_lookup(struct o2nm_cluster *cluster,
74 __be32 ip_needle,
75 struct rb_node ***ret_p,
76 struct rb_node **ret_parent)
77 {
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;
81
82 while (*p) {
83 int cmp;
84
85 parent = *p;
86 node = rb_entry(parent, struct o2nm_node, nd_ip_node);
87
88 cmp = memcmp(&ip_needle, &node->nd_ipv4_address,
89 sizeof(ip_needle));
90 if (cmp < 0)
91 p = &(*p)->rb_left;
92 else if (cmp > 0)
93 p = &(*p)->rb_right;
94 else {
95 ret = node;
96 break;
97 }
98 }
99
100 if (ret_p != NULL)
101 *ret_p = p;
102 if (ret_parent != NULL)
103 *ret_parent = parent;
104
105 return ret;
106 }
107
108 struct o2nm_node *o2nm_get_node_by_ip(__be32 addr)
109 {
110 struct o2nm_node *node = NULL;
111 struct o2nm_cluster *cluster = o2nm_single_cluster;
112
113 if (cluster == NULL)
114 goto out;
115
116 read_lock(&cluster->cl_nodes_lock);
117 node = o2nm_node_ip_tree_lookup(cluster, addr, NULL, NULL);
118 if (node)
119 config_item_get(&node->nd_item);
120 read_unlock(&cluster->cl_nodes_lock);
121
122 out:
123 return node;
124 }
125 EXPORT_SYMBOL_GPL(o2nm_get_node_by_ip);
126
127 void o2nm_node_put(struct o2nm_node *node)
128 {
129 config_item_put(&node->nd_item);
130 }
131 EXPORT_SYMBOL_GPL(o2nm_node_put);
132
133 void o2nm_node_get(struct o2nm_node *node)
134 {
135 config_item_get(&node->nd_item);
136 }
137 EXPORT_SYMBOL_GPL(o2nm_node_get);
138
139 u8 o2nm_this_node(void)
140 {
141 u8 node_num = O2NM_MAX_NODES;
142
143 if (o2nm_single_cluster && o2nm_single_cluster->cl_has_local)
144 node_num = o2nm_single_cluster->cl_local_node;
145
146 return node_num;
147 }
148 EXPORT_SYMBOL_GPL(o2nm_this_node);
149
150 /* node configfs bits */
151
152 static struct o2nm_cluster *to_o2nm_cluster(struct config_item *item)
153 {
154 return item ?
155 container_of(to_config_group(item), struct o2nm_cluster,
156 cl_group)
157 : NULL;
158 }
159
160 static struct o2nm_node *to_o2nm_node(struct config_item *item)
161 {
162 return item ? container_of(item, struct o2nm_node, nd_item) : NULL;
163 }
164
165 static void o2nm_node_release(struct config_item *item)
166 {
167 struct o2nm_node *node = to_o2nm_node(item);
168 kfree(node);
169 }
170
171 static ssize_t o2nm_node_num_read(struct o2nm_node *node, char *page)
172 {
173 return sprintf(page, "%d\n", node->nd_num);
174 }
175
176 static struct o2nm_cluster *to_o2nm_cluster_from_node(struct o2nm_node *node)
177 {
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);
181 }
182
183 enum {
184 O2NM_NODE_ATTR_NUM = 0,
185 O2NM_NODE_ATTR_PORT,
186 O2NM_NODE_ATTR_ADDRESS,
187 O2NM_NODE_ATTR_LOCAL,
188 };
189
190 static ssize_t o2nm_node_num_write(struct o2nm_node *node, const char *page,
191 size_t count)
192 {
193 struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
194 unsigned long tmp;
195 char *p = (char *)page;
196
197 tmp = simple_strtoul(p, &p, 0);
198 if (!p || (*p && (*p != '\n')))
199 return -EINVAL;
200
201 if (tmp >= O2NM_MAX_NODES)
202 return -ERANGE;
203
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 */
211
212 write_lock(&cluster->cl_nodes_lock);
213 if (cluster->cl_nodes[tmp])
214 p = NULL;
215 else {
216 cluster->cl_nodes[tmp] = node;
217 node->nd_num = tmp;
218 set_bit(tmp, cluster->cl_nodes_bitmap);
219 }
220 write_unlock(&cluster->cl_nodes_lock);
221 if (p == NULL)
222 return -EEXIST;
223
224 return count;
225 }
226 static ssize_t o2nm_node_ipv4_port_read(struct o2nm_node *node, char *page)
227 {
228 return sprintf(page, "%u\n", ntohs(node->nd_ipv4_port));
229 }
230
231 static ssize_t o2nm_node_ipv4_port_write(struct o2nm_node *node,
232 const char *page, size_t count)
233 {
234 unsigned long tmp;
235 char *p = (char *)page;
236
237 tmp = simple_strtoul(p, &p, 0);
238 if (!p || (*p && (*p != '\n')))
239 return -EINVAL;
240
241 if (tmp == 0)
242 return -EINVAL;
243 if (tmp >= (u16)-1)
244 return -ERANGE;
245
246 node->nd_ipv4_port = htons(tmp);
247
248 return count;
249 }
250
251 static ssize_t o2nm_node_ipv4_address_read(struct o2nm_node *node, char *page)
252 {
253 return sprintf(page, "%pI4\n", &node->nd_ipv4_address);
254 }
255
256 static ssize_t o2nm_node_ipv4_address_write(struct o2nm_node *node,
257 const char *page,
258 size_t count)
259 {
260 struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
261 int ret, i;
262 struct rb_node **p, *parent;
263 unsigned int octets[4];
264 __be32 ipv4_addr = 0;
265
266 ret = sscanf(page, "%3u.%3u.%3u.%3u", &octets[3], &octets[2],
267 &octets[1], &octets[0]);
268 if (ret != 4)
269 return -EINVAL;
270
271 for (i = 0; i < ARRAY_SIZE(octets); i++) {
272 if (octets[i] > 255)
273 return -ERANGE;
274 be32_add_cpu(&ipv4_addr, octets[i] << (i * 8));
275 }
276
277 ret = 0;
278 write_lock(&cluster->cl_nodes_lock);
279 if (o2nm_node_ip_tree_lookup(cluster, ipv4_addr, &p, &parent))
280 ret = -EEXIST;
281 else {
282 rb_link_node(&node->nd_ip_node, parent, p);
283 rb_insert_color(&node->nd_ip_node, &cluster->cl_node_ip_tree);
284 }
285 write_unlock(&cluster->cl_nodes_lock);
286 if (ret)
287 return ret;
288
289 memcpy(&node->nd_ipv4_address, &ipv4_addr, sizeof(ipv4_addr));
290
291 return count;
292 }
293
294 static ssize_t o2nm_node_local_read(struct o2nm_node *node, char *page)
295 {
296 return sprintf(page, "%d\n", node->nd_local);
297 }
298
299 static ssize_t o2nm_node_local_write(struct o2nm_node *node, const char *page,
300 size_t count)
301 {
302 struct o2nm_cluster *cluster = to_o2nm_cluster_from_node(node);
303 unsigned long tmp;
304 char *p = (char *)page;
305 ssize_t ret;
306
307 tmp = simple_strtoul(p, &p, 0);
308 if (!p || (*p && (*p != '\n')))
309 return -EINVAL;
310
311 tmp = !!tmp; /* boolean of whether this node wants to be local */
312
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 */
319
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)
324 return -EBUSY;
325
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);
329 if (ret)
330 return ret;
331 }
332
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;
337 }
338
339 node->nd_local = tmp;
340 if (node->nd_local) {
341 cluster->cl_has_local = tmp;
342 cluster->cl_local_node = node->nd_num;
343 }
344
345 return count;
346 }
347
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);
352 };
353
354 static struct o2nm_node_attribute o2nm_node_attr_num = {
355 .attr = { .ca_owner = THIS_MODULE,
356 .ca_name = "num",
357 .ca_mode = S_IRUGO | S_IWUSR },
358 .show = o2nm_node_num_read,
359 .store = o2nm_node_num_write,
360 };
361
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,
368 };
369
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,
376 };
377
378 static struct o2nm_node_attribute o2nm_node_attr_local = {
379 .attr = { .ca_owner = THIS_MODULE,
380 .ca_name = "local",
381 .ca_mode = S_IRUGO | S_IWUSR },
382 .show = o2nm_node_local_read,
383 .store = o2nm_node_local_write,
384 };
385
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,
391 NULL,
392 };
393
394 static int o2nm_attr_index(struct configfs_attribute *attr)
395 {
396 int i;
397 for (i = 0; i < ARRAY_SIZE(o2nm_node_attrs); i++) {
398 if (attr == o2nm_node_attrs[i])
399 return i;
400 }
401 BUG();
402 return 0;
403 }
404
405 static ssize_t o2nm_node_show(struct config_item *item,
406 struct configfs_attribute *attr,
407 char *page)
408 {
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);
412 ssize_t ret = 0;
413
414 if (o2nm_node_attr->show)
415 ret = o2nm_node_attr->show(node, page);
416 return ret;
417 }
418
419 static ssize_t o2nm_node_store(struct config_item *item,
420 struct configfs_attribute *attr,
421 const char *page, size_t count)
422 {
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);
426 ssize_t ret;
427 int attr_index = o2nm_attr_index(attr);
428
429 if (o2nm_node_attr->store == NULL) {
430 ret = -EINVAL;
431 goto out;
432 }
433
434 if (test_bit(attr_index, &node->nd_set_attributes))
435 return -EBUSY;
436
437 ret = o2nm_node_attr->store(node, page, count);
438 if (ret < count)
439 goto out;
440
441 set_bit(attr_index, &node->nd_set_attributes);
442 out:
443 return ret;
444 }
445
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,
450 };
451
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,
456 };
457
458 /* node set */
459
460 struct o2nm_node_group {
461 struct config_group ns_group;
462 /* some stuff? */
463 };
464
465 #if 0
466 static struct o2nm_node_group *to_o2nm_node_group(struct config_group *group)
467 {
468 return group ?
469 container_of(group, struct o2nm_node_group, ns_group)
470 : NULL;
471 }
472 #endif
473
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);
478 };
479
480 static ssize_t o2nm_cluster_attr_write(const char *page, ssize_t count,
481 unsigned int *val)
482 {
483 unsigned long tmp;
484 char *p = (char *)page;
485
486 tmp = simple_strtoul(p, &p, 0);
487 if (!p || (*p && (*p != '\n')))
488 return -EINVAL;
489
490 if (tmp == 0)
491 return -EINVAL;
492 if (tmp >= (u32)-1)
493 return -ERANGE;
494
495 *val = tmp;
496
497 return count;
498 }
499
500 static ssize_t o2nm_cluster_attr_idle_timeout_ms_read(
501 struct o2nm_cluster *cluster, char *page)
502 {
503 return sprintf(page, "%u\n", cluster->cl_idle_timeout_ms);
504 }
505
506 static ssize_t o2nm_cluster_attr_idle_timeout_ms_write(
507 struct o2nm_cluster *cluster, const char *page, size_t count)
508 {
509 ssize_t ret;
510 unsigned int val;
511
512 ret = o2nm_cluster_attr_write(page, count, &val);
513
514 if (ret > 0) {
515 if (cluster->cl_idle_timeout_ms != val
516 && o2net_num_connected_peers()) {
517 mlog(ML_NOTICE,
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());
522 ret = -EINVAL;
523 } else if (val <= cluster->cl_keepalive_delay_ms) {
524 mlog(ML_NOTICE, "o2net: idle timeout must be larger "
525 "than keepalive delay\n");
526 ret = -EINVAL;
527 } else {
528 cluster->cl_idle_timeout_ms = val;
529 }
530 }
531
532 return ret;
533 }
534
535 static ssize_t o2nm_cluster_attr_keepalive_delay_ms_read(
536 struct o2nm_cluster *cluster, char *page)
537 {
538 return sprintf(page, "%u\n", cluster->cl_keepalive_delay_ms);
539 }
540
541 static ssize_t o2nm_cluster_attr_keepalive_delay_ms_write(
542 struct o2nm_cluster *cluster, const char *page, size_t count)
543 {
544 ssize_t ret;
545 unsigned int val;
546
547 ret = o2nm_cluster_attr_write(page, count, &val);
548
549 if (ret > 0) {
550 if (cluster->cl_keepalive_delay_ms != val
551 && o2net_num_connected_peers()) {
552 mlog(ML_NOTICE,
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());
557 ret = -EINVAL;
558 } else if (val >= cluster->cl_idle_timeout_ms) {
559 mlog(ML_NOTICE, "o2net: keepalive delay must be "
560 "smaller than idle timeout\n");
561 ret = -EINVAL;
562 } else {
563 cluster->cl_keepalive_delay_ms = val;
564 }
565 }
566
567 return ret;
568 }
569
570 static ssize_t o2nm_cluster_attr_reconnect_delay_ms_read(
571 struct o2nm_cluster *cluster, char *page)
572 {
573 return sprintf(page, "%u\n", cluster->cl_reconnect_delay_ms);
574 }
575
576 static ssize_t o2nm_cluster_attr_reconnect_delay_ms_write(
577 struct o2nm_cluster *cluster, const char *page, size_t count)
578 {
579 return o2nm_cluster_attr_write(page, count,
580 &cluster->cl_reconnect_delay_ms);
581 }
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,
588 };
589
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,
596 };
597
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,
604 };
605
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,
610 NULL,
611 };
612 static ssize_t o2nm_cluster_show(struct config_item *item,
613 struct configfs_attribute *attr,
614 char *page)
615 {
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);
619 ssize_t ret = 0;
620
621 if (o2nm_cluster_attr->show)
622 ret = o2nm_cluster_attr->show(cluster, page);
623 return ret;
624 }
625
626 static ssize_t o2nm_cluster_store(struct config_item *item,
627 struct configfs_attribute *attr,
628 const char *page, size_t count)
629 {
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);
633 ssize_t ret;
634
635 if (o2nm_cluster_attr->store == NULL) {
636 ret = -EINVAL;
637 goto out;
638 }
639
640 ret = o2nm_cluster_attr->store(cluster, page, count);
641 if (ret < count)
642 goto out;
643 out:
644 return ret;
645 }
646
647 static struct config_item *o2nm_node_group_make_item(struct config_group *group,
648 const char *name)
649 {
650 struct o2nm_node *node = NULL;
651
652 if (strlen(name) > O2NM_MAX_NAME_LEN)
653 return ERR_PTR(-ENAMETOOLONG);
654
655 node = kzalloc(sizeof(struct o2nm_node), GFP_KERNEL);
656 if (node == NULL)
657 return ERR_PTR(-ENOMEM);
658
659 strcpy(node->nd_name, name); /* use item.ci_namebuf instead? */
660 config_item_init_type_name(&node->nd_item, name, &o2nm_node_type);
661 spin_lock_init(&node->nd_lock);
662
663 return &node->nd_item;
664 }
665
666 static void o2nm_node_group_drop_item(struct config_group *group,
667 struct config_item *item)
668 {
669 struct o2nm_node *node = to_o2nm_node(item);
670 struct o2nm_cluster *cluster = to_o2nm_cluster(group->cg_item.ci_parent);
671
672 o2net_disconnect_node(node);
673
674 if (cluster->cl_has_local &&
675 (cluster->cl_local_node == node->nd_num)) {
676 cluster->cl_has_local = 0;
677 cluster->cl_local_node = O2NM_INVALID_NODE_NUM;
678 o2net_stop_listening(node);
679 }
680
681 /* XXX call into net to stop this node from trading messages */
682
683 write_lock(&cluster->cl_nodes_lock);
684
685 /* XXX sloppy */
686 if (node->nd_ipv4_address)
687 rb_erase(&node->nd_ip_node, &cluster->cl_node_ip_tree);
688
689 /* nd_num might be 0 if the node number hasn't been set.. */
690 if (cluster->cl_nodes[node->nd_num] == node) {
691 cluster->cl_nodes[node->nd_num] = NULL;
692 clear_bit(node->nd_num, cluster->cl_nodes_bitmap);
693 }
694 write_unlock(&cluster->cl_nodes_lock);
695
696 config_item_put(item);
697 }
698
699 static struct configfs_group_operations o2nm_node_group_group_ops = {
700 .make_item = o2nm_node_group_make_item,
701 .drop_item = o2nm_node_group_drop_item,
702 };
703
704 static struct config_item_type o2nm_node_group_type = {
705 .ct_group_ops = &o2nm_node_group_group_ops,
706 .ct_owner = THIS_MODULE,
707 };
708
709 /* cluster */
710
711 static void o2nm_cluster_release(struct config_item *item)
712 {
713 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
714
715 kfree(cluster->cl_group.default_groups);
716 kfree(cluster);
717 }
718
719 static struct configfs_item_operations o2nm_cluster_item_ops = {
720 .release = o2nm_cluster_release,
721 .show_attribute = o2nm_cluster_show,
722 .store_attribute = o2nm_cluster_store,
723 };
724
725 static struct config_item_type o2nm_cluster_type = {
726 .ct_item_ops = &o2nm_cluster_item_ops,
727 .ct_attrs = o2nm_cluster_attrs,
728 .ct_owner = THIS_MODULE,
729 };
730
731 /* cluster set */
732
733 struct o2nm_cluster_group {
734 struct configfs_subsystem cs_subsys;
735 /* some stuff? */
736 };
737
738 #if 0
739 static struct o2nm_cluster_group *to_o2nm_cluster_group(struct config_group *group)
740 {
741 return group ?
742 container_of(to_configfs_subsystem(group), struct o2nm_cluster_group, cs_subsys)
743 : NULL;
744 }
745 #endif
746
747 static struct config_group *o2nm_cluster_group_make_group(struct config_group *group,
748 const char *name)
749 {
750 struct o2nm_cluster *cluster = NULL;
751 struct o2nm_node_group *ns = NULL;
752 struct config_group *o2hb_group = NULL, *ret = NULL;
753 void *defs = NULL;
754
755 /* this runs under the parent dir's i_mutex; there can be only
756 * one caller in here at a time */
757 if (o2nm_single_cluster)
758 return ERR_PTR(-ENOSPC);
759
760 cluster = kzalloc(sizeof(struct o2nm_cluster), GFP_KERNEL);
761 ns = kzalloc(sizeof(struct o2nm_node_group), GFP_KERNEL);
762 defs = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
763 o2hb_group = o2hb_alloc_hb_set();
764 if (cluster == NULL || ns == NULL || o2hb_group == NULL || defs == NULL)
765 goto out;
766
767 config_group_init_type_name(&cluster->cl_group, name,
768 &o2nm_cluster_type);
769 config_group_init_type_name(&ns->ns_group, "node",
770 &o2nm_node_group_type);
771
772 cluster->cl_group.default_groups = defs;
773 cluster->cl_group.default_groups[0] = &ns->ns_group;
774 cluster->cl_group.default_groups[1] = o2hb_group;
775 cluster->cl_group.default_groups[2] = NULL;
776 rwlock_init(&cluster->cl_nodes_lock);
777 cluster->cl_node_ip_tree = RB_ROOT;
778 cluster->cl_reconnect_delay_ms = O2NET_RECONNECT_DELAY_MS_DEFAULT;
779 cluster->cl_idle_timeout_ms = O2NET_IDLE_TIMEOUT_MS_DEFAULT;
780 cluster->cl_keepalive_delay_ms = O2NET_KEEPALIVE_DELAY_MS_DEFAULT;
781
782 ret = &cluster->cl_group;
783 o2nm_single_cluster = cluster;
784
785 out:
786 if (ret == NULL) {
787 kfree(cluster);
788 kfree(ns);
789 o2hb_free_hb_set(o2hb_group);
790 kfree(defs);
791 ret = ERR_PTR(-ENOMEM);
792 }
793
794 return ret;
795 }
796
797 static void o2nm_cluster_group_drop_item(struct config_group *group, struct config_item *item)
798 {
799 struct o2nm_cluster *cluster = to_o2nm_cluster(item);
800 int i;
801 struct config_item *killme;
802
803 BUG_ON(o2nm_single_cluster != cluster);
804 o2nm_single_cluster = NULL;
805
806 for (i = 0; cluster->cl_group.default_groups[i]; i++) {
807 killme = &cluster->cl_group.default_groups[i]->cg_item;
808 cluster->cl_group.default_groups[i] = NULL;
809 config_item_put(killme);
810 }
811
812 config_item_put(item);
813 }
814
815 static struct configfs_group_operations o2nm_cluster_group_group_ops = {
816 .make_group = o2nm_cluster_group_make_group,
817 .drop_item = o2nm_cluster_group_drop_item,
818 };
819
820 static struct config_item_type o2nm_cluster_group_type = {
821 .ct_group_ops = &o2nm_cluster_group_group_ops,
822 .ct_owner = THIS_MODULE,
823 };
824
825 static struct o2nm_cluster_group o2nm_cluster_group = {
826 .cs_subsys = {
827 .su_group = {
828 .cg_item = {
829 .ci_namebuf = "cluster",
830 .ci_type = &o2nm_cluster_group_type,
831 },
832 },
833 },
834 };
835
836 int o2nm_depend_item(struct config_item *item)
837 {
838 return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item);
839 }
840
841 void o2nm_undepend_item(struct config_item *item)
842 {
843 configfs_undepend_item(&o2nm_cluster_group.cs_subsys, item);
844 }
845
846 int o2nm_depend_this_node(void)
847 {
848 int ret = 0;
849 struct o2nm_node *local_node;
850
851 local_node = o2nm_get_node_by_num(o2nm_this_node());
852 if (!local_node) {
853 ret = -EINVAL;
854 goto out;
855 }
856
857 ret = o2nm_depend_item(&local_node->nd_item);
858 o2nm_node_put(local_node);
859
860 out:
861 return ret;
862 }
863
864 void o2nm_undepend_this_node(void)
865 {
866 struct o2nm_node *local_node;
867
868 local_node = o2nm_get_node_by_num(o2nm_this_node());
869 BUG_ON(!local_node);
870
871 o2nm_undepend_item(&local_node->nd_item);
872 o2nm_node_put(local_node);
873 }
874
875
876 static void __exit exit_o2nm(void)
877 {
878 /* XXX sync with hb callbacks and shut down hb? */
879 o2net_unregister_hb_callbacks();
880 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
881 o2cb_sys_shutdown();
882
883 o2net_exit();
884 o2hb_exit();
885 }
886
887 static int __init init_o2nm(void)
888 {
889 int ret = -1;
890
891 cluster_print_version();
892
893 ret = o2hb_init();
894 if (ret)
895 goto out;
896
897 ret = o2net_init();
898 if (ret)
899 goto out_o2hb;
900
901 ret = o2net_register_hb_callbacks();
902 if (ret)
903 goto out_o2net;
904
905 config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
906 mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex);
907 ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys);
908 if (ret) {
909 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
910 goto out_callbacks;
911 }
912
913 ret = o2cb_sys_init();
914 if (!ret)
915 goto out;
916
917 configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
918 out_callbacks:
919 o2net_unregister_hb_callbacks();
920 out_o2net:
921 o2net_exit();
922 out_o2hb:
923 o2hb_exit();
924 out:
925 return ret;
926 }
927
928 MODULE_AUTHOR("Oracle");
929 MODULE_LICENSE("GPL");
930
931 module_init(init_o2nm)
932 module_exit(exit_o2nm)
933
|
This page was automatically generated by the
LXR engine.
|