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