Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
config.c
Go to the documentation of this file.
1 /******************************************************************************
2 *******************************************************************************
3 **
4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5 ** Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved.
6 **
7 ** This copyrighted material is made available to anyone wishing to use,
8 ** modify, copy, or redistribute it subject to the terms and conditions
9 ** of the GNU General Public License v.2.
10 **
11 *******************************************************************************
12 ******************************************************************************/
13 
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/configfs.h>
17 #include <linux/slab.h>
18 #include <linux/in.h>
19 #include <linux/in6.h>
20 #include <linux/dlmconstants.h>
21 #include <net/ipv6.h>
22 #include <net/sock.h>
23 
24 #include "config.h"
25 #include "lowcomms.h"
26 
27 /*
28  * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/nodeid
29  * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/weight
30  * /config/dlm/<cluster>/comms/<comm>/nodeid
31  * /config/dlm/<cluster>/comms/<comm>/local
32  * /config/dlm/<cluster>/comms/<comm>/addr (write only)
33  * /config/dlm/<cluster>/comms/<comm>/addr_list (read only)
34  * The <cluster> level is useless, but I haven't figured out how to avoid it.
35  */
36 
37 static struct config_group *space_list;
38 static struct config_group *comm_list;
39 static struct dlm_comm *local_comm;
40 static uint32_t dlm_comm_count;
41 
42 struct dlm_clusters;
43 struct dlm_cluster;
44 struct dlm_spaces;
45 struct dlm_space;
46 struct dlm_comms;
47 struct dlm_comm;
48 struct dlm_nodes;
49 struct dlm_node;
50 
51 static struct config_group *make_cluster(struct config_group *, const char *);
52 static void drop_cluster(struct config_group *, struct config_item *);
53 static void release_cluster(struct config_item *);
54 static struct config_group *make_space(struct config_group *, const char *);
55 static void drop_space(struct config_group *, struct config_item *);
56 static void release_space(struct config_item *);
57 static struct config_item *make_comm(struct config_group *, const char *);
58 static void drop_comm(struct config_group *, struct config_item *);
59 static void release_comm(struct config_item *);
60 static struct config_item *make_node(struct config_group *, const char *);
61 static void drop_node(struct config_group *, struct config_item *);
62 static void release_node(struct config_item *);
63 
64 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a,
65  char *buf);
66 static ssize_t store_cluster(struct config_item *i,
67  struct configfs_attribute *a,
68  const char *buf, size_t len);
69 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
70  char *buf);
71 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
72  const char *buf, size_t len);
73 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
74  char *buf);
75 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
76  const char *buf, size_t len);
77 
78 static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf);
79 static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf,
80  size_t len);
81 static ssize_t comm_local_read(struct dlm_comm *cm, char *buf);
82 static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf,
83  size_t len);
84 static ssize_t comm_addr_write(struct dlm_comm *cm, const char *buf,
85  size_t len);
86 static ssize_t comm_addr_list_read(struct dlm_comm *cm, char *buf);
87 static ssize_t node_nodeid_read(struct dlm_node *nd, char *buf);
88 static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf,
89  size_t len);
90 static ssize_t node_weight_read(struct dlm_node *nd, char *buf);
91 static ssize_t node_weight_write(struct dlm_node *nd, const char *buf,
92  size_t len);
93 
94 struct dlm_cluster {
96  unsigned int cl_tcp_port;
97  unsigned int cl_buffer_size;
98  unsigned int cl_rsbtbl_size;
99  unsigned int cl_recover_timer;
100  unsigned int cl_toss_secs;
101  unsigned int cl_scan_secs;
102  unsigned int cl_log_debug;
103  unsigned int cl_protocol;
104  unsigned int cl_timewarn_cs;
105  unsigned int cl_waitwarn_us;
106  unsigned int cl_new_rsb_count;
107  unsigned int cl_recover_callbacks;
109 };
110 
111 enum {
125 };
126 
129  ssize_t (*show)(struct dlm_cluster *, char *);
130  ssize_t (*store)(struct dlm_cluster *, const char *, size_t);
131 };
132 
133 static ssize_t cluster_cluster_name_read(struct dlm_cluster *cl, char *buf)
134 {
135  return sprintf(buf, "%s\n", cl->cl_cluster_name);
136 }
137 
138 static ssize_t cluster_cluster_name_write(struct dlm_cluster *cl,
139  const char *buf, size_t len)
140 {
141  strncpy(dlm_config.ci_cluster_name, buf, DLM_LOCKSPACE_LEN);
143  return len;
144 }
145 
146 static struct cluster_attribute cluster_attr_cluster_name = {
147  .attr = { .ca_owner = THIS_MODULE,
148  .ca_name = "cluster_name",
149  .ca_mode = S_IRUGO | S_IWUSR },
150  .show = cluster_cluster_name_read,
151  .store = cluster_cluster_name_write,
152 };
153 
154 static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field,
155  int *info_field, int check_zero,
156  const char *buf, size_t len)
157 {
158  unsigned int x;
159 
160  if (!capable(CAP_SYS_ADMIN))
161  return -EACCES;
162 
163  x = simple_strtoul(buf, NULL, 0);
164 
165  if (check_zero && !x)
166  return -EINVAL;
167 
168  *cl_field = x;
169  *info_field = x;
170 
171  return len;
172 }
173 
174 #define CLUSTER_ATTR(name, check_zero) \
175 static ssize_t name##_write(struct dlm_cluster *cl, const char *buf, size_t len) \
176 { \
177  return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \
178  check_zero, buf, len); \
179 } \
180 static ssize_t name##_read(struct dlm_cluster *cl, char *buf) \
181 { \
182  return snprintf(buf, PAGE_SIZE, "%u\n", cl->cl_##name); \
183 } \
184 static struct cluster_attribute cluster_attr_##name = \
185 __CONFIGFS_ATTR(name, 0644, name##_read, name##_write)
186 
187 CLUSTER_ATTR(tcp_port, 1);
188 CLUSTER_ATTR(buffer_size, 1);
189 CLUSTER_ATTR(rsbtbl_size, 1);
190 CLUSTER_ATTR(recover_timer, 1);
191 CLUSTER_ATTR(toss_secs, 1);
192 CLUSTER_ATTR(scan_secs, 1);
195 CLUSTER_ATTR(timewarn_cs, 1);
196 CLUSTER_ATTR(waitwarn_us, 0);
197 CLUSTER_ATTR(new_rsb_count, 0);
198 CLUSTER_ATTR(recover_callbacks, 0);
199 
200 static struct configfs_attribute *cluster_attrs[] = {
201  [CLUSTER_ATTR_TCP_PORT] = &cluster_attr_tcp_port.attr,
202  [CLUSTER_ATTR_BUFFER_SIZE] = &cluster_attr_buffer_size.attr,
203  [CLUSTER_ATTR_RSBTBL_SIZE] = &cluster_attr_rsbtbl_size.attr,
204  [CLUSTER_ATTR_RECOVER_TIMER] = &cluster_attr_recover_timer.attr,
205  [CLUSTER_ATTR_TOSS_SECS] = &cluster_attr_toss_secs.attr,
206  [CLUSTER_ATTR_SCAN_SECS] = &cluster_attr_scan_secs.attr,
207  [CLUSTER_ATTR_LOG_DEBUG] = &cluster_attr_log_debug.attr,
208  [CLUSTER_ATTR_PROTOCOL] = &cluster_attr_protocol.attr,
209  [CLUSTER_ATTR_TIMEWARN_CS] = &cluster_attr_timewarn_cs.attr,
210  [CLUSTER_ATTR_WAITWARN_US] = &cluster_attr_waitwarn_us.attr,
211  [CLUSTER_ATTR_NEW_RSB_COUNT] = &cluster_attr_new_rsb_count.attr,
212  [CLUSTER_ATTR_RECOVER_CALLBACKS] = &cluster_attr_recover_callbacks.attr,
213  [CLUSTER_ATTR_CLUSTER_NAME] = &cluster_attr_cluster_name.attr,
214  NULL,
215 };
216 
217 enum {
222 };
223 
226  ssize_t (*show)(struct dlm_comm *, char *);
227  ssize_t (*store)(struct dlm_comm *, const char *, size_t);
228 };
229 
230 static struct comm_attribute comm_attr_nodeid = {
231  .attr = { .ca_owner = THIS_MODULE,
232  .ca_name = "nodeid",
233  .ca_mode = S_IRUGO | S_IWUSR },
234  .show = comm_nodeid_read,
235  .store = comm_nodeid_write,
236 };
237 
238 static struct comm_attribute comm_attr_local = {
239  .attr = { .ca_owner = THIS_MODULE,
240  .ca_name = "local",
241  .ca_mode = S_IRUGO | S_IWUSR },
242  .show = comm_local_read,
243  .store = comm_local_write,
244 };
245 
246 static struct comm_attribute comm_attr_addr = {
247  .attr = { .ca_owner = THIS_MODULE,
248  .ca_name = "addr",
249  .ca_mode = S_IWUSR },
250  .store = comm_addr_write,
251 };
252 
253 static struct comm_attribute comm_attr_addr_list = {
254  .attr = { .ca_owner = THIS_MODULE,
255  .ca_name = "addr_list",
256  .ca_mode = S_IRUGO },
257  .show = comm_addr_list_read,
258 };
259 
260 static struct configfs_attribute *comm_attrs[] = {
261  [COMM_ATTR_NODEID] = &comm_attr_nodeid.attr,
262  [COMM_ATTR_LOCAL] = &comm_attr_local.attr,
263  [COMM_ATTR_ADDR] = &comm_attr_addr.attr,
264  [COMM_ATTR_ADDR_LIST] = &comm_attr_addr_list.attr,
265  NULL,
266 };
267 
268 enum {
271 };
272 
275  ssize_t (*show)(struct dlm_node *, char *);
276  ssize_t (*store)(struct dlm_node *, const char *, size_t);
277 };
278 
279 static struct node_attribute node_attr_nodeid = {
280  .attr = { .ca_owner = THIS_MODULE,
281  .ca_name = "nodeid",
282  .ca_mode = S_IRUGO | S_IWUSR },
283  .show = node_nodeid_read,
284  .store = node_nodeid_write,
285 };
286 
287 static struct node_attribute node_attr_weight = {
288  .attr = { .ca_owner = THIS_MODULE,
289  .ca_name = "weight",
290  .ca_mode = S_IRUGO | S_IWUSR },
291  .show = node_weight_read,
292  .store = node_weight_write,
293 };
294 
295 static struct configfs_attribute *node_attrs[] = {
296  [NODE_ATTR_NODEID] = &node_attr_nodeid.attr,
297  [NODE_ATTR_WEIGHT] = &node_attr_weight.attr,
298  NULL,
299 };
300 
301 struct dlm_clusters {
303 };
304 
305 struct dlm_spaces {
307 };
308 
309 struct dlm_space {
314 };
315 
316 struct dlm_comms {
318 };
319 
320 struct dlm_comm {
322  int seq;
323  int nodeid;
324  int local;
327 };
328 
329 struct dlm_nodes {
331 };
332 
333 struct dlm_node {
335  struct list_head list; /* space->members */
336  int nodeid;
337  int weight;
338  int new;
339  int comm_seq; /* copy of cm->seq when nd->nodeid is set */
340 };
341 
342 static struct configfs_group_operations clusters_ops = {
343  .make_group = make_cluster,
344  .drop_item = drop_cluster,
345 };
346 
347 static struct configfs_item_operations cluster_ops = {
348  .release = release_cluster,
349  .show_attribute = show_cluster,
350  .store_attribute = store_cluster,
351 };
352 
353 static struct configfs_group_operations spaces_ops = {
354  .make_group = make_space,
355  .drop_item = drop_space,
356 };
357 
358 static struct configfs_item_operations space_ops = {
359  .release = release_space,
360 };
361 
362 static struct configfs_group_operations comms_ops = {
363  .make_item = make_comm,
364  .drop_item = drop_comm,
365 };
366 
367 static struct configfs_item_operations comm_ops = {
368  .release = release_comm,
369  .show_attribute = show_comm,
370  .store_attribute = store_comm,
371 };
372 
373 static struct configfs_group_operations nodes_ops = {
374  .make_item = make_node,
375  .drop_item = drop_node,
376 };
377 
378 static struct configfs_item_operations node_ops = {
379  .release = release_node,
380  .show_attribute = show_node,
381  .store_attribute = store_node,
382 };
383 
384 static struct config_item_type clusters_type = {
385  .ct_group_ops = &clusters_ops,
386  .ct_owner = THIS_MODULE,
387 };
388 
389 static struct config_item_type cluster_type = {
390  .ct_item_ops = &cluster_ops,
391  .ct_attrs = cluster_attrs,
392  .ct_owner = THIS_MODULE,
393 };
394 
395 static struct config_item_type spaces_type = {
396  .ct_group_ops = &spaces_ops,
397  .ct_owner = THIS_MODULE,
398 };
399 
400 static struct config_item_type space_type = {
401  .ct_item_ops = &space_ops,
402  .ct_owner = THIS_MODULE,
403 };
404 
405 static struct config_item_type comms_type = {
406  .ct_group_ops = &comms_ops,
407  .ct_owner = THIS_MODULE,
408 };
409 
410 static struct config_item_type comm_type = {
411  .ct_item_ops = &comm_ops,
412  .ct_attrs = comm_attrs,
413  .ct_owner = THIS_MODULE,
414 };
415 
416 static struct config_item_type nodes_type = {
417  .ct_group_ops = &nodes_ops,
418  .ct_owner = THIS_MODULE,
419 };
420 
421 static struct config_item_type node_type = {
422  .ct_item_ops = &node_ops,
423  .ct_attrs = node_attrs,
424  .ct_owner = THIS_MODULE,
425 };
426 
427 static struct dlm_cluster *config_item_to_cluster(struct config_item *i)
428 {
429  return i ? container_of(to_config_group(i), struct dlm_cluster, group) :
430  NULL;
431 }
432 
433 static struct dlm_space *config_item_to_space(struct config_item *i)
434 {
435  return i ? container_of(to_config_group(i), struct dlm_space, group) :
436  NULL;
437 }
438 
439 static struct dlm_comm *config_item_to_comm(struct config_item *i)
440 {
441  return i ? container_of(i, struct dlm_comm, item) : NULL;
442 }
443 
444 static struct dlm_node *config_item_to_node(struct config_item *i)
445 {
446  return i ? container_of(i, struct dlm_node, item) : NULL;
447 }
448 
449 static struct config_group *make_cluster(struct config_group *g,
450  const char *name)
451 {
452  struct dlm_cluster *cl = NULL;
453  struct dlm_spaces *sps = NULL;
454  struct dlm_comms *cms = NULL;
455  void *gps = NULL;
456 
457  cl = kzalloc(sizeof(struct dlm_cluster), GFP_NOFS);
458  gps = kcalloc(3, sizeof(struct config_group *), GFP_NOFS);
459  sps = kzalloc(sizeof(struct dlm_spaces), GFP_NOFS);
460  cms = kzalloc(sizeof(struct dlm_comms), GFP_NOFS);
461 
462  if (!cl || !gps || !sps || !cms)
463  goto fail;
464 
465  config_group_init_type_name(&cl->group, name, &cluster_type);
466  config_group_init_type_name(&sps->ss_group, "spaces", &spaces_type);
467  config_group_init_type_name(&cms->cs_group, "comms", &comms_type);
468 
469  cl->group.default_groups = gps;
470  cl->group.default_groups[0] = &sps->ss_group;
471  cl->group.default_groups[1] = &cms->cs_group;
472  cl->group.default_groups[2] = NULL;
473 
474  cl->cl_tcp_port = dlm_config.ci_tcp_port;
475  cl->cl_buffer_size = dlm_config.ci_buffer_size;
476  cl->cl_rsbtbl_size = dlm_config.ci_rsbtbl_size;
477  cl->cl_recover_timer = dlm_config.ci_recover_timer;
478  cl->cl_toss_secs = dlm_config.ci_toss_secs;
479  cl->cl_scan_secs = dlm_config.ci_scan_secs;
480  cl->cl_log_debug = dlm_config.ci_log_debug;
481  cl->cl_protocol = dlm_config.ci_protocol;
482  cl->cl_timewarn_cs = dlm_config.ci_timewarn_cs;
483  cl->cl_waitwarn_us = dlm_config.ci_waitwarn_us;
484  cl->cl_new_rsb_count = dlm_config.ci_new_rsb_count;
485  cl->cl_recover_callbacks = dlm_config.ci_recover_callbacks;
486  memcpy(cl->cl_cluster_name, dlm_config.ci_cluster_name,
488 
489  space_list = &sps->ss_group;
490  comm_list = &cms->cs_group;
491  return &cl->group;
492 
493  fail:
494  kfree(cl);
495  kfree(gps);
496  kfree(sps);
497  kfree(cms);
498  return ERR_PTR(-ENOMEM);
499 }
500 
501 static void drop_cluster(struct config_group *g, struct config_item *i)
502 {
503  struct dlm_cluster *cl = config_item_to_cluster(i);
504  struct config_item *tmp;
505  int j;
506 
507  for (j = 0; cl->group.default_groups[j]; j++) {
508  tmp = &cl->group.default_groups[j]->cg_item;
509  cl->group.default_groups[j] = NULL;
510  config_item_put(tmp);
511  }
512 
513  space_list = NULL;
514  comm_list = NULL;
515 
516  config_item_put(i);
517 }
518 
519 static void release_cluster(struct config_item *i)
520 {
521  struct dlm_cluster *cl = config_item_to_cluster(i);
522  kfree(cl->group.default_groups);
523  kfree(cl);
524 }
525 
526 static struct config_group *make_space(struct config_group *g, const char *name)
527 {
528  struct dlm_space *sp = NULL;
529  struct dlm_nodes *nds = NULL;
530  void *gps = NULL;
531 
532  sp = kzalloc(sizeof(struct dlm_space), GFP_NOFS);
533  gps = kcalloc(2, sizeof(struct config_group *), GFP_NOFS);
534  nds = kzalloc(sizeof(struct dlm_nodes), GFP_NOFS);
535 
536  if (!sp || !gps || !nds)
537  goto fail;
538 
539  config_group_init_type_name(&sp->group, name, &space_type);
540  config_group_init_type_name(&nds->ns_group, "nodes", &nodes_type);
541 
542  sp->group.default_groups = gps;
543  sp->group.default_groups[0] = &nds->ns_group;
544  sp->group.default_groups[1] = NULL;
545 
546  INIT_LIST_HEAD(&sp->members);
547  mutex_init(&sp->members_lock);
548  sp->members_count = 0;
549  return &sp->group;
550 
551  fail:
552  kfree(sp);
553  kfree(gps);
554  kfree(nds);
555  return ERR_PTR(-ENOMEM);
556 }
557 
558 static void drop_space(struct config_group *g, struct config_item *i)
559 {
560  struct dlm_space *sp = config_item_to_space(i);
561  struct config_item *tmp;
562  int j;
563 
564  /* assert list_empty(&sp->members) */
565 
566  for (j = 0; sp->group.default_groups[j]; j++) {
567  tmp = &sp->group.default_groups[j]->cg_item;
568  sp->group.default_groups[j] = NULL;
569  config_item_put(tmp);
570  }
571 
572  config_item_put(i);
573 }
574 
575 static void release_space(struct config_item *i)
576 {
577  struct dlm_space *sp = config_item_to_space(i);
578  kfree(sp->group.default_groups);
579  kfree(sp);
580 }
581 
582 static struct config_item *make_comm(struct config_group *g, const char *name)
583 {
584  struct dlm_comm *cm;
585 
586  cm = kzalloc(sizeof(struct dlm_comm), GFP_NOFS);
587  if (!cm)
588  return ERR_PTR(-ENOMEM);
589 
590  config_item_init_type_name(&cm->item, name, &comm_type);
591 
592  cm->seq = dlm_comm_count++;
593  if (!cm->seq)
594  cm->seq = dlm_comm_count++;
595 
596  cm->nodeid = -1;
597  cm->local = 0;
598  cm->addr_count = 0;
599  return &cm->item;
600 }
601 
602 static void drop_comm(struct config_group *g, struct config_item *i)
603 {
604  struct dlm_comm *cm = config_item_to_comm(i);
605  if (local_comm == cm)
606  local_comm = NULL;
608  while (cm->addr_count--)
609  kfree(cm->addr[cm->addr_count]);
610  config_item_put(i);
611 }
612 
613 static void release_comm(struct config_item *i)
614 {
615  struct dlm_comm *cm = config_item_to_comm(i);
616  kfree(cm);
617 }
618 
619 static struct config_item *make_node(struct config_group *g, const char *name)
620 {
621  struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent);
622  struct dlm_node *nd;
623 
624  nd = kzalloc(sizeof(struct dlm_node), GFP_NOFS);
625  if (!nd)
626  return ERR_PTR(-ENOMEM);
627 
628  config_item_init_type_name(&nd->item, name, &node_type);
629  nd->nodeid = -1;
630  nd->weight = 1; /* default weight of 1 if none is set */
631  nd->new = 1; /* set to 0 once it's been read by dlm_nodeid_list() */
632 
633  mutex_lock(&sp->members_lock);
634  list_add(&nd->list, &sp->members);
635  sp->members_count++;
637 
638  return &nd->item;
639 }
640 
641 static void drop_node(struct config_group *g, struct config_item *i)
642 {
643  struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent);
644  struct dlm_node *nd = config_item_to_node(i);
645 
646  mutex_lock(&sp->members_lock);
647  list_del(&nd->list);
648  sp->members_count--;
650 
651  config_item_put(i);
652 }
653 
654 static void release_node(struct config_item *i)
655 {
656  struct dlm_node *nd = config_item_to_node(i);
657  kfree(nd);
658 }
659 
660 static struct dlm_clusters clusters_root = {
661  .subsys = {
662  .su_group = {
663  .cg_item = {
664  .ci_namebuf = "dlm",
665  .ci_type = &clusters_type,
666  },
667  },
668  },
669 };
670 
672 {
673  config_group_init(&clusters_root.subsys.su_group);
674  mutex_init(&clusters_root.subsys.su_mutex);
675  return configfs_register_subsystem(&clusters_root.subsys);
676 }
677 
678 void dlm_config_exit(void)
679 {
680  configfs_unregister_subsystem(&clusters_root.subsys);
681 }
682 
683 /*
684  * Functions for user space to read/write attributes
685  */
686 
687 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a,
688  char *buf)
689 {
690  struct dlm_cluster *cl = config_item_to_cluster(i);
691  struct cluster_attribute *cla =
692  container_of(a, struct cluster_attribute, attr);
693  return cla->show ? cla->show(cl, buf) : 0;
694 }
695 
696 static ssize_t store_cluster(struct config_item *i,
697  struct configfs_attribute *a,
698  const char *buf, size_t len)
699 {
700  struct dlm_cluster *cl = config_item_to_cluster(i);
701  struct cluster_attribute *cla =
702  container_of(a, struct cluster_attribute, attr);
703  return cla->store ? cla->store(cl, buf, len) : -EINVAL;
704 }
705 
706 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
707  char *buf)
708 {
709  struct dlm_comm *cm = config_item_to_comm(i);
710  struct comm_attribute *cma =
711  container_of(a, struct comm_attribute, attr);
712  return cma->show ? cma->show(cm, buf) : 0;
713 }
714 
715 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
716  const char *buf, size_t len)
717 {
718  struct dlm_comm *cm = config_item_to_comm(i);
719  struct comm_attribute *cma =
720  container_of(a, struct comm_attribute, attr);
721  return cma->store ? cma->store(cm, buf, len) : -EINVAL;
722 }
723 
724 static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf)
725 {
726  return sprintf(buf, "%d\n", cm->nodeid);
727 }
728 
729 static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf,
730  size_t len)
731 {
732  cm->nodeid = simple_strtol(buf, NULL, 0);
733  return len;
734 }
735 
736 static ssize_t comm_local_read(struct dlm_comm *cm, char *buf)
737 {
738  return sprintf(buf, "%d\n", cm->local);
739 }
740 
741 static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf,
742  size_t len)
743 {
744  cm->local= simple_strtol(buf, NULL, 0);
745  if (cm->local && !local_comm)
746  local_comm = cm;
747  return len;
748 }
749 
750 static ssize_t comm_addr_write(struct dlm_comm *cm, const char *buf, size_t len)
751 {
752  struct sockaddr_storage *addr;
753  int rv;
754 
755  if (len != sizeof(struct sockaddr_storage))
756  return -EINVAL;
757 
758  if (cm->addr_count >= DLM_MAX_ADDR_COUNT)
759  return -ENOSPC;
760 
761  addr = kzalloc(sizeof(*addr), GFP_NOFS);
762  if (!addr)
763  return -ENOMEM;
764 
765  memcpy(addr, buf, len);
766 
767  rv = dlm_lowcomms_addr(cm->nodeid, addr, len);
768  if (rv) {
769  kfree(addr);
770  return rv;
771  }
772 
773  cm->addr[cm->addr_count++] = addr;
774  return len;
775 }
776 
777 static ssize_t comm_addr_list_read(struct dlm_comm *cm, char *buf)
778 {
779  ssize_t s;
780  ssize_t allowance;
781  int i;
782  struct sockaddr_storage *addr;
783  struct sockaddr_in *addr_in;
784  struct sockaddr_in6 *addr_in6;
785 
786  /* Taken from ip6_addr_string() defined in lib/vsprintf.c */
787  char buf0[sizeof("AF_INET6 xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255\n")];
788 
789 
790  /* Derived from SIMPLE_ATTR_SIZE of fs/configfs/file.c */
791  allowance = 4096;
792  buf[0] = '\0';
793 
794  for (i = 0; i < cm->addr_count; i++) {
795  addr = cm->addr[i];
796 
797  switch(addr->ss_family) {
798  case AF_INET:
799  addr_in = (struct sockaddr_in *)addr;
800  s = sprintf(buf0, "AF_INET %pI4\n", &addr_in->sin_addr.s_addr);
801  break;
802  case AF_INET6:
803  addr_in6 = (struct sockaddr_in6 *)addr;
804  s = sprintf(buf0, "AF_INET6 %pI6\n", &addr_in6->sin6_addr);
805  break;
806  default:
807  s = sprintf(buf0, "%s\n", "<UNKNOWN>");
808  break;
809  }
810  allowance -= s;
811  if (allowance >= 0)
812  strcat(buf, buf0);
813  else {
814  allowance += s;
815  break;
816  }
817  }
818  return 4096 - allowance;
819 }
820 
821 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
822  char *buf)
823 {
824  struct dlm_node *nd = config_item_to_node(i);
825  struct node_attribute *nda =
826  container_of(a, struct node_attribute, attr);
827  return nda->show ? nda->show(nd, buf) : 0;
828 }
829 
830 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
831  const char *buf, size_t len)
832 {
833  struct dlm_node *nd = config_item_to_node(i);
834  struct node_attribute *nda =
835  container_of(a, struct node_attribute, attr);
836  return nda->store ? nda->store(nd, buf, len) : -EINVAL;
837 }
838 
839 static ssize_t node_nodeid_read(struct dlm_node *nd, char *buf)
840 {
841  return sprintf(buf, "%d\n", nd->nodeid);
842 }
843 
844 static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf,
845  size_t len)
846 {
847  uint32_t seq = 0;
848  nd->nodeid = simple_strtol(buf, NULL, 0);
849  dlm_comm_seq(nd->nodeid, &seq);
850  nd->comm_seq = seq;
851  return len;
852 }
853 
854 static ssize_t node_weight_read(struct dlm_node *nd, char *buf)
855 {
856  return sprintf(buf, "%d\n", nd->weight);
857 }
858 
859 static ssize_t node_weight_write(struct dlm_node *nd, const char *buf,
860  size_t len)
861 {
862  nd->weight = simple_strtol(buf, NULL, 0);
863  return len;
864 }
865 
866 /*
867  * Functions for the dlm to get the info that's been configured
868  */
869 
870 static struct dlm_space *get_space(char *name)
871 {
872  struct config_item *i;
873 
874  if (!space_list)
875  return NULL;
876 
877  mutex_lock(&space_list->cg_subsys->su_mutex);
878  i = config_group_find_item(space_list, name);
879  mutex_unlock(&space_list->cg_subsys->su_mutex);
880 
881  return config_item_to_space(i);
882 }
883 
884 static void put_space(struct dlm_space *sp)
885 {
886  config_item_put(&sp->group.cg_item);
887 }
888 
889 static struct dlm_comm *get_comm(int nodeid)
890 {
891  struct config_item *i;
892  struct dlm_comm *cm = NULL;
893  int found = 0;
894 
895  if (!comm_list)
896  return NULL;
897 
898  mutex_lock(&clusters_root.subsys.su_mutex);
899 
900  list_for_each_entry(i, &comm_list->cg_children, ci_entry) {
901  cm = config_item_to_comm(i);
902 
903  if (cm->nodeid != nodeid)
904  continue;
905  found = 1;
906  config_item_get(i);
907  break;
908  }
909  mutex_unlock(&clusters_root.subsys.su_mutex);
910 
911  if (!found)
912  cm = NULL;
913  return cm;
914 }
915 
916 static void put_comm(struct dlm_comm *cm)
917 {
918  config_item_put(&cm->item);
919 }
920 
921 /* caller must free mem */
922 int dlm_config_nodes(char *lsname, struct dlm_config_node **nodes_out,
923  int *count_out)
924 {
925  struct dlm_space *sp;
926  struct dlm_node *nd;
927  struct dlm_config_node *nodes, *node;
928  int rv, count;
929 
930  sp = get_space(lsname);
931  if (!sp)
932  return -EEXIST;
933 
934  mutex_lock(&sp->members_lock);
935  if (!sp->members_count) {
936  rv = -EINVAL;
937  printk(KERN_ERR "dlm: zero members_count\n");
938  goto out;
939  }
940 
941  count = sp->members_count;
942 
943  nodes = kcalloc(count, sizeof(struct dlm_config_node), GFP_NOFS);
944  if (!nodes) {
945  rv = -ENOMEM;
946  goto out;
947  }
948 
949  node = nodes;
950  list_for_each_entry(nd, &sp->members, list) {
951  node->nodeid = nd->nodeid;
952  node->weight = nd->weight;
953  node->new = nd->new;
954  node->comm_seq = nd->comm_seq;
955  node++;
956 
957  nd->new = 0;
958  }
959 
960  *count_out = count;
961  *nodes_out = nodes;
962  rv = 0;
963  out:
965  put_space(sp);
966  return rv;
967 }
968 
969 int dlm_comm_seq(int nodeid, uint32_t *seq)
970 {
971  struct dlm_comm *cm = get_comm(nodeid);
972  if (!cm)
973  return -EEXIST;
974  *seq = cm->seq;
975  put_comm(cm);
976  return 0;
977 }
978 
979 int dlm_our_nodeid(void)
980 {
981  return local_comm ? local_comm->nodeid : 0;
982 }
983 
984 /* num 0 is first addr, num 1 is second addr */
985 int dlm_our_addr(struct sockaddr_storage *addr, int num)
986 {
987  if (!local_comm)
988  return -1;
989  if (num + 1 > local_comm->addr_count)
990  return -1;
991  memcpy(addr, local_comm->addr[num], sizeof(*addr));
992  return 0;
993 }
994 
995 /* Config file defaults */
996 #define DEFAULT_TCP_PORT 21064
997 #define DEFAULT_BUFFER_SIZE 4096
998 #define DEFAULT_RSBTBL_SIZE 1024
999 #define DEFAULT_RECOVER_TIMER 5
1000 #define DEFAULT_TOSS_SECS 10
1001 #define DEFAULT_SCAN_SECS 5
1002 #define DEFAULT_LOG_DEBUG 0
1003 #define DEFAULT_PROTOCOL 0
1004 #define DEFAULT_TIMEWARN_CS 500 /* 5 sec = 500 centiseconds */
1005 #define DEFAULT_WAITWARN_US 0
1006 #define DEFAULT_NEW_RSB_COUNT 128
1007 #define DEFAULT_RECOVER_CALLBACKS 0
1008 #define DEFAULT_CLUSTER_NAME ""
1009 
1011  .ci_tcp_port = DEFAULT_TCP_PORT,
1012  .ci_buffer_size = DEFAULT_BUFFER_SIZE,
1013  .ci_rsbtbl_size = DEFAULT_RSBTBL_SIZE,
1014  .ci_recover_timer = DEFAULT_RECOVER_TIMER,
1015  .ci_toss_secs = DEFAULT_TOSS_SECS,
1016  .ci_scan_secs = DEFAULT_SCAN_SECS,
1017  .ci_log_debug = DEFAULT_LOG_DEBUG,
1018  .ci_protocol = DEFAULT_PROTOCOL,
1019  .ci_timewarn_cs = DEFAULT_TIMEWARN_CS,
1020  .ci_waitwarn_us = DEFAULT_WAITWARN_US,
1021  .ci_new_rsb_count = DEFAULT_NEW_RSB_COUNT,
1022  .ci_recover_callbacks = DEFAULT_RECOVER_CALLBACKS,
1023  .ci_cluster_name = DEFAULT_CLUSTER_NAME
1024 };
1025