~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ocfs2/cluster/nodemanager.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp