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

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

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

~ [ 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