1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * stackglue.c 4 * 5 * Code which implements an OCFS2 specific interface to underlying 6 * cluster stacks. 7 * 8 * Copyright (C) 2007, 2009 Oracle. All rights reserved. 9 */ 10 11 #include <linux/list.h> 12 #include <linux/spinlock.h> 13 #include <linux/string.h> 14 #include <linux/module.h> 15 #include <linux/slab.h> 16 #include <linux/kmod.h> 17 #include <linux/fs.h> 18 #include <linux/kobject.h> 19 #include <linux/sysfs.h> 20 #include <linux/sysctl.h> 21 22 #include "ocfs2_fs.h" 23 24 #include "stackglue.h" 25 26 #define OCFS2_STACK_PLUGIN_O2CB "o2cb" 27 #define OCFS2_STACK_PLUGIN_USER "user" 28 #define OCFS2_MAX_HB_CTL_PATH 256 29 30 static struct ocfs2_protocol_version locking_max_version; 31 static DEFINE_SPINLOCK(ocfs2_stack_lock); 32 static LIST_HEAD(ocfs2_stack_list); 33 static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1]; 34 static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl"; 35 36 /* 37 * The stack currently in use. If not null, active_stack->sp_count > 0, 38 * the module is pinned, and the locking protocol cannot be changed. 39 */ 40 static struct ocfs2_stack_plugin *active_stack; 41 42 static struct ocfs2_stack_plugin *ocfs2_stack_lookup(const char *name) 43 { 44 struct ocfs2_stack_plugin *p; 45 46 assert_spin_locked(&ocfs2_stack_lock); 47 48 list_for_each_entry(p, &ocfs2_stack_list, sp_list) { 49 if (!strcmp(p->sp_name, name)) 50 return p; 51 } 52 53 return NULL; 54 } 55 56 static int ocfs2_stack_driver_request(const char *stack_name, 57 const char *plugin_name) 58 { 59 int rc; 60 struct ocfs2_stack_plugin *p; 61 62 spin_lock(&ocfs2_stack_lock); 63 64 /* 65 * If the stack passed by the filesystem isn't the selected one, 66 * we can't continue. 67 */ 68 if (strcmp(stack_name, cluster_stack_name)) { 69 rc = -EBUSY; 70 goto out; 71 } 72 73 if (active_stack) { 74 /* 75 * If the active stack isn't the one we want, it cannot 76 * be selected right now. 77 */ 78 if (!strcmp(active_stack->sp_name, plugin_name)) 79 rc = 0; 80 else 81 rc = -EBUSY; 82 goto out; 83 } 84 85 p = ocfs2_stack_lookup(plugin_name); 86 if (!p || !try_module_get(p->sp_owner)) { 87 rc = -ENOENT; 88 goto out; 89 } 90 91 active_stack = p; 92 rc = 0; 93 94 out: 95 /* If we found it, pin it */ 96 if (!rc) 97 active_stack->sp_count++; 98 99 spin_unlock(&ocfs2_stack_lock); 100 return rc; 101 } 102 103 /* 104 * This function looks up the appropriate stack and makes it active. If 105 * there is no stack, it tries to load it. It will fail if the stack still 106 * cannot be found. It will also fail if a different stack is in use. 107 */ 108 static int ocfs2_stack_driver_get(const char *stack_name) 109 { 110 int rc; 111 char *plugin_name = OCFS2_STACK_PLUGIN_O2CB; 112 113 /* 114 * Classic stack does not pass in a stack name. This is 115 * compatible with older tools as well. 116 */ 117 if (!stack_name || !*stack_name) 118 stack_name = OCFS2_STACK_PLUGIN_O2CB; 119 120 if (strlen(stack_name) != OCFS2_STACK_LABEL_LEN) { 121 printk(KERN_ERR 122 "ocfs2 passed an invalid cluster stack label: \"%s\"\n", 123 stack_name); 124 return -EINVAL; 125 } 126 127 /* Anything that isn't the classic stack is a user stack */ 128 if (strcmp(stack_name, OCFS2_STACK_PLUGIN_O2CB)) 129 plugin_name = OCFS2_STACK_PLUGIN_USER; 130 131 rc = ocfs2_stack_driver_request(stack_name, plugin_name); 132 if (rc == -ENOENT) { 133 request_module("ocfs2_stack_%s", plugin_name); 134 rc = ocfs2_stack_driver_request(stack_name, plugin_name); 135 } 136 137 if (rc == -ENOENT) { 138 printk(KERN_ERR 139 "ocfs2: Cluster stack driver \"%s\" cannot be found\n", 140 plugin_name); 141 } else if (rc == -EBUSY) { 142 printk(KERN_ERR 143 "ocfs2: A different cluster stack is in use\n"); 144 } 145 146 return rc; 147 } 148 149 static void ocfs2_stack_driver_put(void) 150 { 151 spin_lock(&ocfs2_stack_lock); 152 BUG_ON(active_stack == NULL); 153 BUG_ON(active_stack->sp_count == 0); 154 155 active_stack->sp_count--; 156 if (!active_stack->sp_count) { 157 module_put(active_stack->sp_owner); 158 active_stack = NULL; 159 } 160 spin_unlock(&ocfs2_stack_lock); 161 } 162 163 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin) 164 { 165 int rc; 166 167 spin_lock(&ocfs2_stack_lock); 168 if (!ocfs2_stack_lookup(plugin->sp_name)) { 169 plugin->sp_count = 0; 170 plugin->sp_max_proto = locking_max_version; 171 list_add(&plugin->sp_list, &ocfs2_stack_list); 172 printk(KERN_INFO "ocfs2: Registered cluster interface %s\n", 173 plugin->sp_name); 174 rc = 0; 175 } else { 176 printk(KERN_ERR "ocfs2: Stack \"%s\" already registered\n", 177 plugin->sp_name); 178 rc = -EEXIST; 179 } 180 spin_unlock(&ocfs2_stack_lock); 181 182 return rc; 183 } 184 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_register); 185 186 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin) 187 { 188 struct ocfs2_stack_plugin *p; 189 190 spin_lock(&ocfs2_stack_lock); 191 p = ocfs2_stack_lookup(plugin->sp_name); 192 if (p) { 193 BUG_ON(p != plugin); 194 BUG_ON(plugin == active_stack); 195 BUG_ON(plugin->sp_count != 0); 196 list_del_init(&plugin->sp_list); 197 printk(KERN_INFO "ocfs2: Unregistered cluster interface %s\n", 198 plugin->sp_name); 199 } else { 200 printk(KERN_ERR "Stack \"%s\" is not registered\n", 201 plugin->sp_name); 202 } 203 spin_unlock(&ocfs2_stack_lock); 204 } 205 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_unregister); 206 207 void ocfs2_stack_glue_set_max_proto_version(struct ocfs2_protocol_version *max_proto) 208 { 209 struct ocfs2_stack_plugin *p; 210 211 spin_lock(&ocfs2_stack_lock); 212 if (memcmp(max_proto, &locking_max_version, 213 sizeof(struct ocfs2_protocol_version))) { 214 BUG_ON(locking_max_version.pv_major != 0); 215 216 locking_max_version = *max_proto; 217 list_for_each_entry(p, &ocfs2_stack_list, sp_list) { 218 p->sp_max_proto = locking_max_version; 219 } 220 } 221 spin_unlock(&ocfs2_stack_lock); 222 } 223 EXPORT_SYMBOL_GPL(ocfs2_stack_glue_set_max_proto_version); 224 225 226 /* 227 * The ocfs2_dlm_lock() and ocfs2_dlm_unlock() functions take no argument 228 * for the ast and bast functions. They will pass the lksb to the ast 229 * and bast. The caller can wrap the lksb with their own structure to 230 * get more information. 231 */ 232 int ocfs2_dlm_lock(struct ocfs2_cluster_connection *conn, 233 int mode, 234 struct ocfs2_dlm_lksb *lksb, 235 u32 flags, 236 void *name, 237 unsigned int namelen) 238 { 239 if (!lksb->lksb_conn) 240 lksb->lksb_conn = conn; 241 else 242 BUG_ON(lksb->lksb_conn != conn); 243 return active_stack->sp_ops->dlm_lock(conn, mode, lksb, flags, 244 name, namelen); 245 } 246 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock); 247 248 int ocfs2_dlm_unlock(struct ocfs2_cluster_connection *conn, 249 struct ocfs2_dlm_lksb *lksb, 250 u32 flags) 251 { 252 BUG_ON(lksb->lksb_conn == NULL); 253 254 return active_stack->sp_ops->dlm_unlock(conn, lksb, flags); 255 } 256 EXPORT_SYMBOL_GPL(ocfs2_dlm_unlock); 257 258 int ocfs2_dlm_lock_status(struct ocfs2_dlm_lksb *lksb) 259 { 260 return active_stack->sp_ops->lock_status(lksb); 261 } 262 EXPORT_SYMBOL_GPL(ocfs2_dlm_lock_status); 263 264 int ocfs2_dlm_lvb_valid(struct ocfs2_dlm_lksb *lksb) 265 { 266 return active_stack->sp_ops->lvb_valid(lksb); 267 } 268 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb_valid); 269 270 void *ocfs2_dlm_lvb(struct ocfs2_dlm_lksb *lksb) 271 { 272 return active_stack->sp_ops->lock_lvb(lksb); 273 } 274 EXPORT_SYMBOL_GPL(ocfs2_dlm_lvb); 275 276 void ocfs2_dlm_dump_lksb(struct ocfs2_dlm_lksb *lksb) 277 { 278 active_stack->sp_ops->dump_lksb(lksb); 279 } 280 EXPORT_SYMBOL_GPL(ocfs2_dlm_dump_lksb); 281 282 int ocfs2_stack_supports_plocks(void) 283 { 284 return active_stack && active_stack->sp_ops->plock; 285 } 286 EXPORT_SYMBOL_GPL(ocfs2_stack_supports_plocks); 287 288 /* 289 * ocfs2_plock() can only be safely called if 290 * ocfs2_stack_supports_plocks() returned true 291 */ 292 int ocfs2_plock(struct ocfs2_cluster_connection *conn, u64 ino, 293 struct file *file, int cmd, struct file_lock *fl) 294 { 295 WARN_ON_ONCE(active_stack->sp_ops->plock == NULL); 296 if (active_stack->sp_ops->plock) 297 return active_stack->sp_ops->plock(conn, ino, file, cmd, fl); 298 return -EOPNOTSUPP; 299 } 300 EXPORT_SYMBOL_GPL(ocfs2_plock); 301 302 int ocfs2_cluster_connect(const char *stack_name, 303 const char *cluster_name, 304 int cluster_name_len, 305 const char *group, 306 int grouplen, 307 struct ocfs2_locking_protocol *lproto, 308 void (*recovery_handler)(int node_num, 309 void *recovery_data), 310 void *recovery_data, 311 struct ocfs2_cluster_connection **conn) 312 { 313 int rc = 0; 314 struct ocfs2_cluster_connection *new_conn; 315 316 BUG_ON(group == NULL); 317 BUG_ON(conn == NULL); 318 BUG_ON(recovery_handler == NULL); 319 320 if (grouplen > GROUP_NAME_MAX) { 321 rc = -EINVAL; 322 goto out; 323 } 324 325 if (memcmp(&lproto->lp_max_version, &locking_max_version, 326 sizeof(struct ocfs2_protocol_version))) { 327 rc = -EINVAL; 328 goto out; 329 } 330 331 new_conn = kzalloc(sizeof(struct ocfs2_cluster_connection), 332 GFP_KERNEL); 333 if (!new_conn) { 334 rc = -ENOMEM; 335 goto out; 336 } 337 338 strscpy(new_conn->cc_name, group, GROUP_NAME_MAX + 1); 339 new_conn->cc_namelen = grouplen; 340 if (cluster_name_len) 341 strscpy(new_conn->cc_cluster_name, cluster_name, 342 CLUSTER_NAME_MAX + 1); 343 new_conn->cc_cluster_name_len = cluster_name_len; 344 new_conn->cc_recovery_handler = recovery_handler; 345 new_conn->cc_recovery_data = recovery_data; 346 347 new_conn->cc_proto = lproto; 348 /* Start the new connection at our maximum compatibility level */ 349 new_conn->cc_version = lproto->lp_max_version; 350 351 /* This will pin the stack driver if successful */ 352 rc = ocfs2_stack_driver_get(stack_name); 353 if (rc) 354 goto out_free; 355 356 rc = active_stack->sp_ops->connect(new_conn); 357 if (rc) { 358 ocfs2_stack_driver_put(); 359 goto out_free; 360 } 361 362 *conn = new_conn; 363 364 out_free: 365 if (rc) 366 kfree(new_conn); 367 368 out: 369 return rc; 370 } 371 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect); 372 373 /* The caller will ensure all nodes have the same cluster stack */ 374 int ocfs2_cluster_connect_agnostic(const char *group, 375 int grouplen, 376 struct ocfs2_locking_protocol *lproto, 377 void (*recovery_handler)(int node_num, 378 void *recovery_data), 379 void *recovery_data, 380 struct ocfs2_cluster_connection **conn) 381 { 382 char *stack_name = NULL; 383 384 if (cluster_stack_name[0]) 385 stack_name = cluster_stack_name; 386 return ocfs2_cluster_connect(stack_name, NULL, 0, group, grouplen, 387 lproto, recovery_handler, recovery_data, 388 conn); 389 } 390 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect_agnostic); 391 392 /* If hangup_pending is 0, the stack driver will be dropped */ 393 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn, 394 int hangup_pending) 395 { 396 int ret; 397 398 BUG_ON(conn == NULL); 399 400 ret = active_stack->sp_ops->disconnect(conn); 401 402 /* XXX Should we free it anyway? */ 403 if (!ret) { 404 kfree(conn); 405 if (!hangup_pending) 406 ocfs2_stack_driver_put(); 407 } 408 409 return ret; 410 } 411 EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect); 412 413 /* 414 * Leave the group for this filesystem. This is executed by a userspace 415 * program (stored in ocfs2_hb_ctl_path). 416 */ 417 static void ocfs2_leave_group(const char *group) 418 { 419 int ret; 420 char *argv[5], *envp[3]; 421 422 argv[0] = ocfs2_hb_ctl_path; 423 argv[1] = "-K"; 424 argv[2] = "-u"; 425 argv[3] = (char *)group; 426 argv[4] = NULL; 427 428 /* minimal command environment taken from cpu_run_sbin_hotplug */ 429 envp[0] = "HOME=/"; 430 envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; 431 envp[2] = NULL; 432 433 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 434 if (ret < 0) { 435 printk(KERN_ERR 436 "ocfs2: Error %d running user helper " 437 "\"%s %s %s %s\"\n", 438 ret, argv[0], argv[1], argv[2], argv[3]); 439 } 440 } 441 442 /* 443 * Hangup is a required post-umount. ocfs2-tools software expects the 444 * filesystem to call "ocfs2_hb_ctl" during unmount. This happens 445 * regardless of whether the DLM got started, so we can't do it 446 * in ocfs2_cluster_disconnect(). The ocfs2_leave_group() function does 447 * the actual work. 448 */ 449 void ocfs2_cluster_hangup(const char *group, int grouplen) 450 { 451 BUG_ON(group == NULL); 452 BUG_ON(group[grouplen] != '\0'); 453 454 ocfs2_leave_group(group); 455 456 /* cluster_disconnect() was called with hangup_pending==1 */ 457 ocfs2_stack_driver_put(); 458 } 459 EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup); 460 461 int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn, 462 unsigned int *node) 463 { 464 return active_stack->sp_ops->this_node(conn, node); 465 } 466 EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node); 467 468 469 /* 470 * Sysfs bits 471 */ 472 473 static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj, 474 struct kobj_attribute *attr, 475 char *buf) 476 { 477 ssize_t ret = 0; 478 479 spin_lock(&ocfs2_stack_lock); 480 if (locking_max_version.pv_major) 481 ret = snprintf(buf, PAGE_SIZE, "%u.%u\n", 482 locking_max_version.pv_major, 483 locking_max_version.pv_minor); 484 spin_unlock(&ocfs2_stack_lock); 485 486 return ret; 487 } 488 489 static struct kobj_attribute ocfs2_attr_max_locking_protocol = 490 __ATTR(max_locking_protocol, S_IRUGO, 491 ocfs2_max_locking_protocol_show, NULL); 492 493 static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj, 494 struct kobj_attribute *attr, 495 char *buf) 496 { 497 ssize_t ret = 0, total = 0, remain = PAGE_SIZE; 498 struct ocfs2_stack_plugin *p; 499 500 spin_lock(&ocfs2_stack_lock); 501 list_for_each_entry(p, &ocfs2_stack_list, sp_list) { 502 ret = snprintf(buf, remain, "%s\n", 503 p->sp_name); 504 if (ret >= remain) { 505 /* snprintf() didn't fit */ 506 total = -E2BIG; 507 break; 508 } 509 total += ret; 510 remain -= ret; 511 } 512 spin_unlock(&ocfs2_stack_lock); 513 514 return total; 515 } 516 517 static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins = 518 __ATTR(loaded_cluster_plugins, S_IRUGO, 519 ocfs2_loaded_cluster_plugins_show, NULL); 520 521 static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj, 522 struct kobj_attribute *attr, 523 char *buf) 524 { 525 ssize_t ret = 0; 526 527 spin_lock(&ocfs2_stack_lock); 528 if (active_stack) { 529 ret = snprintf(buf, PAGE_SIZE, "%s\n", 530 active_stack->sp_name); 531 if (ret >= PAGE_SIZE) 532 ret = -E2BIG; 533 } 534 spin_unlock(&ocfs2_stack_lock); 535 536 return ret; 537 } 538 539 static struct kobj_attribute ocfs2_attr_active_cluster_plugin = 540 __ATTR(active_cluster_plugin, S_IRUGO, 541 ocfs2_active_cluster_plugin_show, NULL); 542 543 static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj, 544 struct kobj_attribute *attr, 545 char *buf) 546 { 547 ssize_t ret; 548 spin_lock(&ocfs2_stack_lock); 549 ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name); 550 spin_unlock(&ocfs2_stack_lock); 551 552 return ret; 553 } 554 555 static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj, 556 struct kobj_attribute *attr, 557 const char *buf, size_t count) 558 { 559 size_t len = count; 560 ssize_t ret; 561 562 if (len == 0) 563 return len; 564 565 if (buf[len - 1] == '\n') 566 len--; 567 568 if ((len != OCFS2_STACK_LABEL_LEN) || 569 (strnlen(buf, len) != len)) 570 return -EINVAL; 571 572 spin_lock(&ocfs2_stack_lock); 573 if (active_stack) { 574 if (!strncmp(buf, cluster_stack_name, len)) 575 ret = count; 576 else 577 ret = -EBUSY; 578 } else { 579 memcpy(cluster_stack_name, buf, len); 580 ret = count; 581 } 582 spin_unlock(&ocfs2_stack_lock); 583 584 return ret; 585 } 586 587 588 static struct kobj_attribute ocfs2_attr_cluster_stack = 589 __ATTR(cluster_stack, S_IRUGO | S_IWUSR, 590 ocfs2_cluster_stack_show, 591 ocfs2_cluster_stack_store); 592 593 594 595 static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj, 596 struct kobj_attribute *attr, 597 char *buf) 598 { 599 return snprintf(buf, PAGE_SIZE, "1\n"); 600 } 601 602 static struct kobj_attribute ocfs2_attr_dlm_recover_support = 603 __ATTR(dlm_recover_callback_support, S_IRUGO, 604 ocfs2_dlm_recover_show, NULL); 605 606 static struct attribute *ocfs2_attrs[] = { 607 &ocfs2_attr_max_locking_protocol.attr, 608 &ocfs2_attr_loaded_cluster_plugins.attr, 609 &ocfs2_attr_active_cluster_plugin.attr, 610 &ocfs2_attr_cluster_stack.attr, 611 &ocfs2_attr_dlm_recover_support.attr, 612 NULL, 613 }; 614 615 static const struct attribute_group ocfs2_attr_group = { 616 .attrs = ocfs2_attrs, 617 }; 618 619 struct kset *ocfs2_kset; 620 EXPORT_SYMBOL_GPL(ocfs2_kset); 621 622 static void ocfs2_sysfs_exit(void) 623 { 624 kset_unregister(ocfs2_kset); 625 } 626 627 static int ocfs2_sysfs_init(void) 628 { 629 int ret; 630 631 ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj); 632 if (!ocfs2_kset) 633 return -ENOMEM; 634 635 ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group); 636 if (ret) 637 goto error; 638 639 return 0; 640 641 error: 642 kset_unregister(ocfs2_kset); 643 return ret; 644 } 645 646 /* 647 * Sysctl bits 648 * 649 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path. The 'nm' doesn't 650 * make as much sense in a multiple cluster stack world, but it's safer 651 * and easier to preserve the name. 652 */ 653 654 static const struct ctl_table ocfs2_nm_table[] = { 655 { 656 .procname = "hb_ctl_path", 657 .data = ocfs2_hb_ctl_path, 658 .maxlen = OCFS2_MAX_HB_CTL_PATH, 659 .mode = 0644, 660 .proc_handler = proc_dostring, 661 }, 662 }; 663 664 static struct ctl_table_header *ocfs2_table_header; 665 666 /* 667 * Initialization 668 */ 669 670 static int __init ocfs2_stack_glue_init(void) 671 { 672 int ret; 673 674 strscpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB); 675 676 ocfs2_table_header = register_sysctl("fs/ocfs2/nm", ocfs2_nm_table); 677 if (!ocfs2_table_header) { 678 printk(KERN_ERR 679 "ocfs2 stack glue: unable to register sysctl\n"); 680 return -ENOMEM; /* or something. */ 681 } 682 683 ret = ocfs2_sysfs_init(); 684 if (ret) 685 unregister_sysctl_table(ocfs2_table_header); 686 687 return ret; 688 } 689 690 static void __exit ocfs2_stack_glue_exit(void) 691 { 692 memset(&locking_max_version, 0, 693 sizeof(struct ocfs2_protocol_version)); 694 ocfs2_sysfs_exit(); 695 unregister_sysctl_table(ocfs2_table_header); 696 } 697 698 MODULE_AUTHOR("Oracle"); 699 MODULE_DESCRIPTION("ocfs2 cluster stack glue layer"); 700 MODULE_LICENSE("GPL"); 701 module_init(ocfs2_stack_glue_init); 702 module_exit(ocfs2_stack_glue_exit); 703