1 /******************************************************************************
2 *******************************************************************************
4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5 ** Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
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.
11 *******************************************************************************
12 ******************************************************************************/
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/configfs.h>
23 * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/nodeid
24 * /config/dlm/<cluster>/spaces/<space>/nodes/<node>/weight
25 * /config/dlm/<cluster>/comms/<comm>/nodeid
26 * /config/dlm/<cluster>/comms/<comm>/local
27 * /config/dlm/<cluster>/comms/<comm>/addr
28 * The <cluster> level is useless, but I haven't figured out how to avoid it.
31 static struct config_group *space_list;
32 static struct config_group *comm_list;
33 static struct comm *local_comm;
44 static struct config_group *make_cluster(struct config_group *, const char *);
45 static void drop_cluster(struct config_group *, struct config_item *);
46 static void release_cluster(struct config_item *);
47 static struct config_group *make_space(struct config_group *, const char *);
48 static void drop_space(struct config_group *, struct config_item *);
49 static void release_space(struct config_item *);
50 static struct config_item *make_comm(struct config_group *, const char *);
51 static void drop_comm(struct config_group *, struct config_item *);
52 static void release_comm(struct config_item *);
53 static struct config_item *make_node(struct config_group *, const char *);
54 static void drop_node(struct config_group *, struct config_item *);
55 static void release_node(struct config_item *);
57 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a,
59 static ssize_t store_cluster(struct config_item *i,
60 struct configfs_attribute *a,
61 const char *buf, size_t len);
62 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
64 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
65 const char *buf, size_t len);
66 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
68 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
69 const char *buf, size_t len);
71 static ssize_t comm_nodeid_read(struct comm *cm, char *buf);
72 static ssize_t comm_nodeid_write(struct comm *cm, const char *buf, size_t len);
73 static ssize_t comm_local_read(struct comm *cm, char *buf);
74 static ssize_t comm_local_write(struct comm *cm, const char *buf, size_t len);
75 static ssize_t comm_addr_write(struct comm *cm, const char *buf, size_t len);
76 static ssize_t node_nodeid_read(struct node *nd, char *buf);
77 static ssize_t node_nodeid_write(struct node *nd, const char *buf, size_t len);
78 static ssize_t node_weight_read(struct node *nd, char *buf);
79 static ssize_t node_weight_write(struct node *nd, const char *buf, size_t len);
82 struct config_group group;
83 unsigned int cl_tcp_port;
84 unsigned int cl_buffer_size;
85 unsigned int cl_rsbtbl_size;
86 unsigned int cl_lkbtbl_size;
87 unsigned int cl_dirtbl_size;
88 unsigned int cl_recover_timer;
89 unsigned int cl_toss_secs;
90 unsigned int cl_scan_secs;
91 unsigned int cl_log_debug;
92 unsigned int cl_protocol;
93 unsigned int cl_timewarn_cs;
97 CLUSTER_ATTR_TCP_PORT = 0,
98 CLUSTER_ATTR_BUFFER_SIZE,
99 CLUSTER_ATTR_RSBTBL_SIZE,
100 CLUSTER_ATTR_LKBTBL_SIZE,
101 CLUSTER_ATTR_DIRTBL_SIZE,
102 CLUSTER_ATTR_RECOVER_TIMER,
103 CLUSTER_ATTR_TOSS_SECS,
104 CLUSTER_ATTR_SCAN_SECS,
105 CLUSTER_ATTR_LOG_DEBUG,
106 CLUSTER_ATTR_PROTOCOL,
107 CLUSTER_ATTR_TIMEWARN_CS,
110 struct cluster_attribute {
111 struct configfs_attribute attr;
112 ssize_t (*show)(struct cluster *, char *);
113 ssize_t (*store)(struct cluster *, const char *, size_t);
116 static ssize_t cluster_set(struct cluster *cl, unsigned int *cl_field,
117 unsigned int *info_field, int check_zero,
118 const char *buf, size_t len)
122 if (!capable(CAP_SYS_ADMIN))
125 x = simple_strtoul(buf, NULL, 0);
127 if (check_zero && !x)
136 #define __CONFIGFS_ATTR(_name,_mode,_read,_write) { \
137 .attr = { .ca_name = __stringify(_name), \
139 .ca_owner = THIS_MODULE }, \
144 #define CLUSTER_ATTR(name, check_zero) \
145 static ssize_t name##_write(struct cluster *cl, const char *buf, size_t len) \
147 return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \
148 check_zero, buf, len); \
150 static ssize_t name##_read(struct cluster *cl, char *buf) \
152 return snprintf(buf, PAGE_SIZE, "%u\n", cl->cl_##name); \
154 static struct cluster_attribute cluster_attr_##name = \
155 __CONFIGFS_ATTR(name, 0644, name##_read, name##_write)
157 CLUSTER_ATTR(tcp_port, 1);
158 CLUSTER_ATTR(buffer_size, 1);
159 CLUSTER_ATTR(rsbtbl_size, 1);
160 CLUSTER_ATTR(lkbtbl_size, 1);
161 CLUSTER_ATTR(dirtbl_size, 1);
162 CLUSTER_ATTR(recover_timer, 1);
163 CLUSTER_ATTR(toss_secs, 1);
164 CLUSTER_ATTR(scan_secs, 1);
165 CLUSTER_ATTR(log_debug, 0);
166 CLUSTER_ATTR(protocol, 0);
167 CLUSTER_ATTR(timewarn_cs, 1);
169 static struct configfs_attribute *cluster_attrs[] = {
170 [CLUSTER_ATTR_TCP_PORT] = &cluster_attr_tcp_port.attr,
171 [CLUSTER_ATTR_BUFFER_SIZE] = &cluster_attr_buffer_size.attr,
172 [CLUSTER_ATTR_RSBTBL_SIZE] = &cluster_attr_rsbtbl_size.attr,
173 [CLUSTER_ATTR_LKBTBL_SIZE] = &cluster_attr_lkbtbl_size.attr,
174 [CLUSTER_ATTR_DIRTBL_SIZE] = &cluster_attr_dirtbl_size.attr,
175 [CLUSTER_ATTR_RECOVER_TIMER] = &cluster_attr_recover_timer.attr,
176 [CLUSTER_ATTR_TOSS_SECS] = &cluster_attr_toss_secs.attr,
177 [CLUSTER_ATTR_SCAN_SECS] = &cluster_attr_scan_secs.attr,
178 [CLUSTER_ATTR_LOG_DEBUG] = &cluster_attr_log_debug.attr,
179 [CLUSTER_ATTR_PROTOCOL] = &cluster_attr_protocol.attr,
180 [CLUSTER_ATTR_TIMEWARN_CS] = &cluster_attr_timewarn_cs.attr,
185 COMM_ATTR_NODEID = 0,
190 struct comm_attribute {
191 struct configfs_attribute attr;
192 ssize_t (*show)(struct comm *, char *);
193 ssize_t (*store)(struct comm *, const char *, size_t);
196 static struct comm_attribute comm_attr_nodeid = {
197 .attr = { .ca_owner = THIS_MODULE,
199 .ca_mode = S_IRUGO | S_IWUSR },
200 .show = comm_nodeid_read,
201 .store = comm_nodeid_write,
204 static struct comm_attribute comm_attr_local = {
205 .attr = { .ca_owner = THIS_MODULE,
207 .ca_mode = S_IRUGO | S_IWUSR },
208 .show = comm_local_read,
209 .store = comm_local_write,
212 static struct comm_attribute comm_attr_addr = {
213 .attr = { .ca_owner = THIS_MODULE,
215 .ca_mode = S_IRUGO | S_IWUSR },
216 .store = comm_addr_write,
219 static struct configfs_attribute *comm_attrs[] = {
220 [COMM_ATTR_NODEID] = &comm_attr_nodeid.attr,
221 [COMM_ATTR_LOCAL] = &comm_attr_local.attr,
222 [COMM_ATTR_ADDR] = &comm_attr_addr.attr,
227 NODE_ATTR_NODEID = 0,
231 struct node_attribute {
232 struct configfs_attribute attr;
233 ssize_t (*show)(struct node *, char *);
234 ssize_t (*store)(struct node *, const char *, size_t);
237 static struct node_attribute node_attr_nodeid = {
238 .attr = { .ca_owner = THIS_MODULE,
240 .ca_mode = S_IRUGO | S_IWUSR },
241 .show = node_nodeid_read,
242 .store = node_nodeid_write,
245 static struct node_attribute node_attr_weight = {
246 .attr = { .ca_owner = THIS_MODULE,
248 .ca_mode = S_IRUGO | S_IWUSR },
249 .show = node_weight_read,
250 .store = node_weight_write,
253 static struct configfs_attribute *node_attrs[] = {
254 [NODE_ATTR_NODEID] = &node_attr_nodeid.attr,
255 [NODE_ATTR_WEIGHT] = &node_attr_weight.attr,
260 struct configfs_subsystem subsys;
264 struct config_group ss_group;
268 struct config_group group;
269 struct list_head members;
270 struct mutex members_lock;
275 struct config_group cs_group;
279 struct config_item item;
283 struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT];
287 struct config_group ns_group;
291 struct config_item item;
292 struct list_head list; /* space->members */
297 static struct configfs_group_operations clusters_ops = {
298 .make_group = make_cluster,
299 .drop_item = drop_cluster,
302 static struct configfs_item_operations cluster_ops = {
303 .release = release_cluster,
304 .show_attribute = show_cluster,
305 .store_attribute = store_cluster,
308 static struct configfs_group_operations spaces_ops = {
309 .make_group = make_space,
310 .drop_item = drop_space,
313 static struct configfs_item_operations space_ops = {
314 .release = release_space,
317 static struct configfs_group_operations comms_ops = {
318 .make_item = make_comm,
319 .drop_item = drop_comm,
322 static struct configfs_item_operations comm_ops = {
323 .release = release_comm,
324 .show_attribute = show_comm,
325 .store_attribute = store_comm,
328 static struct configfs_group_operations nodes_ops = {
329 .make_item = make_node,
330 .drop_item = drop_node,
333 static struct configfs_item_operations node_ops = {
334 .release = release_node,
335 .show_attribute = show_node,
336 .store_attribute = store_node,
339 static struct config_item_type clusters_type = {
340 .ct_group_ops = &clusters_ops,
341 .ct_owner = THIS_MODULE,
344 static struct config_item_type cluster_type = {
345 .ct_item_ops = &cluster_ops,
346 .ct_attrs = cluster_attrs,
347 .ct_owner = THIS_MODULE,
350 static struct config_item_type spaces_type = {
351 .ct_group_ops = &spaces_ops,
352 .ct_owner = THIS_MODULE,
355 static struct config_item_type space_type = {
356 .ct_item_ops = &space_ops,
357 .ct_owner = THIS_MODULE,
360 static struct config_item_type comms_type = {
361 .ct_group_ops = &comms_ops,
362 .ct_owner = THIS_MODULE,
365 static struct config_item_type comm_type = {
366 .ct_item_ops = &comm_ops,
367 .ct_attrs = comm_attrs,
368 .ct_owner = THIS_MODULE,
371 static struct config_item_type nodes_type = {
372 .ct_group_ops = &nodes_ops,
373 .ct_owner = THIS_MODULE,
376 static struct config_item_type node_type = {
377 .ct_item_ops = &node_ops,
378 .ct_attrs = node_attrs,
379 .ct_owner = THIS_MODULE,
382 static struct cluster *to_cluster(struct config_item *i)
384 return i ? container_of(to_config_group(i), struct cluster, group):NULL;
387 static struct space *to_space(struct config_item *i)
389 return i ? container_of(to_config_group(i), struct space, group) : NULL;
392 static struct comm *to_comm(struct config_item *i)
394 return i ? container_of(i, struct comm, item) : NULL;
397 static struct node *to_node(struct config_item *i)
399 return i ? container_of(i, struct node, item) : NULL;
402 static struct config_group *make_cluster(struct config_group *g,
405 struct cluster *cl = NULL;
406 struct spaces *sps = NULL;
407 struct comms *cms = NULL;
410 cl = kzalloc(sizeof(struct cluster), GFP_KERNEL);
411 gps = kcalloc(3, sizeof(struct config_group *), GFP_KERNEL);
412 sps = kzalloc(sizeof(struct spaces), GFP_KERNEL);
413 cms = kzalloc(sizeof(struct comms), GFP_KERNEL);
415 if (!cl || !gps || !sps || !cms)
418 config_group_init_type_name(&cl->group, name, &cluster_type);
419 config_group_init_type_name(&sps->ss_group, "spaces", &spaces_type);
420 config_group_init_type_name(&cms->cs_group, "comms", &comms_type);
422 cl->group.default_groups = gps;
423 cl->group.default_groups[0] = &sps->ss_group;
424 cl->group.default_groups[1] = &cms->cs_group;
425 cl->group.default_groups[2] = NULL;
427 cl->cl_tcp_port = dlm_config.ci_tcp_port;
428 cl->cl_buffer_size = dlm_config.ci_buffer_size;
429 cl->cl_rsbtbl_size = dlm_config.ci_rsbtbl_size;
430 cl->cl_lkbtbl_size = dlm_config.ci_lkbtbl_size;
431 cl->cl_dirtbl_size = dlm_config.ci_dirtbl_size;
432 cl->cl_recover_timer = dlm_config.ci_recover_timer;
433 cl->cl_toss_secs = dlm_config.ci_toss_secs;
434 cl->cl_scan_secs = dlm_config.ci_scan_secs;
435 cl->cl_log_debug = dlm_config.ci_log_debug;
437 space_list = &sps->ss_group;
438 comm_list = &cms->cs_group;
449 static void drop_cluster(struct config_group *g, struct config_item *i)
451 struct cluster *cl = to_cluster(i);
452 struct config_item *tmp;
455 for (j = 0; cl->group.default_groups[j]; j++) {
456 tmp = &cl->group.default_groups[j]->cg_item;
457 cl->group.default_groups[j] = NULL;
458 config_item_put(tmp);
467 static void release_cluster(struct config_item *i)
469 struct cluster *cl = to_cluster(i);
470 kfree(cl->group.default_groups);
474 static struct config_group *make_space(struct config_group *g, const char *name)
476 struct space *sp = NULL;
477 struct nodes *nds = NULL;
480 sp = kzalloc(sizeof(struct space), GFP_KERNEL);
481 gps = kcalloc(2, sizeof(struct config_group *), GFP_KERNEL);
482 nds = kzalloc(sizeof(struct nodes), GFP_KERNEL);
484 if (!sp || !gps || !nds)
487 config_group_init_type_name(&sp->group, name, &space_type);
488 config_group_init_type_name(&nds->ns_group, "nodes", &nodes_type);
490 sp->group.default_groups = gps;
491 sp->group.default_groups[0] = &nds->ns_group;
492 sp->group.default_groups[1] = NULL;
494 INIT_LIST_HEAD(&sp->members);
495 mutex_init(&sp->members_lock);
496 sp->members_count = 0;
506 static void drop_space(struct config_group *g, struct config_item *i)
508 struct space *sp = to_space(i);
509 struct config_item *tmp;
512 /* assert list_empty(&sp->members) */
514 for (j = 0; sp->group.default_groups[j]; j++) {
515 tmp = &sp->group.default_groups[j]->cg_item;
516 sp->group.default_groups[j] = NULL;
517 config_item_put(tmp);
523 static void release_space(struct config_item *i)
525 struct space *sp = to_space(i);
526 kfree(sp->group.default_groups);
530 static struct config_item *make_comm(struct config_group *g, const char *name)
534 cm = kzalloc(sizeof(struct comm), GFP_KERNEL);
538 config_item_init_type_name(&cm->item, name, &comm_type);
545 static void drop_comm(struct config_group *g, struct config_item *i)
547 struct comm *cm = to_comm(i);
548 if (local_comm == cm)
550 dlm_lowcomms_close(cm->nodeid);
551 while (cm->addr_count--)
552 kfree(cm->addr[cm->addr_count]);
556 static void release_comm(struct config_item *i)
558 struct comm *cm = to_comm(i);
562 static struct config_item *make_node(struct config_group *g, const char *name)
564 struct space *sp = to_space(g->cg_item.ci_parent);
567 nd = kzalloc(sizeof(struct node), GFP_KERNEL);
571 config_item_init_type_name(&nd->item, name, &node_type);
573 nd->weight = 1; /* default weight of 1 if none is set */
575 mutex_lock(&sp->members_lock);
576 list_add(&nd->list, &sp->members);
578 mutex_unlock(&sp->members_lock);
583 static void drop_node(struct config_group *g, struct config_item *i)
585 struct space *sp = to_space(g->cg_item.ci_parent);
586 struct node *nd = to_node(i);
588 mutex_lock(&sp->members_lock);
591 mutex_unlock(&sp->members_lock);
596 static void release_node(struct config_item *i)
598 struct node *nd = to_node(i);
602 static struct clusters clusters_root = {
607 .ci_type = &clusters_type,
613 int dlm_config_init(void)
615 config_group_init(&clusters_root.subsys.su_group);
616 init_MUTEX(&clusters_root.subsys.su_sem);
617 return configfs_register_subsystem(&clusters_root.subsys);
620 void dlm_config_exit(void)
622 configfs_unregister_subsystem(&clusters_root.subsys);
626 * Functions for user space to read/write attributes
629 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a,
632 struct cluster *cl = to_cluster(i);
633 struct cluster_attribute *cla =
634 container_of(a, struct cluster_attribute, attr);
635 return cla->show ? cla->show(cl, buf) : 0;
638 static ssize_t store_cluster(struct config_item *i,
639 struct configfs_attribute *a,
640 const char *buf, size_t len)
642 struct cluster *cl = to_cluster(i);
643 struct cluster_attribute *cla =
644 container_of(a, struct cluster_attribute, attr);
645 return cla->store ? cla->store(cl, buf, len) : -EINVAL;
648 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a,
651 struct comm *cm = to_comm(i);
652 struct comm_attribute *cma =
653 container_of(a, struct comm_attribute, attr);
654 return cma->show ? cma->show(cm, buf) : 0;
657 static ssize_t store_comm(struct config_item *i, struct configfs_attribute *a,
658 const char *buf, size_t len)
660 struct comm *cm = to_comm(i);
661 struct comm_attribute *cma =
662 container_of(a, struct comm_attribute, attr);
663 return cma->store ? cma->store(cm, buf, len) : -EINVAL;
666 static ssize_t comm_nodeid_read(struct comm *cm, char *buf)
668 return sprintf(buf, "%d\n", cm->nodeid);
671 static ssize_t comm_nodeid_write(struct comm *cm, const char *buf, size_t len)
673 cm->nodeid = simple_strtol(buf, NULL, 0);
677 static ssize_t comm_local_read(struct comm *cm, char *buf)
679 return sprintf(buf, "%d\n", cm->local);
682 static ssize_t comm_local_write(struct comm *cm, const char *buf, size_t len)
684 cm->local= simple_strtol(buf, NULL, 0);
685 if (cm->local && !local_comm)
690 static ssize_t comm_addr_write(struct comm *cm, const char *buf, size_t len)
692 struct sockaddr_storage *addr;
694 if (len != sizeof(struct sockaddr_storage))
697 if (cm->addr_count >= DLM_MAX_ADDR_COUNT)
700 addr = kzalloc(sizeof(*addr), GFP_KERNEL);
704 memcpy(addr, buf, len);
705 cm->addr[cm->addr_count++] = addr;
709 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a,
712 struct node *nd = to_node(i);
713 struct node_attribute *nda =
714 container_of(a, struct node_attribute, attr);
715 return nda->show ? nda->show(nd, buf) : 0;
718 static ssize_t store_node(struct config_item *i, struct configfs_attribute *a,
719 const char *buf, size_t len)
721 struct node *nd = to_node(i);
722 struct node_attribute *nda =
723 container_of(a, struct node_attribute, attr);
724 return nda->store ? nda->store(nd, buf, len) : -EINVAL;
727 static ssize_t node_nodeid_read(struct node *nd, char *buf)
729 return sprintf(buf, "%d\n", nd->nodeid);
732 static ssize_t node_nodeid_write(struct node *nd, const char *buf, size_t len)
734 nd->nodeid = simple_strtol(buf, NULL, 0);
738 static ssize_t node_weight_read(struct node *nd, char *buf)
740 return sprintf(buf, "%d\n", nd->weight);
743 static ssize_t node_weight_write(struct node *nd, const char *buf, size_t len)
745 nd->weight = simple_strtol(buf, NULL, 0);
750 * Functions for the dlm to get the info that's been configured
753 static struct space *get_space(char *name)
755 struct config_item *i;
760 down(&space_list->cg_subsys->su_sem);
761 i = config_group_find_obj(space_list, name);
762 up(&space_list->cg_subsys->su_sem);
767 static void put_space(struct space *sp)
769 config_item_put(&sp->group.cg_item);
772 static struct comm *get_comm(int nodeid, struct sockaddr_storage *addr)
774 struct config_item *i;
775 struct comm *cm = NULL;
781 down(&clusters_root.subsys.su_sem);
783 list_for_each_entry(i, &comm_list->cg_children, ci_entry) {
787 if (cm->nodeid != nodeid)
793 if (!cm->addr_count ||
794 memcmp(cm->addr[0], addr, sizeof(*addr)))
801 up(&clusters_root.subsys.su_sem);
808 static void put_comm(struct comm *cm)
810 config_item_put(&cm->item);
813 /* caller must free mem */
814 int dlm_nodeid_list(char *lsname, int **ids_out)
821 sp = get_space(lsname);
825 mutex_lock(&sp->members_lock);
826 if (!sp->members_count) {
831 ids = kcalloc(sp->members_count, sizeof(int), GFP_KERNEL);
837 rv = sp->members_count;
838 list_for_each_entry(nd, &sp->members, list)
839 ids[i++] = nd->nodeid;
842 printk("bad nodeid count %d %d\n", rv, i);
846 mutex_unlock(&sp->members_lock);
851 int dlm_node_weight(char *lsname, int nodeid)
857 sp = get_space(lsname);
861 mutex_lock(&sp->members_lock);
862 list_for_each_entry(nd, &sp->members, list) {
863 if (nd->nodeid != nodeid)
868 mutex_unlock(&sp->members_lock);
874 int dlm_nodeid_to_addr(int nodeid, struct sockaddr_storage *addr)
876 struct comm *cm = get_comm(nodeid, NULL);
881 memcpy(addr, cm->addr[0], sizeof(*addr));
886 int dlm_addr_to_nodeid(struct sockaddr_storage *addr, int *nodeid)
888 struct comm *cm = get_comm(0, addr);
891 *nodeid = cm->nodeid;
896 int dlm_our_nodeid(void)
898 return local_comm ? local_comm->nodeid : 0;
901 /* num 0 is first addr, num 1 is second addr */
902 int dlm_our_addr(struct sockaddr_storage *addr, int num)
906 if (num + 1 > local_comm->addr_count)
908 memcpy(addr, local_comm->addr[num], sizeof(*addr));
912 /* Config file defaults */
913 #define DEFAULT_TCP_PORT 21064
914 #define DEFAULT_BUFFER_SIZE 4096
915 #define DEFAULT_RSBTBL_SIZE 256
916 #define DEFAULT_LKBTBL_SIZE 1024
917 #define DEFAULT_DIRTBL_SIZE 512
918 #define DEFAULT_RECOVER_TIMER 5
919 #define DEFAULT_TOSS_SECS 10
920 #define DEFAULT_SCAN_SECS 5
921 #define DEFAULT_LOG_DEBUG 0
922 #define DEFAULT_PROTOCOL 0
923 #define DEFAULT_TIMEWARN_CS 500 /* 5 sec = 500 centiseconds */
925 struct dlm_config_info dlm_config = {
926 .ci_tcp_port = DEFAULT_TCP_PORT,
927 .ci_buffer_size = DEFAULT_BUFFER_SIZE,
928 .ci_rsbtbl_size = DEFAULT_RSBTBL_SIZE,
929 .ci_lkbtbl_size = DEFAULT_LKBTBL_SIZE,
930 .ci_dirtbl_size = DEFAULT_DIRTBL_SIZE,
931 .ci_recover_timer = DEFAULT_RECOVER_TIMER,
932 .ci_toss_secs = DEFAULT_TOSS_SECS,
933 .ci_scan_secs = DEFAULT_SCAN_SECS,
934 .ci_log_debug = DEFAULT_LOG_DEBUG,
935 .ci_protocol = DEFAULT_PROTOCOL,
936 .ci_timewarn_cs = DEFAULT_TIMEWARN_CS