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

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