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_obj(struct ocfs2_cluster_connection); 332 if (!new_conn) { 333 rc = -ENOMEM; 334 goto out; 335 } 336 337 strscpy(new_conn->cc_name, group, GROUP_NAME_MAX + 1); 338 new_conn->cc_namelen = grouplen; 339 if (cluster_name_len) 340 strscpy(new_conn->cc_cluster_name, cluster_name, 341 CLUSTER_NAME_MAX + 1); 342 new_conn->cc_cluster_name_len = cluster_name_len; 343 new_conn->cc_recovery_handler = recovery_handler; 344 new_conn->cc_recovery_data = recovery_data; 345 346 new_conn->cc_proto = lproto; 347 /* Start the new connection at our maximum compatibility level */ 348 new_conn->cc_version = lproto->lp_max_version; 349 350 /* This will pin the stack driver if successful */ 351 rc = ocfs2_stack_driver_get(stack_name); 352 if (rc) 353 goto out_free; 354 355 rc = active_stack->sp_ops->connect(new_conn); 356 if (rc) { 357 ocfs2_stack_driver_put(); 358 goto out_free; 359 } 360 361 *conn = new_conn; 362 363 out_free: 364 if (rc) 365 kfree(new_conn); 366 367 out: 368 return rc; 369 } 370 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect); 371 372 /* The caller will ensure all nodes have the same cluster stack */ 373 int ocfs2_cluster_connect_agnostic(const char *group, 374 int grouplen, 375 struct ocfs2_locking_protocol *lproto, 376 void (*recovery_handler)(int node_num, 377 void *recovery_data), 378 void *recovery_data, 379 struct ocfs2_cluster_connection **conn) 380 { 381 char *stack_name = NULL; 382 383 if (cluster_stack_name[0]) 384 stack_name = cluster_stack_name; 385 return ocfs2_cluster_connect(stack_name, NULL, 0, group, grouplen, 386 lproto, recovery_handler, recovery_data, 387 conn); 388 } 389 EXPORT_SYMBOL_GPL(ocfs2_cluster_connect_agnostic); 390 391 /* If hangup_pending is 0, the stack driver will be dropped */ 392 int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn, 393 int hangup_pending) 394 { 395 int ret; 396 397 BUG_ON(conn == NULL); 398 399 ret = active_stack->sp_ops->disconnect(conn); 400 401 /* XXX Should we free it anyway? */ 402 if (!ret) { 403 kfree(conn); 404 if (!hangup_pending) 405 ocfs2_stack_driver_put(); 406 } 407 408 return ret; 409 } 410 EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect); 411 412 /* 413 * Leave the group for this filesystem. This is executed by a userspace 414 * program (stored in ocfs2_hb_ctl_path). 415 */ 416 static void ocfs2_leave_group(const char *group) 417 { 418 int ret; 419 char *argv[5], *envp[3]; 420 421 argv[0] = ocfs2_hb_ctl_path; 422 argv[1] = "-K"; 423 argv[2] = "-u"; 424 argv[3] = (char *)group; 425 argv[4] = NULL; 426 427 /* minimal command environment taken from cpu_run_sbin_hotplug */ 428 envp[0] = "HOME=/"; 429 envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; 430 envp[2] = NULL; 431 432 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 433 if (ret < 0) { 434 printk(KERN_ERR 435 "ocfs2: Error %d running user helper " 436 "\"%s %s %s %s\"\n", 437 ret, argv[0], argv[1], argv[2], argv[3]); 438 } 439 } 440 441 /* 442 * Hangup is a required post-umount. ocfs2-tools software expects the 443 * filesystem to call "ocfs2_hb_ctl" during unmount. This happens 444 * regardless of whether the DLM got started, so we can't do it 445 * in ocfs2_cluster_disconnect(). The ocfs2_leave_group() function does 446 * the actual work. 447 */ 448 void ocfs2_cluster_hangup(const char *group, int grouplen) 449 { 450 BUG_ON(group == NULL); 451 BUG_ON(group[grouplen] != '\0'); 452 453 ocfs2_leave_group(group); 454 455 /* cluster_disconnect() was called with hangup_pending==1 */ 456 ocfs2_stack_driver_put(); 457 } 458 EXPORT_SYMBOL_GPL(ocfs2_cluster_hangup); 459 460 int ocfs2_cluster_this_node(struct ocfs2_cluster_connection *conn, 461 unsigned int *node) 462 { 463 return active_stack->sp_ops->this_node(conn, node); 464 } 465 EXPORT_SYMBOL_GPL(ocfs2_cluster_this_node); 466 467 468 /* 469 * Sysfs bits 470 */ 471 472 static ssize_t ocfs2_max_locking_protocol_show(struct kobject *kobj, 473 struct kobj_attribute *attr, 474 char *buf) 475 { 476 ssize_t ret = 0; 477 478 spin_lock(&ocfs2_stack_lock); 479 if (locking_max_version.pv_major) 480 ret = snprintf(buf, PAGE_SIZE, "%u.%u\n", 481 locking_max_version.pv_major, 482 locking_max_version.pv_minor); 483 spin_unlock(&ocfs2_stack_lock); 484 485 return ret; 486 } 487 488 static struct kobj_attribute ocfs2_attr_max_locking_protocol = 489 __ATTR(max_locking_protocol, S_IRUGO, 490 ocfs2_max_locking_protocol_show, NULL); 491 492 static ssize_t ocfs2_loaded_cluster_plugins_show(struct kobject *kobj, 493 struct kobj_attribute *attr, 494 char *buf) 495 { 496 ssize_t ret = 0, total = 0, remain = PAGE_SIZE; 497 struct ocfs2_stack_plugin *p; 498 499 spin_lock(&ocfs2_stack_lock); 500 list_for_each_entry(p, &ocfs2_stack_list, sp_list) { 501 ret = snprintf(buf, remain, "%s\n", 502 p->sp_name); 503 if (ret >= remain) { 504 /* snprintf() didn't fit */ 505 total = -E2BIG; 506 break; 507 } 508 total += ret; 509 remain -= ret; 510 } 511 spin_unlock(&ocfs2_stack_lock); 512 513 return total; 514 } 515 516 static struct kobj_attribute ocfs2_attr_loaded_cluster_plugins = 517 __ATTR(loaded_cluster_plugins, S_IRUGO, 518 ocfs2_loaded_cluster_plugins_show, NULL); 519 520 static ssize_t ocfs2_active_cluster_plugin_show(struct kobject *kobj, 521 struct kobj_attribute *attr, 522 char *buf) 523 { 524 ssize_t ret = 0; 525 526 spin_lock(&ocfs2_stack_lock); 527 if (active_stack) { 528 ret = snprintf(buf, PAGE_SIZE, "%s\n", 529 active_stack->sp_name); 530 if (ret >= PAGE_SIZE) 531 ret = -E2BIG; 532 } 533 spin_unlock(&ocfs2_stack_lock); 534 535 return ret; 536 } 537 538 static struct kobj_attribute ocfs2_attr_active_cluster_plugin = 539 __ATTR(active_cluster_plugin, S_IRUGO, 540 ocfs2_active_cluster_plugin_show, NULL); 541 542 static ssize_t ocfs2_cluster_stack_show(struct kobject *kobj, 543 struct kobj_attribute *attr, 544 char *buf) 545 { 546 ssize_t ret; 547 spin_lock(&ocfs2_stack_lock); 548 ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name); 549 spin_unlock(&ocfs2_stack_lock); 550 551 return ret; 552 } 553 554 static ssize_t ocfs2_cluster_stack_store(struct kobject *kobj, 555 struct kobj_attribute *attr, 556 const char *buf, size_t count) 557 { 558 size_t len = count; 559 ssize_t ret; 560 561 if (len == 0) 562 return len; 563 564 if (buf[len - 1] == '\n') 565 len--; 566 567 if ((len != OCFS2_STACK_LABEL_LEN) || 568 (strnlen(buf, len) != len)) 569 return -EINVAL; 570 571 spin_lock(&ocfs2_stack_lock); 572 if (active_stack) { 573 if (!strncmp(buf, cluster_stack_name, len)) 574 ret = count; 575 else 576 ret = -EBUSY; 577 } else { 578 memcpy(cluster_stack_name, buf, len); 579 ret = count; 580 } 581 spin_unlock(&ocfs2_stack_lock); 582 583 return ret; 584 } 585 586 587 static struct kobj_attribute ocfs2_attr_cluster_stack = 588 __ATTR(cluster_stack, S_IRUGO | S_IWUSR, 589 ocfs2_cluster_stack_show, 590 ocfs2_cluster_stack_store); 591 592 593 594 static ssize_t ocfs2_dlm_recover_show(struct kobject *kobj, 595 struct kobj_attribute *attr, 596 char *buf) 597 { 598 return snprintf(buf, PAGE_SIZE, "1\n"); 599 } 600 601 static struct kobj_attribute ocfs2_attr_dlm_recover_support = 602 __ATTR(dlm_recover_callback_support, S_IRUGO, 603 ocfs2_dlm_recover_show, NULL); 604 605 static struct attribute *ocfs2_attrs[] = { 606 &ocfs2_attr_max_locking_protocol.attr, 607 &ocfs2_attr_loaded_cluster_plugins.attr, 608 &ocfs2_attr_active_cluster_plugin.attr, 609 &ocfs2_attr_cluster_stack.attr, 610 &ocfs2_attr_dlm_recover_support.attr, 611 NULL, 612 }; 613 614 static const struct attribute_group ocfs2_attr_group = { 615 .attrs = ocfs2_attrs, 616 }; 617 618 struct kset *ocfs2_kset; 619 EXPORT_SYMBOL_GPL(ocfs2_kset); 620 621 static void ocfs2_sysfs_exit(void) 622 { 623 kset_unregister(ocfs2_kset); 624 } 625 626 static int ocfs2_sysfs_init(void) 627 { 628 int ret; 629 630 ocfs2_kset = kset_create_and_add("ocfs2", NULL, fs_kobj); 631 if (!ocfs2_kset) 632 return -ENOMEM; 633 634 ret = sysfs_create_group(&ocfs2_kset->kobj, &ocfs2_attr_group); 635 if (ret) 636 goto error; 637 638 return 0; 639 640 error: 641 kset_unregister(ocfs2_kset); 642 return ret; 643 } 644 645 /* 646 * Sysctl bits 647 * 648 * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path. The 'nm' doesn't 649 * make as much sense in a multiple cluster stack world, but it's safer 650 * and easier to preserve the name. 651 */ 652 653 static const struct ctl_table ocfs2_nm_table[] = { 654 { 655 .procname = "hb_ctl_path", 656 .data = ocfs2_hb_ctl_path, 657 .maxlen = OCFS2_MAX_HB_CTL_PATH, 658 .mode = 0644, 659 .proc_handler = proc_dostring, 660 }, 661 }; 662 663 static struct ctl_table_header *ocfs2_table_header; 664 665 /* 666 * Initialization 667 */ 668 669 static int __init ocfs2_stack_glue_init(void) 670 { 671 int ret; 672 673 strscpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB); 674 675 ocfs2_table_header = register_sysctl("fs/ocfs2/nm", ocfs2_nm_table); 676 if (!ocfs2_table_header) { 677 printk(KERN_ERR 678 "ocfs2 stack glue: unable to register sysctl\n"); 679 return -ENOMEM; /* or something. */ 680 } 681 682 ret = ocfs2_sysfs_init(); 683 if (ret) 684 unregister_sysctl_table(ocfs2_table_header); 685 686 return ret; 687 } 688 689 static void __exit ocfs2_stack_glue_exit(void) 690 { 691 memset(&locking_max_version, 0, 692 sizeof(struct ocfs2_protocol_version)); 693 ocfs2_sysfs_exit(); 694 unregister_sysctl_table(ocfs2_table_header); 695 } 696 697 MODULE_AUTHOR("Oracle"); 698 MODULE_DESCRIPTION("ocfs2 cluster stack glue layer"); 699 MODULE_LICENSE("GPL"); 700 module_init(ocfs2_stack_glue_init); 701 module_exit(ocfs2_stack_glue_exit); 702