Root/
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | } |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | }; |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
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 | |
893 | int o2nm_depend_item(struct config_item *item) |
894 | { |
895 | return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item); |
896 | } |
897 | |
898 | void o2nm_undepend_item(struct config_item *item) |
899 | { |
900 | configfs_undepend_item(&o2nm_cluster_group.cs_subsys, item); |
901 | } |
902 | |
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 | |
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 | |
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 | |
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 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9