1 /******************************************************************************
2 *******************************************************************************
4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5 ** Copyright (C) 2004-2011 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>
17 #include <linux/slab.h>
19 #include <linux/in6.h>
20 #include <linux/dlmconstants.h>
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.
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
;
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
*);
64 static struct configfs_attribute
*comm_attrs
[];
65 static struct configfs_attribute
*node_attrs
[];
68 struct config_group group
;
69 unsigned int cl_tcp_port
;
70 unsigned int cl_buffer_size
;
71 unsigned int cl_rsbtbl_size
;
72 unsigned int cl_recover_timer
;
73 unsigned int cl_toss_secs
;
74 unsigned int cl_scan_secs
;
75 unsigned int cl_log_debug
;
76 unsigned int cl_protocol
;
77 unsigned int cl_timewarn_cs
;
78 unsigned int cl_waitwarn_us
;
79 unsigned int cl_new_rsb_count
;
80 unsigned int cl_recover_callbacks
;
81 char cl_cluster_name
[DLM_LOCKSPACE_LEN
];
84 static struct dlm_cluster
*config_item_to_cluster(struct config_item
*i
)
86 return i
? container_of(to_config_group(i
), struct dlm_cluster
, group
) :
91 CLUSTER_ATTR_TCP_PORT
= 0,
92 CLUSTER_ATTR_BUFFER_SIZE
,
93 CLUSTER_ATTR_RSBTBL_SIZE
,
94 CLUSTER_ATTR_RECOVER_TIMER
,
95 CLUSTER_ATTR_TOSS_SECS
,
96 CLUSTER_ATTR_SCAN_SECS
,
97 CLUSTER_ATTR_LOG_DEBUG
,
98 CLUSTER_ATTR_PROTOCOL
,
99 CLUSTER_ATTR_TIMEWARN_CS
,
100 CLUSTER_ATTR_WAITWARN_US
,
101 CLUSTER_ATTR_NEW_RSB_COUNT
,
102 CLUSTER_ATTR_RECOVER_CALLBACKS
,
103 CLUSTER_ATTR_CLUSTER_NAME
,
106 static ssize_t
cluster_cluster_name_show(struct config_item
*item
, char *buf
)
108 struct dlm_cluster
*cl
= config_item_to_cluster(item
);
109 return sprintf(buf
, "%s\n", cl
->cl_cluster_name
);
112 static ssize_t
cluster_cluster_name_store(struct config_item
*item
,
113 const char *buf
, size_t len
)
115 struct dlm_cluster
*cl
= config_item_to_cluster(item
);
117 strlcpy(dlm_config
.ci_cluster_name
, buf
,
118 sizeof(dlm_config
.ci_cluster_name
));
119 strlcpy(cl
->cl_cluster_name
, buf
, sizeof(cl
->cl_cluster_name
));
123 CONFIGFS_ATTR(cluster_
, cluster_name
);
125 static ssize_t
cluster_set(struct dlm_cluster
*cl
, unsigned int *cl_field
,
126 int *info_field
, int check_zero
,
127 const char *buf
, size_t len
)
132 if (!capable(CAP_SYS_ADMIN
))
134 rc
= kstrtouint(buf
, 0, &x
);
138 if (check_zero
&& !x
)
147 #define CLUSTER_ATTR(name, check_zero) \
148 static ssize_t cluster_##name##_store(struct config_item *item, \
149 const char *buf, size_t len) \
151 struct dlm_cluster *cl = config_item_to_cluster(item); \
152 return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \
153 check_zero, buf, len); \
155 static ssize_t cluster_##name##_show(struct config_item *item, char *buf) \
157 struct dlm_cluster *cl = config_item_to_cluster(item); \
158 return snprintf(buf, PAGE_SIZE, "%u\n", cl->cl_##name); \
160 CONFIGFS_ATTR(cluster_, name);
162 CLUSTER_ATTR(tcp_port
, 1);
163 CLUSTER_ATTR(buffer_size
, 1);
164 CLUSTER_ATTR(rsbtbl_size
, 1);
165 CLUSTER_ATTR(recover_timer
, 1);
166 CLUSTER_ATTR(toss_secs
, 1);
167 CLUSTER_ATTR(scan_secs
, 1);
168 CLUSTER_ATTR(log_debug
, 0);
169 CLUSTER_ATTR(protocol
, 0);
170 CLUSTER_ATTR(timewarn_cs
, 1);
171 CLUSTER_ATTR(waitwarn_us
, 0);
172 CLUSTER_ATTR(new_rsb_count
, 0);
173 CLUSTER_ATTR(recover_callbacks
, 0);
175 static struct configfs_attribute
*cluster_attrs
[] = {
176 [CLUSTER_ATTR_TCP_PORT
] = &cluster_attr_tcp_port
,
177 [CLUSTER_ATTR_BUFFER_SIZE
] = &cluster_attr_buffer_size
,
178 [CLUSTER_ATTR_RSBTBL_SIZE
] = &cluster_attr_rsbtbl_size
,
179 [CLUSTER_ATTR_RECOVER_TIMER
] = &cluster_attr_recover_timer
,
180 [CLUSTER_ATTR_TOSS_SECS
] = &cluster_attr_toss_secs
,
181 [CLUSTER_ATTR_SCAN_SECS
] = &cluster_attr_scan_secs
,
182 [CLUSTER_ATTR_LOG_DEBUG
] = &cluster_attr_log_debug
,
183 [CLUSTER_ATTR_PROTOCOL
] = &cluster_attr_protocol
,
184 [CLUSTER_ATTR_TIMEWARN_CS
] = &cluster_attr_timewarn_cs
,
185 [CLUSTER_ATTR_WAITWARN_US
] = &cluster_attr_waitwarn_us
,
186 [CLUSTER_ATTR_NEW_RSB_COUNT
] = &cluster_attr_new_rsb_count
,
187 [CLUSTER_ATTR_RECOVER_CALLBACKS
] = &cluster_attr_recover_callbacks
,
188 [CLUSTER_ATTR_CLUSTER_NAME
] = &cluster_attr_cluster_name
,
193 COMM_ATTR_NODEID
= 0,
200 NODE_ATTR_NODEID
= 0,
204 struct dlm_clusters
{
205 struct configfs_subsystem subsys
;
209 struct config_group ss_group
;
213 struct config_group group
;
214 struct list_head members
;
215 struct mutex members_lock
;
220 struct config_group cs_group
;
224 struct config_item item
;
229 struct sockaddr_storage
*addr
[DLM_MAX_ADDR_COUNT
];
233 struct config_group ns_group
;
237 struct config_item item
;
238 struct list_head list
; /* space->members */
242 int comm_seq
; /* copy of cm->seq when nd->nodeid is set */
245 static struct configfs_group_operations clusters_ops
= {
246 .make_group
= make_cluster
,
247 .drop_item
= drop_cluster
,
250 static struct configfs_item_operations cluster_ops
= {
251 .release
= release_cluster
,
254 static struct configfs_group_operations spaces_ops
= {
255 .make_group
= make_space
,
256 .drop_item
= drop_space
,
259 static struct configfs_item_operations space_ops
= {
260 .release
= release_space
,
263 static struct configfs_group_operations comms_ops
= {
264 .make_item
= make_comm
,
265 .drop_item
= drop_comm
,
268 static struct configfs_item_operations comm_ops
= {
269 .release
= release_comm
,
272 static struct configfs_group_operations nodes_ops
= {
273 .make_item
= make_node
,
274 .drop_item
= drop_node
,
277 static struct configfs_item_operations node_ops
= {
278 .release
= release_node
,
281 static struct config_item_type clusters_type
= {
282 .ct_group_ops
= &clusters_ops
,
283 .ct_owner
= THIS_MODULE
,
286 static struct config_item_type cluster_type
= {
287 .ct_item_ops
= &cluster_ops
,
288 .ct_attrs
= cluster_attrs
,
289 .ct_owner
= THIS_MODULE
,
292 static struct config_item_type spaces_type
= {
293 .ct_group_ops
= &spaces_ops
,
294 .ct_owner
= THIS_MODULE
,
297 static struct config_item_type space_type
= {
298 .ct_item_ops
= &space_ops
,
299 .ct_owner
= THIS_MODULE
,
302 static struct config_item_type comms_type
= {
303 .ct_group_ops
= &comms_ops
,
304 .ct_owner
= THIS_MODULE
,
307 static struct config_item_type comm_type
= {
308 .ct_item_ops
= &comm_ops
,
309 .ct_attrs
= comm_attrs
,
310 .ct_owner
= THIS_MODULE
,
313 static struct config_item_type nodes_type
= {
314 .ct_group_ops
= &nodes_ops
,
315 .ct_owner
= THIS_MODULE
,
318 static struct config_item_type node_type
= {
319 .ct_item_ops
= &node_ops
,
320 .ct_attrs
= node_attrs
,
321 .ct_owner
= THIS_MODULE
,
324 static struct dlm_space
*config_item_to_space(struct config_item
*i
)
326 return i
? container_of(to_config_group(i
), struct dlm_space
, group
) :
330 static struct dlm_comm
*config_item_to_comm(struct config_item
*i
)
332 return i
? container_of(i
, struct dlm_comm
, item
) : NULL
;
335 static struct dlm_node
*config_item_to_node(struct config_item
*i
)
337 return i
? container_of(i
, struct dlm_node
, item
) : NULL
;
340 static struct config_group
*make_cluster(struct config_group
*g
,
343 struct dlm_cluster
*cl
= NULL
;
344 struct dlm_spaces
*sps
= NULL
;
345 struct dlm_comms
*cms
= NULL
;
348 cl
= kzalloc(sizeof(struct dlm_cluster
), GFP_NOFS
);
349 sps
= kzalloc(sizeof(struct dlm_spaces
), GFP_NOFS
);
350 cms
= kzalloc(sizeof(struct dlm_comms
), GFP_NOFS
);
352 if (!cl
|| !gps
|| !sps
|| !cms
)
355 config_group_init_type_name(&cl
->group
, name
, &cluster_type
);
356 config_group_init_type_name(&sps
->ss_group
, "spaces", &spaces_type
);
357 config_group_init_type_name(&cms
->cs_group
, "comms", &comms_type
);
359 configfs_add_default_group(&sps
->ss_group
, &cl
->group
);
360 configfs_add_default_group(&cms
->cs_group
, &cl
->group
);
362 cl
->cl_tcp_port
= dlm_config
.ci_tcp_port
;
363 cl
->cl_buffer_size
= dlm_config
.ci_buffer_size
;
364 cl
->cl_rsbtbl_size
= dlm_config
.ci_rsbtbl_size
;
365 cl
->cl_recover_timer
= dlm_config
.ci_recover_timer
;
366 cl
->cl_toss_secs
= dlm_config
.ci_toss_secs
;
367 cl
->cl_scan_secs
= dlm_config
.ci_scan_secs
;
368 cl
->cl_log_debug
= dlm_config
.ci_log_debug
;
369 cl
->cl_protocol
= dlm_config
.ci_protocol
;
370 cl
->cl_timewarn_cs
= dlm_config
.ci_timewarn_cs
;
371 cl
->cl_waitwarn_us
= dlm_config
.ci_waitwarn_us
;
372 cl
->cl_new_rsb_count
= dlm_config
.ci_new_rsb_count
;
373 cl
->cl_recover_callbacks
= dlm_config
.ci_recover_callbacks
;
374 memcpy(cl
->cl_cluster_name
, dlm_config
.ci_cluster_name
,
377 space_list
= &sps
->ss_group
;
378 comm_list
= &cms
->cs_group
;
385 return ERR_PTR(-ENOMEM
);
388 static void drop_cluster(struct config_group
*g
, struct config_item
*i
)
390 struct dlm_cluster
*cl
= config_item_to_cluster(i
);
392 configfs_remove_default_groups(&cl
->group
);
400 static void release_cluster(struct config_item
*i
)
402 struct dlm_cluster
*cl
= config_item_to_cluster(i
);
406 static struct config_group
*make_space(struct config_group
*g
, const char *name
)
408 struct dlm_space
*sp
= NULL
;
409 struct dlm_nodes
*nds
= NULL
;
411 sp
= kzalloc(sizeof(struct dlm_space
), GFP_NOFS
);
412 nds
= kzalloc(sizeof(struct dlm_nodes
), GFP_NOFS
);
417 config_group_init_type_name(&sp
->group
, name
, &space_type
);
419 config_group_init_type_name(&nds
->ns_group
, "nodes", &nodes_type
);
420 configfs_add_default_group(&nds
->ns_group
, &sp
->group
);
422 INIT_LIST_HEAD(&sp
->members
);
423 mutex_init(&sp
->members_lock
);
424 sp
->members_count
= 0;
430 return ERR_PTR(-ENOMEM
);
433 static void drop_space(struct config_group
*g
, struct config_item
*i
)
435 struct dlm_space
*sp
= config_item_to_space(i
);
437 /* assert list_empty(&sp->members) */
439 configfs_remove_default_groups(&sp
->group
);
443 static void release_space(struct config_item
*i
)
445 struct dlm_space
*sp
= config_item_to_space(i
);
449 static struct config_item
*make_comm(struct config_group
*g
, const char *name
)
453 cm
= kzalloc(sizeof(struct dlm_comm
), GFP_NOFS
);
455 return ERR_PTR(-ENOMEM
);
457 config_item_init_type_name(&cm
->item
, name
, &comm_type
);
459 cm
->seq
= dlm_comm_count
++;
461 cm
->seq
= dlm_comm_count
++;
469 static void drop_comm(struct config_group
*g
, struct config_item
*i
)
471 struct dlm_comm
*cm
= config_item_to_comm(i
);
472 if (local_comm
== cm
)
474 dlm_lowcomms_close(cm
->nodeid
);
475 while (cm
->addr_count
--)
476 kfree(cm
->addr
[cm
->addr_count
]);
480 static void release_comm(struct config_item
*i
)
482 struct dlm_comm
*cm
= config_item_to_comm(i
);
486 static struct config_item
*make_node(struct config_group
*g
, const char *name
)
488 struct dlm_space
*sp
= config_item_to_space(g
->cg_item
.ci_parent
);
491 nd
= kzalloc(sizeof(struct dlm_node
), GFP_NOFS
);
493 return ERR_PTR(-ENOMEM
);
495 config_item_init_type_name(&nd
->item
, name
, &node_type
);
497 nd
->weight
= 1; /* default weight of 1 if none is set */
498 nd
->new = 1; /* set to 0 once it's been read by dlm_nodeid_list() */
500 mutex_lock(&sp
->members_lock
);
501 list_add(&nd
->list
, &sp
->members
);
503 mutex_unlock(&sp
->members_lock
);
508 static void drop_node(struct config_group
*g
, struct config_item
*i
)
510 struct dlm_space
*sp
= config_item_to_space(g
->cg_item
.ci_parent
);
511 struct dlm_node
*nd
= config_item_to_node(i
);
513 mutex_lock(&sp
->members_lock
);
516 mutex_unlock(&sp
->members_lock
);
521 static void release_node(struct config_item
*i
)
523 struct dlm_node
*nd
= config_item_to_node(i
);
527 static struct dlm_clusters clusters_root
= {
532 .ci_type
= &clusters_type
,
538 int __init
dlm_config_init(void)
540 config_group_init(&clusters_root
.subsys
.su_group
);
541 mutex_init(&clusters_root
.subsys
.su_mutex
);
542 return configfs_register_subsystem(&clusters_root
.subsys
);
545 void dlm_config_exit(void)
547 configfs_unregister_subsystem(&clusters_root
.subsys
);
551 * Functions for user space to read/write attributes
554 static ssize_t
comm_nodeid_show(struct config_item
*item
, char *buf
)
556 return sprintf(buf
, "%d\n", config_item_to_comm(item
)->nodeid
);
559 static ssize_t
comm_nodeid_store(struct config_item
*item
, const char *buf
,
562 int rc
= kstrtoint(buf
, 0, &config_item_to_comm(item
)->nodeid
);
569 static ssize_t
comm_local_show(struct config_item
*item
, char *buf
)
571 return sprintf(buf
, "%d\n", config_item_to_comm(item
)->local
);
574 static ssize_t
comm_local_store(struct config_item
*item
, const char *buf
,
577 struct dlm_comm
*cm
= config_item_to_comm(item
);
578 int rc
= kstrtoint(buf
, 0, &cm
->local
);
582 if (cm
->local
&& !local_comm
)
587 static ssize_t
comm_addr_store(struct config_item
*item
, const char *buf
,
590 struct dlm_comm
*cm
= config_item_to_comm(item
);
591 struct sockaddr_storage
*addr
;
594 if (len
!= sizeof(struct sockaddr_storage
))
597 if (cm
->addr_count
>= DLM_MAX_ADDR_COUNT
)
600 addr
= kzalloc(sizeof(*addr
), GFP_NOFS
);
604 memcpy(addr
, buf
, len
);
606 rv
= dlm_lowcomms_addr(cm
->nodeid
, addr
, len
);
612 cm
->addr
[cm
->addr_count
++] = addr
;
616 static ssize_t
comm_addr_list_show(struct config_item
*item
, char *buf
)
618 struct dlm_comm
*cm
= config_item_to_comm(item
);
622 struct sockaddr_storage
*addr
;
623 struct sockaddr_in
*addr_in
;
624 struct sockaddr_in6
*addr_in6
;
626 /* Taken from ip6_addr_string() defined in lib/vsprintf.c */
627 char buf0
[sizeof("AF_INET6 xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255\n")];
630 /* Derived from SIMPLE_ATTR_SIZE of fs/configfs/file.c */
634 for (i
= 0; i
< cm
->addr_count
; i
++) {
637 switch(addr
->ss_family
) {
639 addr_in
= (struct sockaddr_in
*)addr
;
640 s
= sprintf(buf0
, "AF_INET %pI4\n", &addr_in
->sin_addr
.s_addr
);
643 addr_in6
= (struct sockaddr_in6
*)addr
;
644 s
= sprintf(buf0
, "AF_INET6 %pI6\n", &addr_in6
->sin6_addr
);
647 s
= sprintf(buf0
, "%s\n", "<UNKNOWN>");
658 return 4096 - allowance
;
661 CONFIGFS_ATTR(comm_
, nodeid
);
662 CONFIGFS_ATTR(comm_
, local
);
663 CONFIGFS_ATTR_WO(comm_
, addr
);
664 CONFIGFS_ATTR_RO(comm_
, addr_list
);
666 static struct configfs_attribute
*comm_attrs
[] = {
667 [COMM_ATTR_NODEID
] = &comm_attr_nodeid
,
668 [COMM_ATTR_LOCAL
] = &comm_attr_local
,
669 [COMM_ATTR_ADDR
] = &comm_attr_addr
,
670 [COMM_ATTR_ADDR_LIST
] = &comm_attr_addr_list
,
674 static ssize_t
node_nodeid_show(struct config_item
*item
, char *buf
)
676 return sprintf(buf
, "%d\n", config_item_to_node(item
)->nodeid
);
679 static ssize_t
node_nodeid_store(struct config_item
*item
, const char *buf
,
682 struct dlm_node
*nd
= config_item_to_node(item
);
684 int rc
= kstrtoint(buf
, 0, &nd
->nodeid
);
688 dlm_comm_seq(nd
->nodeid
, &seq
);
693 static ssize_t
node_weight_show(struct config_item
*item
, char *buf
)
695 return sprintf(buf
, "%d\n", config_item_to_node(item
)->weight
);
698 static ssize_t
node_weight_store(struct config_item
*item
, const char *buf
,
701 int rc
= kstrtoint(buf
, 0, &config_item_to_node(item
)->weight
);
708 CONFIGFS_ATTR(node_
, nodeid
);
709 CONFIGFS_ATTR(node_
, weight
);
711 static struct configfs_attribute
*node_attrs
[] = {
712 [NODE_ATTR_NODEID
] = &node_attr_nodeid
,
713 [NODE_ATTR_WEIGHT
] = &node_attr_weight
,
718 * Functions for the dlm to get the info that's been configured
721 static struct dlm_space
*get_space(char *name
)
723 struct config_item
*i
;
728 mutex_lock(&space_list
->cg_subsys
->su_mutex
);
729 i
= config_group_find_item(space_list
, name
);
730 mutex_unlock(&space_list
->cg_subsys
->su_mutex
);
732 return config_item_to_space(i
);
735 static void put_space(struct dlm_space
*sp
)
737 config_item_put(&sp
->group
.cg_item
);
740 static struct dlm_comm
*get_comm(int nodeid
)
742 struct config_item
*i
;
743 struct dlm_comm
*cm
= NULL
;
749 mutex_lock(&clusters_root
.subsys
.su_mutex
);
751 list_for_each_entry(i
, &comm_list
->cg_children
, ci_entry
) {
752 cm
= config_item_to_comm(i
);
754 if (cm
->nodeid
!= nodeid
)
760 mutex_unlock(&clusters_root
.subsys
.su_mutex
);
767 static void put_comm(struct dlm_comm
*cm
)
769 config_item_put(&cm
->item
);
772 /* caller must free mem */
773 int dlm_config_nodes(char *lsname
, struct dlm_config_node
**nodes_out
,
776 struct dlm_space
*sp
;
778 struct dlm_config_node
*nodes
, *node
;
781 sp
= get_space(lsname
);
785 mutex_lock(&sp
->members_lock
);
786 if (!sp
->members_count
) {
788 printk(KERN_ERR
"dlm: zero members_count\n");
792 count
= sp
->members_count
;
794 nodes
= kcalloc(count
, sizeof(struct dlm_config_node
), GFP_NOFS
);
801 list_for_each_entry(nd
, &sp
->members
, list
) {
802 node
->nodeid
= nd
->nodeid
;
803 node
->weight
= nd
->weight
;
805 node
->comm_seq
= nd
->comm_seq
;
815 mutex_unlock(&sp
->members_lock
);
820 int dlm_comm_seq(int nodeid
, uint32_t *seq
)
822 struct dlm_comm
*cm
= get_comm(nodeid
);
830 int dlm_our_nodeid(void)
832 return local_comm
? local_comm
->nodeid
: 0;
835 /* num 0 is first addr, num 1 is second addr */
836 int dlm_our_addr(struct sockaddr_storage
*addr
, int num
)
840 if (num
+ 1 > local_comm
->addr_count
)
842 memcpy(addr
, local_comm
->addr
[num
], sizeof(*addr
));
846 /* Config file defaults */
847 #define DEFAULT_TCP_PORT 21064
848 #define DEFAULT_BUFFER_SIZE 4096
849 #define DEFAULT_RSBTBL_SIZE 1024
850 #define DEFAULT_RECOVER_TIMER 5
851 #define DEFAULT_TOSS_SECS 10
852 #define DEFAULT_SCAN_SECS 5
853 #define DEFAULT_LOG_DEBUG 0
854 #define DEFAULT_PROTOCOL 0
855 #define DEFAULT_TIMEWARN_CS 500 /* 5 sec = 500 centiseconds */
856 #define DEFAULT_WAITWARN_US 0
857 #define DEFAULT_NEW_RSB_COUNT 128
858 #define DEFAULT_RECOVER_CALLBACKS 0
859 #define DEFAULT_CLUSTER_NAME ""
861 struct dlm_config_info dlm_config
= {
862 .ci_tcp_port
= DEFAULT_TCP_PORT
,
863 .ci_buffer_size
= DEFAULT_BUFFER_SIZE
,
864 .ci_rsbtbl_size
= DEFAULT_RSBTBL_SIZE
,
865 .ci_recover_timer
= DEFAULT_RECOVER_TIMER
,
866 .ci_toss_secs
= DEFAULT_TOSS_SECS
,
867 .ci_scan_secs
= DEFAULT_SCAN_SECS
,
868 .ci_log_debug
= DEFAULT_LOG_DEBUG
,
869 .ci_protocol
= DEFAULT_PROTOCOL
,
870 .ci_timewarn_cs
= DEFAULT_TIMEWARN_CS
,
871 .ci_waitwarn_us
= DEFAULT_WAITWARN_US
,
872 .ci_new_rsb_count
= DEFAULT_NEW_RSB_COUNT
,
873 .ci_recover_callbacks
= DEFAULT_RECOVER_CALLBACKS
,
874 .ci_cluster_name
= DEFAULT_CLUSTER_NAME