Commit | Line | Data |
---|---|---|
e7fd4179 DT |
1 | /****************************************************************************** |
2 | ******************************************************************************* | |
3 | ** | |
4 | ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | |
60f98d18 | 5 | ** Copyright (C) 2004-2011 Red Hat, Inc. All rights reserved. |
e7fd4179 DT |
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> | |
5a0e3ad6 | 17 | #include <linux/slab.h> |
44be6fdf DT |
18 | #include <linux/in.h> |
19 | #include <linux/in6.h> | |
60f98d18 | 20 | #include <linux/dlmconstants.h> |
44be6fdf | 21 | #include <net/ipv6.h> |
e7fd4179 DT |
22 | #include <net/sock.h> |
23 | ||
24 | #include "config.h" | |
1c032c03 | 25 | #include "lowcomms.h" |
e7fd4179 DT |
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 | |
55b3286d MY |
32 | * /config/dlm/<cluster>/comms/<comm>/addr (write only) |
33 | * /config/dlm/<cluster>/comms/<comm>/addr_list (read only) | |
e7fd4179 DT |
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; | |
51409340 | 39 | static struct dlm_comm *local_comm; |
60f98d18 | 40 | static uint32_t dlm_comm_count; |
e7fd4179 | 41 | |
51409340 DT |
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; | |
e7fd4179 | 50 | |
f89ab861 | 51 | static struct config_group *make_cluster(struct config_group *, const char *); |
e7fd4179 DT |
52 | static void drop_cluster(struct config_group *, struct config_item *); |
53 | static void release_cluster(struct config_item *); | |
f89ab861 | 54 | static struct config_group *make_space(struct config_group *, const char *); |
e7fd4179 DT |
55 | static void drop_space(struct config_group *, struct config_item *); |
56 | static void release_space(struct config_item *); | |
f89ab861 | 57 | static struct config_item *make_comm(struct config_group *, const char *); |
e7fd4179 DT |
58 | static void drop_comm(struct config_group *, struct config_item *); |
59 | static void release_comm(struct config_item *); | |
f89ab861 | 60 | static struct config_item *make_node(struct config_group *, const char *); |
e7fd4179 DT |
61 | static void drop_node(struct config_group *, struct config_item *); |
62 | static void release_node(struct config_item *); | |
63 | ||
d200778e DT |
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); | |
e7fd4179 DT |
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 | ||
51409340 DT |
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); | |
55b3286d | 86 | static ssize_t comm_addr_list_read(struct dlm_comm *cm, char *buf); |
51409340 DT |
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 { | |
d200778e DT |
95 | struct config_group group; |
96 | unsigned int cl_tcp_port; | |
97 | unsigned int cl_buffer_size; | |
98 | unsigned int cl_rsbtbl_size; | |
d200778e DT |
99 | unsigned int cl_recover_timer; |
100 | unsigned int cl_toss_secs; | |
101 | unsigned int cl_scan_secs; | |
102 | unsigned int cl_log_debug; | |
6ed7257b | 103 | unsigned int cl_protocol; |
3ae1acf9 | 104 | unsigned int cl_timewarn_cs; |
c6ff669b | 105 | unsigned int cl_waitwarn_us; |
3881ac04 | 106 | unsigned int cl_new_rsb_count; |
60f98d18 DT |
107 | unsigned int cl_recover_callbacks; |
108 | char cl_cluster_name[DLM_LOCKSPACE_LEN]; | |
d200778e DT |
109 | }; |
110 | ||
111 | enum { | |
112 | CLUSTER_ATTR_TCP_PORT = 0, | |
113 | CLUSTER_ATTR_BUFFER_SIZE, | |
114 | CLUSTER_ATTR_RSBTBL_SIZE, | |
d200778e DT |
115 | CLUSTER_ATTR_RECOVER_TIMER, |
116 | CLUSTER_ATTR_TOSS_SECS, | |
117 | CLUSTER_ATTR_SCAN_SECS, | |
118 | CLUSTER_ATTR_LOG_DEBUG, | |
6ed7257b | 119 | CLUSTER_ATTR_PROTOCOL, |
3ae1acf9 | 120 | CLUSTER_ATTR_TIMEWARN_CS, |
c6ff669b | 121 | CLUSTER_ATTR_WAITWARN_US, |
3881ac04 | 122 | CLUSTER_ATTR_NEW_RSB_COUNT, |
60f98d18 DT |
123 | CLUSTER_ATTR_RECOVER_CALLBACKS, |
124 | CLUSTER_ATTR_CLUSTER_NAME, | |
d200778e DT |
125 | }; |
126 | ||
127 | struct cluster_attribute { | |
128 | struct configfs_attribute attr; | |
51409340 DT |
129 | ssize_t (*show)(struct dlm_cluster *, char *); |
130 | ssize_t (*store)(struct dlm_cluster *, const char *, size_t); | |
d200778e DT |
131 | }; |
132 | ||
60f98d18 DT |
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); | |
142 | strncpy(cl->cl_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 | ||
51409340 | 154 | static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field, |
5416b704 | 155 | int *info_field, int check_zero, |
d200778e DT |
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 | ||
d200778e | 174 | #define CLUSTER_ATTR(name, check_zero) \ |
51409340 | 175 | static ssize_t name##_write(struct dlm_cluster *cl, const char *buf, size_t len) \ |
d200778e DT |
176 | { \ |
177 | return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \ | |
178 | check_zero, buf, len); \ | |
179 | } \ | |
51409340 | 180 | static ssize_t name##_read(struct dlm_cluster *cl, char *buf) \ |
d200778e DT |
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); | |
d200778e DT |
190 | CLUSTER_ATTR(recover_timer, 1); |
191 | CLUSTER_ATTR(toss_secs, 1); | |
192 | CLUSTER_ATTR(scan_secs, 1); | |
193 | CLUSTER_ATTR(log_debug, 0); | |
6ed7257b | 194 | CLUSTER_ATTR(protocol, 0); |
3ae1acf9 | 195 | CLUSTER_ATTR(timewarn_cs, 1); |
c6ff669b | 196 | CLUSTER_ATTR(waitwarn_us, 0); |
3881ac04 | 197 | CLUSTER_ATTR(new_rsb_count, 0); |
60f98d18 | 198 | CLUSTER_ATTR(recover_callbacks, 0); |
d200778e DT |
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, | |
d200778e DT |
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, | |
6ed7257b | 208 | [CLUSTER_ATTR_PROTOCOL] = &cluster_attr_protocol.attr, |
3ae1acf9 | 209 | [CLUSTER_ATTR_TIMEWARN_CS] = &cluster_attr_timewarn_cs.attr, |
c6ff669b | 210 | [CLUSTER_ATTR_WAITWARN_US] = &cluster_attr_waitwarn_us.attr, |
3881ac04 | 211 | [CLUSTER_ATTR_NEW_RSB_COUNT] = &cluster_attr_new_rsb_count.attr, |
60f98d18 DT |
212 | [CLUSTER_ATTR_RECOVER_CALLBACKS] = &cluster_attr_recover_callbacks.attr, |
213 | [CLUSTER_ATTR_CLUSTER_NAME] = &cluster_attr_cluster_name.attr, | |
d200778e DT |
214 | NULL, |
215 | }; | |
216 | ||
e7fd4179 DT |
217 | enum { |
218 | COMM_ATTR_NODEID = 0, | |
219 | COMM_ATTR_LOCAL, | |
220 | COMM_ATTR_ADDR, | |
55b3286d | 221 | COMM_ATTR_ADDR_LIST, |
e7fd4179 DT |
222 | }; |
223 | ||
224 | struct comm_attribute { | |
225 | struct configfs_attribute attr; | |
51409340 DT |
226 | ssize_t (*show)(struct dlm_comm *, char *); |
227 | ssize_t (*store)(struct dlm_comm *, const char *, size_t); | |
e7fd4179 DT |
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", | |
55b3286d | 249 | .ca_mode = S_IWUSR }, |
e7fd4179 DT |
250 | .store = comm_addr_write, |
251 | }; | |
252 | ||
55b3286d MY |
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 | ||
e7fd4179 DT |
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, | |
55b3286d | 264 | [COMM_ATTR_ADDR_LIST] = &comm_attr_addr_list.attr, |
e7fd4179 DT |
265 | NULL, |
266 | }; | |
267 | ||
268 | enum { | |
269 | NODE_ATTR_NODEID = 0, | |
270 | NODE_ATTR_WEIGHT, | |
271 | }; | |
272 | ||
273 | struct node_attribute { | |
274 | struct configfs_attribute attr; | |
51409340 DT |
275 | ssize_t (*show)(struct dlm_node *, char *); |
276 | ssize_t (*store)(struct dlm_node *, const char *, size_t); | |
e7fd4179 DT |
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 | ||
51409340 | 301 | struct dlm_clusters { |
e7fd4179 DT |
302 | struct configfs_subsystem subsys; |
303 | }; | |
304 | ||
51409340 | 305 | struct dlm_spaces { |
e7fd4179 DT |
306 | struct config_group ss_group; |
307 | }; | |
308 | ||
51409340 | 309 | struct dlm_space { |
e7fd4179 DT |
310 | struct config_group group; |
311 | struct list_head members; | |
90135925 | 312 | struct mutex members_lock; |
e7fd4179 DT |
313 | int members_count; |
314 | }; | |
315 | ||
51409340 | 316 | struct dlm_comms { |
e7fd4179 DT |
317 | struct config_group cs_group; |
318 | }; | |
319 | ||
51409340 | 320 | struct dlm_comm { |
e7fd4179 | 321 | struct config_item item; |
60f98d18 | 322 | int seq; |
e7fd4179 DT |
323 | int nodeid; |
324 | int local; | |
325 | int addr_count; | |
326 | struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; | |
327 | }; | |
328 | ||
51409340 | 329 | struct dlm_nodes { |
e7fd4179 DT |
330 | struct config_group ns_group; |
331 | }; | |
332 | ||
51409340 | 333 | struct dlm_node { |
e7fd4179 DT |
334 | struct config_item item; |
335 | struct list_head list; /* space->members */ | |
336 | int nodeid; | |
337 | int weight; | |
d44e0fc7 | 338 | int new; |
60f98d18 | 339 | int comm_seq; /* copy of cm->seq when nd->nodeid is set */ |
e7fd4179 DT |
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, | |
d200778e DT |
349 | .show_attribute = show_cluster, |
350 | .store_attribute = store_cluster, | |
e7fd4179 DT |
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, | |
d200778e | 391 | .ct_attrs = cluster_attrs, |
e7fd4179 DT |
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 | ||
27eccf46 | 427 | static struct dlm_cluster *config_item_to_cluster(struct config_item *i) |
e7fd4179 | 428 | { |
51409340 DT |
429 | return i ? container_of(to_config_group(i), struct dlm_cluster, group) : |
430 | NULL; | |
e7fd4179 DT |
431 | } |
432 | ||
27eccf46 | 433 | static struct dlm_space *config_item_to_space(struct config_item *i) |
e7fd4179 | 434 | { |
51409340 DT |
435 | return i ? container_of(to_config_group(i), struct dlm_space, group) : |
436 | NULL; | |
e7fd4179 DT |
437 | } |
438 | ||
27eccf46 | 439 | static struct dlm_comm *config_item_to_comm(struct config_item *i) |
e7fd4179 | 440 | { |
51409340 | 441 | return i ? container_of(i, struct dlm_comm, item) : NULL; |
e7fd4179 DT |
442 | } |
443 | ||
27eccf46 | 444 | static struct dlm_node *config_item_to_node(struct config_item *i) |
e7fd4179 | 445 | { |
51409340 | 446 | return i ? container_of(i, struct dlm_node, item) : NULL; |
e7fd4179 DT |
447 | } |
448 | ||
f89ab861 JB |
449 | static struct config_group *make_cluster(struct config_group *g, |
450 | const char *name) | |
e7fd4179 | 451 | { |
51409340 DT |
452 | struct dlm_cluster *cl = NULL; |
453 | struct dlm_spaces *sps = NULL; | |
454 | struct dlm_comms *cms = NULL; | |
e7fd4179 DT |
455 | void *gps = NULL; |
456 | ||
573c24c4 DT |
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); | |
e7fd4179 DT |
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 | ||
d200778e DT |
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; | |
d200778e DT |
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; | |
0b7cac0f | 481 | cl->cl_protocol = dlm_config.ci_protocol; |
84d8cd69 | 482 | cl->cl_timewarn_cs = dlm_config.ci_timewarn_cs; |
c6ff669b | 483 | cl->cl_waitwarn_us = dlm_config.ci_waitwarn_us; |
3881ac04 | 484 | cl->cl_new_rsb_count = dlm_config.ci_new_rsb_count; |
60f98d18 DT |
485 | cl->cl_recover_callbacks = dlm_config.ci_recover_callbacks; |
486 | memcpy(cl->cl_cluster_name, dlm_config.ci_cluster_name, | |
487 | DLM_LOCKSPACE_LEN); | |
d200778e | 488 | |
e7fd4179 DT |
489 | space_list = &sps->ss_group; |
490 | comm_list = &cms->cs_group; | |
f89ab861 | 491 | return &cl->group; |
e7fd4179 DT |
492 | |
493 | fail: | |
494 | kfree(cl); | |
495 | kfree(gps); | |
496 | kfree(sps); | |
497 | kfree(cms); | |
a6795e9e | 498 | return ERR_PTR(-ENOMEM); |
e7fd4179 DT |
499 | } |
500 | ||
501 | static void drop_cluster(struct config_group *g, struct config_item *i) | |
502 | { | |
27eccf46 | 503 | struct dlm_cluster *cl = config_item_to_cluster(i); |
e7fd4179 DT |
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 | { | |
27eccf46 | 521 | struct dlm_cluster *cl = config_item_to_cluster(i); |
e7fd4179 DT |
522 | kfree(cl->group.default_groups); |
523 | kfree(cl); | |
524 | } | |
525 | ||
f89ab861 | 526 | static struct config_group *make_space(struct config_group *g, const char *name) |
e7fd4179 | 527 | { |
51409340 DT |
528 | struct dlm_space *sp = NULL; |
529 | struct dlm_nodes *nds = NULL; | |
e7fd4179 DT |
530 | void *gps = NULL; |
531 | ||
573c24c4 DT |
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); | |
e7fd4179 DT |
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); | |
90135925 | 547 | mutex_init(&sp->members_lock); |
e7fd4179 | 548 | sp->members_count = 0; |
f89ab861 | 549 | return &sp->group; |
e7fd4179 DT |
550 | |
551 | fail: | |
552 | kfree(sp); | |
553 | kfree(gps); | |
554 | kfree(nds); | |
a6795e9e | 555 | return ERR_PTR(-ENOMEM); |
e7fd4179 DT |
556 | } |
557 | ||
558 | static void drop_space(struct config_group *g, struct config_item *i) | |
559 | { | |
27eccf46 | 560 | struct dlm_space *sp = config_item_to_space(i); |
e7fd4179 DT |
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 | { | |
27eccf46 | 577 | struct dlm_space *sp = config_item_to_space(i); |
e7fd4179 DT |
578 | kfree(sp->group.default_groups); |
579 | kfree(sp); | |
580 | } | |
581 | ||
f89ab861 | 582 | static struct config_item *make_comm(struct config_group *g, const char *name) |
e7fd4179 | 583 | { |
51409340 | 584 | struct dlm_comm *cm; |
e7fd4179 | 585 | |
573c24c4 | 586 | cm = kzalloc(sizeof(struct dlm_comm), GFP_NOFS); |
e7fd4179 | 587 | if (!cm) |
a6795e9e | 588 | return ERR_PTR(-ENOMEM); |
e7fd4179 DT |
589 | |
590 | config_item_init_type_name(&cm->item, name, &comm_type); | |
60f98d18 DT |
591 | |
592 | cm->seq = dlm_comm_count++; | |
593 | if (!cm->seq) | |
594 | cm->seq = dlm_comm_count++; | |
595 | ||
e7fd4179 DT |
596 | cm->nodeid = -1; |
597 | cm->local = 0; | |
598 | cm->addr_count = 0; | |
f89ab861 | 599 | return &cm->item; |
e7fd4179 DT |
600 | } |
601 | ||
602 | static void drop_comm(struct config_group *g, struct config_item *i) | |
603 | { | |
27eccf46 | 604 | struct dlm_comm *cm = config_item_to_comm(i); |
e7fd4179 DT |
605 | if (local_comm == cm) |
606 | local_comm = NULL; | |
1c032c03 | 607 | dlm_lowcomms_close(cm->nodeid); |
e7fd4179 DT |
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 | { | |
27eccf46 | 615 | struct dlm_comm *cm = config_item_to_comm(i); |
e7fd4179 DT |
616 | kfree(cm); |
617 | } | |
618 | ||
f89ab861 | 619 | static struct config_item *make_node(struct config_group *g, const char *name) |
e7fd4179 | 620 | { |
27eccf46 | 621 | struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent); |
51409340 | 622 | struct dlm_node *nd; |
e7fd4179 | 623 | |
573c24c4 | 624 | nd = kzalloc(sizeof(struct dlm_node), GFP_NOFS); |
e7fd4179 | 625 | if (!nd) |
a6795e9e | 626 | return ERR_PTR(-ENOMEM); |
e7fd4179 DT |
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 */ | |
d44e0fc7 | 631 | nd->new = 1; /* set to 0 once it's been read by dlm_nodeid_list() */ |
e7fd4179 | 632 | |
90135925 | 633 | mutex_lock(&sp->members_lock); |
e7fd4179 DT |
634 | list_add(&nd->list, &sp->members); |
635 | sp->members_count++; | |
90135925 | 636 | mutex_unlock(&sp->members_lock); |
e7fd4179 | 637 | |
f89ab861 | 638 | return &nd->item; |
e7fd4179 DT |
639 | } |
640 | ||
641 | static void drop_node(struct config_group *g, struct config_item *i) | |
642 | { | |
27eccf46 AM |
643 | struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent); |
644 | struct dlm_node *nd = config_item_to_node(i); | |
e7fd4179 | 645 | |
90135925 | 646 | mutex_lock(&sp->members_lock); |
e7fd4179 DT |
647 | list_del(&nd->list); |
648 | sp->members_count--; | |
90135925 | 649 | mutex_unlock(&sp->members_lock); |
e7fd4179 DT |
650 | |
651 | config_item_put(i); | |
652 | } | |
653 | ||
654 | static void release_node(struct config_item *i) | |
655 | { | |
27eccf46 | 656 | struct dlm_node *nd = config_item_to_node(i); |
e7fd4179 DT |
657 | kfree(nd); |
658 | } | |
659 | ||
51409340 | 660 | static struct dlm_clusters clusters_root = { |
e7fd4179 DT |
661 | .subsys = { |
662 | .su_group = { | |
663 | .cg_item = { | |
664 | .ci_namebuf = "dlm", | |
665 | .ci_type = &clusters_type, | |
666 | }, | |
667 | }, | |
668 | }, | |
669 | }; | |
670 | ||
30727174 | 671 | int __init dlm_config_init(void) |
e7fd4179 DT |
672 | { |
673 | config_group_init(&clusters_root.subsys.su_group); | |
e6bd07ae | 674 | mutex_init(&clusters_root.subsys.su_mutex); |
e7fd4179 DT |
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 | ||
d200778e DT |
687 | static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a, |
688 | char *buf) | |
689 | { | |
27eccf46 | 690 | struct dlm_cluster *cl = config_item_to_cluster(i); |
d200778e DT |
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 | { | |
27eccf46 | 700 | struct dlm_cluster *cl = config_item_to_cluster(i); |
d200778e DT |
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 | ||
e7fd4179 DT |
706 | static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a, |
707 | char *buf) | |
708 | { | |
27eccf46 | 709 | struct dlm_comm *cm = config_item_to_comm(i); |
e7fd4179 DT |
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 | { | |
27eccf46 | 718 | struct dlm_comm *cm = config_item_to_comm(i); |
e7fd4179 DT |
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 | ||
51409340 | 724 | static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf) |
e7fd4179 DT |
725 | { |
726 | return sprintf(buf, "%d\n", cm->nodeid); | |
727 | } | |
728 | ||
51409340 DT |
729 | static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf, |
730 | size_t len) | |
e7fd4179 DT |
731 | { |
732 | cm->nodeid = simple_strtol(buf, NULL, 0); | |
733 | return len; | |
734 | } | |
735 | ||
51409340 | 736 | static ssize_t comm_local_read(struct dlm_comm *cm, char *buf) |
e7fd4179 DT |
737 | { |
738 | return sprintf(buf, "%d\n", cm->local); | |
739 | } | |
740 | ||
51409340 DT |
741 | static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf, |
742 | size_t len) | |
e7fd4179 DT |
743 | { |
744 | cm->local= simple_strtol(buf, NULL, 0); | |
745 | if (cm->local && !local_comm) | |
746 | local_comm = cm; | |
747 | return len; | |
748 | } | |
749 | ||
51409340 | 750 | static ssize_t comm_addr_write(struct dlm_comm *cm, const char *buf, size_t len) |
e7fd4179 DT |
751 | { |
752 | struct sockaddr_storage *addr; | |
36b71a8b | 753 | int rv; |
e7fd4179 DT |
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 | ||
573c24c4 | 761 | addr = kzalloc(sizeof(*addr), GFP_NOFS); |
e7fd4179 DT |
762 | if (!addr) |
763 | return -ENOMEM; | |
764 | ||
765 | memcpy(addr, buf, len); | |
36b71a8b DT |
766 | |
767 | rv = dlm_lowcomms_addr(cm->nodeid, addr, len); | |
768 | if (rv) { | |
769 | kfree(addr); | |
770 | return rv; | |
771 | } | |
772 | ||
e7fd4179 DT |
773 | cm->addr[cm->addr_count++] = addr; |
774 | return len; | |
775 | } | |
776 | ||
55b3286d MY |
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 | ||
e7fd4179 DT |
821 | static ssize_t show_node(struct config_item *i, struct configfs_attribute *a, |
822 | char *buf) | |
823 | { | |
27eccf46 | 824 | struct dlm_node *nd = config_item_to_node(i); |
e7fd4179 DT |
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 | { | |
27eccf46 | 833 | struct dlm_node *nd = config_item_to_node(i); |
e7fd4179 DT |
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 | ||
51409340 | 839 | static ssize_t node_nodeid_read(struct dlm_node *nd, char *buf) |
e7fd4179 DT |
840 | { |
841 | return sprintf(buf, "%d\n", nd->nodeid); | |
842 | } | |
843 | ||
51409340 DT |
844 | static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf, |
845 | size_t len) | |
e7fd4179 | 846 | { |
60f98d18 | 847 | uint32_t seq = 0; |
e7fd4179 | 848 | nd->nodeid = simple_strtol(buf, NULL, 0); |
60f98d18 DT |
849 | dlm_comm_seq(nd->nodeid, &seq); |
850 | nd->comm_seq = seq; | |
e7fd4179 DT |
851 | return len; |
852 | } | |
853 | ||
51409340 | 854 | static ssize_t node_weight_read(struct dlm_node *nd, char *buf) |
e7fd4179 DT |
855 | { |
856 | return sprintf(buf, "%d\n", nd->weight); | |
857 | } | |
858 | ||
51409340 DT |
859 | static ssize_t node_weight_write(struct dlm_node *nd, const char *buf, |
860 | size_t len) | |
e7fd4179 DT |
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 | ||
51409340 | 870 | static struct dlm_space *get_space(char *name) |
e7fd4179 | 871 | { |
3168b078 SS |
872 | struct config_item *i; |
873 | ||
e7fd4179 DT |
874 | if (!space_list) |
875 | return NULL; | |
3168b078 | 876 | |
e6bd07ae | 877 | mutex_lock(&space_list->cg_subsys->su_mutex); |
3fe6c5ce | 878 | i = config_group_find_item(space_list, name); |
e6bd07ae | 879 | mutex_unlock(&space_list->cg_subsys->su_mutex); |
3168b078 | 880 | |
27eccf46 | 881 | return config_item_to_space(i); |
e7fd4179 DT |
882 | } |
883 | ||
51409340 | 884 | static void put_space(struct dlm_space *sp) |
e7fd4179 DT |
885 | { |
886 | config_item_put(&sp->group.cg_item); | |
887 | } | |
888 | ||
36b71a8b | 889 | static struct dlm_comm *get_comm(int nodeid) |
e7fd4179 DT |
890 | { |
891 | struct config_item *i; | |
51409340 | 892 | struct dlm_comm *cm = NULL; |
e7fd4179 DT |
893 | int found = 0; |
894 | ||
895 | if (!comm_list) | |
896 | return NULL; | |
897 | ||
e6bd07ae | 898 | mutex_lock(&clusters_root.subsys.su_mutex); |
e7fd4179 DT |
899 | |
900 | list_for_each_entry(i, &comm_list->cg_children, ci_entry) { | |
27eccf46 | 901 | cm = config_item_to_comm(i); |
e7fd4179 | 902 | |
36b71a8b DT |
903 | if (cm->nodeid != nodeid) |
904 | continue; | |
905 | found = 1; | |
906 | config_item_get(i); | |
907 | break; | |
e7fd4179 | 908 | } |
e6bd07ae | 909 | mutex_unlock(&clusters_root.subsys.su_mutex); |
e7fd4179 | 910 | |
3168b078 | 911 | if (!found) |
e7fd4179 DT |
912 | cm = NULL; |
913 | return cm; | |
914 | } | |
915 | ||
51409340 | 916 | static void put_comm(struct dlm_comm *cm) |
e7fd4179 DT |
917 | { |
918 | config_item_put(&cm->item); | |
919 | } | |
920 | ||
921 | /* caller must free mem */ | |
60f98d18 DT |
922 | int dlm_config_nodes(char *lsname, struct dlm_config_node **nodes_out, |
923 | int *count_out) | |
e7fd4179 | 924 | { |
51409340 DT |
925 | struct dlm_space *sp; |
926 | struct dlm_node *nd; | |
60f98d18 DT |
927 | struct dlm_config_node *nodes, *node; |
928 | int rv, count; | |
e7fd4179 DT |
929 | |
930 | sp = get_space(lsname); | |
931 | if (!sp) | |
932 | return -EEXIST; | |
933 | ||
90135925 | 934 | mutex_lock(&sp->members_lock); |
e7fd4179 | 935 | if (!sp->members_count) { |
d44e0fc7 DT |
936 | rv = -EINVAL; |
937 | printk(KERN_ERR "dlm: zero members_count\n"); | |
e7fd4179 DT |
938 | goto out; |
939 | } | |
940 | ||
60f98d18 | 941 | count = sp->members_count; |
d44e0fc7 | 942 | |
60f98d18 DT |
943 | nodes = kcalloc(count, sizeof(struct dlm_config_node), GFP_NOFS); |
944 | if (!nodes) { | |
e7fd4179 DT |
945 | rv = -ENOMEM; |
946 | goto out; | |
947 | } | |
948 | ||
60f98d18 | 949 | node = nodes; |
d44e0fc7 | 950 | list_for_each_entry(nd, &sp->members, list) { |
60f98d18 DT |
951 | node->nodeid = nd->nodeid; |
952 | node->weight = nd->weight; | |
953 | node->new = nd->new; | |
954 | node->comm_seq = nd->comm_seq; | |
955 | node++; | |
d44e0fc7 | 956 | |
60f98d18 | 957 | nd->new = 0; |
d44e0fc7 | 958 | } |
e7fd4179 | 959 | |
60f98d18 DT |
960 | *count_out = count; |
961 | *nodes_out = nodes; | |
962 | rv = 0; | |
e7fd4179 | 963 | out: |
90135925 | 964 | mutex_unlock(&sp->members_lock); |
e7fd4179 DT |
965 | put_space(sp); |
966 | return rv; | |
967 | } | |
968 | ||
60f98d18 | 969 | int dlm_comm_seq(int nodeid, uint32_t *seq) |
e7fd4179 | 970 | { |
36b71a8b | 971 | struct dlm_comm *cm = get_comm(nodeid); |
60f98d18 DT |
972 | if (!cm) |
973 | return -EEXIST; | |
974 | *seq = cm->seq; | |
975 | put_comm(cm); | |
976 | return 0; | |
e7fd4179 DT |
977 | } |
978 | ||
e7fd4179 DT |
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 | |
e3853a90 | 998 | #define DEFAULT_RSBTBL_SIZE 1024 |
e7fd4179 DT |
999 | #define DEFAULT_RECOVER_TIMER 5 |
1000 | #define DEFAULT_TOSS_SECS 10 | |
1001 | #define DEFAULT_SCAN_SECS 5 | |
99fc6487 | 1002 | #define DEFAULT_LOG_DEBUG 0 |
6ed7257b | 1003 | #define DEFAULT_PROTOCOL 0 |
3ae1acf9 | 1004 | #define DEFAULT_TIMEWARN_CS 500 /* 5 sec = 500 centiseconds */ |
c6ff669b | 1005 | #define DEFAULT_WAITWARN_US 0 |
3881ac04 | 1006 | #define DEFAULT_NEW_RSB_COUNT 128 |
60f98d18 DT |
1007 | #define DEFAULT_RECOVER_CALLBACKS 0 |
1008 | #define DEFAULT_CLUSTER_NAME "" | |
e7fd4179 DT |
1009 | |
1010 | struct dlm_config_info dlm_config = { | |
68c817a1 DT |
1011 | .ci_tcp_port = DEFAULT_TCP_PORT, |
1012 | .ci_buffer_size = DEFAULT_BUFFER_SIZE, | |
1013 | .ci_rsbtbl_size = DEFAULT_RSBTBL_SIZE, | |
68c817a1 DT |
1014 | .ci_recover_timer = DEFAULT_RECOVER_TIMER, |
1015 | .ci_toss_secs = DEFAULT_TOSS_SECS, | |
99fc6487 | 1016 | .ci_scan_secs = DEFAULT_SCAN_SECS, |
6ed7257b | 1017 | .ci_log_debug = DEFAULT_LOG_DEBUG, |
3ae1acf9 | 1018 | .ci_protocol = DEFAULT_PROTOCOL, |
c6ff669b | 1019 | .ci_timewarn_cs = DEFAULT_TIMEWARN_CS, |
3881ac04 | 1020 | .ci_waitwarn_us = DEFAULT_WAITWARN_US, |
60f98d18 DT |
1021 | .ci_new_rsb_count = DEFAULT_NEW_RSB_COUNT, |
1022 | .ci_recover_callbacks = DEFAULT_RECOVER_CALLBACKS, | |
1023 | .ci_cluster_name = DEFAULT_CLUSTER_NAME | |
e7fd4179 DT |
1024 | }; |
1025 |