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