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