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 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)); 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 155 static ssize_t cluster_set(struct dlm_cluster *cl, unsigned int *cl_field, 156 int *info_field, int check_zero, 157 const char *buf, size_t len) 158 { 159 unsigned int x; 160 int rc; 161 162 if (!capable(CAP_SYS_ADMIN)) 163 return -EPERM; 164 rc = kstrtouint(buf, 0, &x); 165 if (rc) 166 return rc; 167 168 if (check_zero && !x) 169 return -EINVAL; 170 171 *cl_field = x; 172 *info_field = x; 173 174 return len; 175 } 176 177 #define CLUSTER_ATTR(name, check_zero) \ 178 static ssize_t name##_write(struct dlm_cluster *cl, const char *buf, size_t len) \ 179 { \ 180 return cluster_set(cl, &cl->cl_##name, &dlm_config.ci_##name, \ 181 check_zero, buf, len); \ 182 } \ 183 static ssize_t name##_read(struct dlm_cluster *cl, char *buf) \ 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); 193 CLUSTER_ATTR(recover_timer, 1); 194 CLUSTER_ATTR(toss_secs, 1); 195 CLUSTER_ATTR(scan_secs, 1); 196 CLUSTER_ATTR(log_debug, 0); 197 CLUSTER_ATTR(protocol, 0); 198 CLUSTER_ATTR(timewarn_cs, 1); 199 CLUSTER_ATTR(waitwarn_us, 0); 200 CLUSTER_ATTR(new_rsb_count, 0); 201 CLUSTER_ATTR(recover_callbacks, 0); 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, 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, 211 [CLUSTER_ATTR_PROTOCOL] = &cluster_attr_protocol.attr, 212 [CLUSTER_ATTR_TIMEWARN_CS] = &cluster_attr_timewarn_cs.attr, 213 [CLUSTER_ATTR_WAITWARN_US] = &cluster_attr_waitwarn_us.attr, 214 [CLUSTER_ATTR_NEW_RSB_COUNT] = &cluster_attr_new_rsb_count.attr, 215 [CLUSTER_ATTR_RECOVER_CALLBACKS] = &cluster_attr_recover_callbacks.attr, 216 [CLUSTER_ATTR_CLUSTER_NAME] = &cluster_attr_cluster_name.attr, 217 NULL, 218 }; 219 220 enum { 221 COMM_ATTR_NODEID = 0, 222 COMM_ATTR_LOCAL, 223 COMM_ATTR_ADDR, 224 COMM_ATTR_ADDR_LIST, 225 }; 226 227 struct comm_attribute { 228 struct configfs_attribute attr; 229 ssize_t (*show)(struct dlm_comm *, char *); 230 ssize_t (*store)(struct dlm_comm *, const char *, size_t); 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", 252 .ca_mode = S_IWUSR }, 253 .store = comm_addr_write, 254 }; 255 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 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, 267 [COMM_ATTR_ADDR_LIST] = &comm_attr_addr_list.attr, 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; 278 ssize_t (*show)(struct dlm_node *, char *); 279 ssize_t (*store)(struct dlm_node *, const char *, size_t); 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 304 struct dlm_clusters { 305 struct configfs_subsystem subsys; 306 }; 307 308 struct dlm_spaces { 309 struct config_group ss_group; 310 }; 311 312 struct dlm_space { 313 struct config_group group; 314 struct list_head members; 315 struct mutex members_lock; 316 int members_count; 317 }; 318 319 struct dlm_comms { 320 struct config_group cs_group; 321 }; 322 323 struct dlm_comm { 324 struct config_item item; 325 int seq; 326 int nodeid; 327 int local; 328 int addr_count; 329 struct sockaddr_storage *addr[DLM_MAX_ADDR_COUNT]; 330 }; 331 332 struct dlm_nodes { 333 struct config_group ns_group; 334 }; 335 336 struct dlm_node { 337 struct config_item item; 338 struct list_head list; /* space->members */ 339 int nodeid; 340 int weight; 341 int new; 342 int comm_seq; /* copy of cm->seq when nd->nodeid is set */ 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, 352 .show_attribute = show_cluster, 353 .store_attribute = store_cluster, 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, 394 .ct_attrs = cluster_attrs, 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 430 static struct dlm_cluster *config_item_to_cluster(struct config_item *i) 431 { 432 return i ? container_of(to_config_group(i), struct dlm_cluster, group) : 433 NULL; 434 } 435 436 static struct dlm_space *config_item_to_space(struct config_item *i) 437 { 438 return i ? container_of(to_config_group(i), struct dlm_space, group) : 439 NULL; 440 } 441 442 static struct dlm_comm *config_item_to_comm(struct config_item *i) 443 { 444 return i ? container_of(i, struct dlm_comm, item) : NULL; 445 } 446 447 static struct dlm_node *config_item_to_node(struct config_item *i) 448 { 449 return i ? container_of(i, struct dlm_node, item) : NULL; 450 } 451 452 static struct config_group *make_cluster(struct config_group *g, 453 const char *name) 454 { 455 struct dlm_cluster *cl = NULL; 456 struct dlm_spaces *sps = NULL; 457 struct dlm_comms *cms = NULL; 458 void *gps = NULL; 459 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); 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 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; 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; 484 cl->cl_protocol = dlm_config.ci_protocol; 485 cl->cl_timewarn_cs = dlm_config.ci_timewarn_cs; 486 cl->cl_waitwarn_us = dlm_config.ci_waitwarn_us; 487 cl->cl_new_rsb_count = dlm_config.ci_new_rsb_count; 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); 491 492 space_list = &sps->ss_group; 493 comm_list = &cms->cs_group; 494 return &cl->group; 495 496 fail: 497 kfree(cl); 498 kfree(gps); 499 kfree(sps); 500 kfree(cms); 501 return ERR_PTR(-ENOMEM); 502 } 503 504 static void drop_cluster(struct config_group *g, struct config_item *i) 505 { 506 struct dlm_cluster *cl = config_item_to_cluster(i); 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 { 524 struct dlm_cluster *cl = config_item_to_cluster(i); 525 kfree(cl->group.default_groups); 526 kfree(cl); 527 } 528 529 static struct config_group *make_space(struct config_group *g, const char *name) 530 { 531 struct dlm_space *sp = NULL; 532 struct dlm_nodes *nds = NULL; 533 void *gps = NULL; 534 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); 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); 550 mutex_init(&sp->members_lock); 551 sp->members_count = 0; 552 return &sp->group; 553 554 fail: 555 kfree(sp); 556 kfree(gps); 557 kfree(nds); 558 return ERR_PTR(-ENOMEM); 559 } 560 561 static void drop_space(struct config_group *g, struct config_item *i) 562 { 563 struct dlm_space *sp = config_item_to_space(i); 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 { 580 struct dlm_space *sp = config_item_to_space(i); 581 kfree(sp->group.default_groups); 582 kfree(sp); 583 } 584 585 static struct config_item *make_comm(struct config_group *g, const char *name) 586 { 587 struct dlm_comm *cm; 588 589 cm = kzalloc(sizeof(struct dlm_comm), GFP_NOFS); 590 if (!cm) 591 return ERR_PTR(-ENOMEM); 592 593 config_item_init_type_name(&cm->item, name, &comm_type); 594 595 cm->seq = dlm_comm_count++; 596 if (!cm->seq) 597 cm->seq = dlm_comm_count++; 598 599 cm->nodeid = -1; 600 cm->local = 0; 601 cm->addr_count = 0; 602 return &cm->item; 603 } 604 605 static void drop_comm(struct config_group *g, struct config_item *i) 606 { 607 struct dlm_comm *cm = config_item_to_comm(i); 608 if (local_comm == cm) 609 local_comm = NULL; 610 dlm_lowcomms_close(cm->nodeid); 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 { 618 struct dlm_comm *cm = config_item_to_comm(i); 619 kfree(cm); 620 } 621 622 static struct config_item *make_node(struct config_group *g, const char *name) 623 { 624 struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent); 625 struct dlm_node *nd; 626 627 nd = kzalloc(sizeof(struct dlm_node), GFP_NOFS); 628 if (!nd) 629 return ERR_PTR(-ENOMEM); 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 */ 634 nd->new = 1; /* set to 0 once it's been read by dlm_nodeid_list() */ 635 636 mutex_lock(&sp->members_lock); 637 list_add(&nd->list, &sp->members); 638 sp->members_count++; 639 mutex_unlock(&sp->members_lock); 640 641 return &nd->item; 642 } 643 644 static void drop_node(struct config_group *g, struct config_item *i) 645 { 646 struct dlm_space *sp = config_item_to_space(g->cg_item.ci_parent); 647 struct dlm_node *nd = config_item_to_node(i); 648 649 mutex_lock(&sp->members_lock); 650 list_del(&nd->list); 651 sp->members_count--; 652 mutex_unlock(&sp->members_lock); 653 654 config_item_put(i); 655 } 656 657 static void release_node(struct config_item *i) 658 { 659 struct dlm_node *nd = config_item_to_node(i); 660 kfree(nd); 661 } 662 663 static struct dlm_clusters clusters_root = { 664 .subsys = { 665 .su_group = { 666 .cg_item = { 667 .ci_namebuf = "dlm", 668 .ci_type = &clusters_type, 669 }, 670 }, 671 }, 672 }; 673 674 int __init dlm_config_init(void) 675 { 676 config_group_init(&clusters_root.subsys.su_group); 677 mutex_init(&clusters_root.subsys.su_mutex); 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 690 static ssize_t show_cluster(struct config_item *i, struct configfs_attribute *a, 691 char *buf) 692 { 693 struct dlm_cluster *cl = config_item_to_cluster(i); 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 { 703 struct dlm_cluster *cl = config_item_to_cluster(i); 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 709 static ssize_t show_comm(struct config_item *i, struct configfs_attribute *a, 710 char *buf) 711 { 712 struct dlm_comm *cm = config_item_to_comm(i); 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 { 721 struct dlm_comm *cm = config_item_to_comm(i); 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 727 static ssize_t comm_nodeid_read(struct dlm_comm *cm, char *buf) 728 { 729 return sprintf(buf, "%d\n", cm->nodeid); 730 } 731 732 static ssize_t comm_nodeid_write(struct dlm_comm *cm, const char *buf, 733 size_t len) 734 { 735 int rc = kstrtoint(buf, 0, &cm->nodeid); 736 737 if (rc) 738 return rc; 739 return len; 740 } 741 742 static ssize_t comm_local_read(struct dlm_comm *cm, char *buf) 743 { 744 return sprintf(buf, "%d\n", cm->local); 745 } 746 747 static ssize_t comm_local_write(struct dlm_comm *cm, const char *buf, 748 size_t len) 749 { 750 int rc = kstrtoint(buf, 0, &cm->local); 751 752 if (rc) 753 return rc; 754 if (cm->local && !local_comm) 755 local_comm = cm; 756 return len; 757 } 758 759 static ssize_t comm_addr_write(struct dlm_comm *cm, const char *buf, size_t len) 760 { 761 struct sockaddr_storage *addr; 762 int rv; 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 770 addr = kzalloc(sizeof(*addr), GFP_NOFS); 771 if (!addr) 772 return -ENOMEM; 773 774 memcpy(addr, buf, len); 775 776 rv = dlm_lowcomms_addr(cm->nodeid, addr, len); 777 if (rv) { 778 kfree(addr); 779 return rv; 780 } 781 782 cm->addr[cm->addr_count++] = addr; 783 return len; 784 } 785 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 830 static ssize_t show_node(struct config_item *i, struct configfs_attribute *a, 831 char *buf) 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->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 { 842 struct dlm_node *nd = config_item_to_node(i); 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 848 static ssize_t node_nodeid_read(struct dlm_node *nd, char *buf) 849 { 850 return sprintf(buf, "%d\n", nd->nodeid); 851 } 852 853 static ssize_t node_nodeid_write(struct dlm_node *nd, const char *buf, 854 size_t len) 855 { 856 uint32_t seq = 0; 857 int rc = kstrtoint(buf, 0, &nd->nodeid); 858 859 if (rc) 860 return rc; 861 dlm_comm_seq(nd->nodeid, &seq); 862 nd->comm_seq = seq; 863 return len; 864 } 865 866 static ssize_t node_weight_read(struct dlm_node *nd, char *buf) 867 { 868 return sprintf(buf, "%d\n", nd->weight); 869 } 870 871 static ssize_t node_weight_write(struct dlm_node *nd, const char *buf, 872 size_t len) 873 { 874 int rc = kstrtoint(buf, 0, &nd->weight); 875 876 if (rc) 877 return rc; 878 return len; 879 } 880 881 /* 882 * Functions for the dlm to get the info that's been configured 883 */ 884 885 static struct dlm_space *get_space(char *name) 886 { 887 struct config_item *i; 888 889 if (!space_list) 890 return NULL; 891 892 mutex_lock(&space_list->cg_subsys->su_mutex); 893 i = config_group_find_item(space_list, name); 894 mutex_unlock(&space_list->cg_subsys->su_mutex); 895 896 return config_item_to_space(i); 897 } 898 899 static void put_space(struct dlm_space *sp) 900 { 901 config_item_put(&sp->group.cg_item); 902 } 903 904 static struct dlm_comm *get_comm(int nodeid) 905 { 906 struct config_item *i; 907 struct dlm_comm *cm = NULL; 908 int found = 0; 909 910 if (!comm_list) 911 return NULL; 912 913 mutex_lock(&clusters_root.subsys.su_mutex); 914 915 list_for_each_entry(i, &comm_list->cg_children, ci_entry) { 916 cm = config_item_to_comm(i); 917 918 if (cm->nodeid != nodeid) 919 continue; 920 found = 1; 921 config_item_get(i); 922 break; 923 } 924 mutex_unlock(&clusters_root.subsys.su_mutex); 925 926 if (!found) 927 cm = NULL; 928 return cm; 929 } 930 931 static void put_comm(struct dlm_comm *cm) 932 { 933 config_item_put(&cm->item); 934 } 935 936 /* caller must free mem */ 937 int dlm_config_nodes(char *lsname, struct dlm_config_node **nodes_out, 938 int *count_out) 939 { 940 struct dlm_space *sp; 941 struct dlm_node *nd; 942 struct dlm_config_node *nodes, *node; 943 int rv, count; 944 945 sp = get_space(lsname); 946 if (!sp) 947 return -EEXIST; 948 949 mutex_lock(&sp->members_lock); 950 if (!sp->members_count) { 951 rv = -EINVAL; 952 printk(KERN_ERR "dlm: zero members_count\n"); 953 goto out; 954 } 955 956 count = sp->members_count; 957 958 nodes = kcalloc(count, sizeof(struct dlm_config_node), GFP_NOFS); 959 if (!nodes) { 960 rv = -ENOMEM; 961 goto out; 962 } 963 964 node = nodes; 965 list_for_each_entry(nd, &sp->members, list) { 966 node->nodeid = nd->nodeid; 967 node->weight = nd->weight; 968 node->new = nd->new; 969 node->comm_seq = nd->comm_seq; 970 node++; 971 972 nd->new = 0; 973 } 974 975 *count_out = count; 976 *nodes_out = nodes; 977 rv = 0; 978 out: 979 mutex_unlock(&sp->members_lock); 980 put_space(sp); 981 return rv; 982 } 983 984 int dlm_comm_seq(int nodeid, uint32_t *seq) 985 { 986 struct dlm_comm *cm = get_comm(nodeid); 987 if (!cm) 988 return -EEXIST; 989 *seq = cm->seq; 990 put_comm(cm); 991 return 0; 992 } 993 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 1013 #define DEFAULT_RSBTBL_SIZE 1024 1014 #define DEFAULT_RECOVER_TIMER 5 1015 #define DEFAULT_TOSS_SECS 10 1016 #define DEFAULT_SCAN_SECS 5 1017 #define DEFAULT_LOG_DEBUG 0 1018 #define DEFAULT_PROTOCOL 0 1019 #define DEFAULT_TIMEWARN_CS 500 /* 5 sec = 500 centiseconds */ 1020 #define DEFAULT_WAITWARN_US 0 1021 #define DEFAULT_NEW_RSB_COUNT 128 1022 #define DEFAULT_RECOVER_CALLBACKS 0 1023 #define DEFAULT_CLUSTER_NAME "" 1024 1025 struct dlm_config_info dlm_config = { 1026 .ci_tcp_port = DEFAULT_TCP_PORT, 1027 .ci_buffer_size = DEFAULT_BUFFER_SIZE, 1028 .ci_rsbtbl_size = DEFAULT_RSBTBL_SIZE, 1029 .ci_recover_timer = DEFAULT_RECOVER_TIMER, 1030 .ci_toss_secs = DEFAULT_TOSS_SECS, 1031 .ci_scan_secs = DEFAULT_SCAN_SECS, 1032 .ci_log_debug = DEFAULT_LOG_DEBUG, 1033 .ci_protocol = DEFAULT_PROTOCOL, 1034 .ci_timewarn_cs = DEFAULT_TIMEWARN_CS, 1035 .ci_waitwarn_us = DEFAULT_WAITWARN_US, 1036 .ci_new_rsb_count = DEFAULT_NEW_RSB_COUNT, 1037 .ci_recover_callbacks = DEFAULT_RECOVER_CALLBACKS, 1038 .ci_cluster_name = DEFAULT_CLUSTER_NAME 1039 }; 1040 1041