1 /****************************************************************************** 2 ******************************************************************************* 3 ** 4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 5 ** Copyright (C) 2004-2008 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 "dlm_internal.h" 15 #include "lockspace.h" 16 #include "member.h" 17 #include "recoverd.h" 18 #include "ast.h" 19 #include "dir.h" 20 #include "lowcomms.h" 21 #include "config.h" 22 #include "memory.h" 23 #include "lock.h" 24 #include "recover.h" 25 #include "requestqueue.h" 26 #include "user.h" 27 28 static int ls_count; 29 static struct mutex ls_lock; 30 static struct list_head lslist; 31 static spinlock_t lslist_lock; 32 static struct task_struct * scand_task; 33 34 35 static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len) 36 { 37 ssize_t ret = len; 38 int n = simple_strtol(buf, NULL, 0); 39 40 ls = dlm_find_lockspace_local(ls->ls_local_handle); 41 if (!ls) 42 return -EINVAL; 43 44 switch (n) { 45 case 0: 46 dlm_ls_stop(ls); 47 break; 48 case 1: 49 dlm_ls_start(ls); 50 break; 51 default: 52 ret = -EINVAL; 53 } 54 dlm_put_lockspace(ls); 55 return ret; 56 } 57 58 static ssize_t dlm_event_store(struct dlm_ls *ls, const char *buf, size_t len) 59 { 60 ls->ls_uevent_result = simple_strtol(buf, NULL, 0); 61 set_bit(LSFL_UEVENT_WAIT, &ls->ls_flags); 62 wake_up(&ls->ls_uevent_wait); 63 return len; 64 } 65 66 static ssize_t dlm_id_show(struct dlm_ls *ls, char *buf) 67 { 68 return snprintf(buf, PAGE_SIZE, "%u\n", ls->ls_global_id); 69 } 70 71 static ssize_t dlm_id_store(struct dlm_ls *ls, const char *buf, size_t len) 72 { 73 ls->ls_global_id = simple_strtoul(buf, NULL, 0); 74 return len; 75 } 76 77 static ssize_t dlm_recover_status_show(struct dlm_ls *ls, char *buf) 78 { 79 uint32_t status = dlm_recover_status(ls); 80 return snprintf(buf, PAGE_SIZE, "%x\n", status); 81 } 82 83 static ssize_t dlm_recover_nodeid_show(struct dlm_ls *ls, char *buf) 84 { 85 return snprintf(buf, PAGE_SIZE, "%d\n", ls->ls_recover_nodeid); 86 } 87 88 struct dlm_attr { 89 struct attribute attr; 90 ssize_t (*show)(struct dlm_ls *, char *); 91 ssize_t (*store)(struct dlm_ls *, const char *, size_t); 92 }; 93 94 static struct dlm_attr dlm_attr_control = { 95 .attr = {.name = "control", .mode = S_IWUSR}, 96 .store = dlm_control_store 97 }; 98 99 static struct dlm_attr dlm_attr_event = { 100 .attr = {.name = "event_done", .mode = S_IWUSR}, 101 .store = dlm_event_store 102 }; 103 104 static struct dlm_attr dlm_attr_id = { 105 .attr = {.name = "id", .mode = S_IRUGO | S_IWUSR}, 106 .show = dlm_id_show, 107 .store = dlm_id_store 108 }; 109 110 static struct dlm_attr dlm_attr_recover_status = { 111 .attr = {.name = "recover_status", .mode = S_IRUGO}, 112 .show = dlm_recover_status_show 113 }; 114 115 static struct dlm_attr dlm_attr_recover_nodeid = { 116 .attr = {.name = "recover_nodeid", .mode = S_IRUGO}, 117 .show = dlm_recover_nodeid_show 118 }; 119 120 static struct attribute *dlm_attrs[] = { 121 &dlm_attr_control.attr, 122 &dlm_attr_event.attr, 123 &dlm_attr_id.attr, 124 &dlm_attr_recover_status.attr, 125 &dlm_attr_recover_nodeid.attr, 126 NULL, 127 }; 128 129 static ssize_t dlm_attr_show(struct kobject *kobj, struct attribute *attr, 130 char *buf) 131 { 132 struct dlm_ls *ls = container_of(kobj, struct dlm_ls, ls_kobj); 133 struct dlm_attr *a = container_of(attr, struct dlm_attr, attr); 134 return a->show ? a->show(ls, buf) : 0; 135 } 136 137 static ssize_t dlm_attr_store(struct kobject *kobj, struct attribute *attr, 138 const char *buf, size_t len) 139 { 140 struct dlm_ls *ls = container_of(kobj, struct dlm_ls, ls_kobj); 141 struct dlm_attr *a = container_of(attr, struct dlm_attr, attr); 142 return a->store ? a->store(ls, buf, len) : len; 143 } 144 145 static void lockspace_kobj_release(struct kobject *k) 146 { 147 struct dlm_ls *ls = container_of(k, struct dlm_ls, ls_kobj); 148 kfree(ls); 149 } 150 151 static const struct sysfs_ops dlm_attr_ops = { 152 .show = dlm_attr_show, 153 .store = dlm_attr_store, 154 }; 155 156 static struct kobj_type dlm_ktype = { 157 .default_attrs = dlm_attrs, 158 .sysfs_ops = &dlm_attr_ops, 159 .release = lockspace_kobj_release, 160 }; 161 162 static struct kset *dlm_kset; 163 164 static int do_uevent(struct dlm_ls *ls, int in) 165 { 166 int error; 167 168 if (in) 169 kobject_uevent(&ls->ls_kobj, KOBJ_ONLINE); 170 else 171 kobject_uevent(&ls->ls_kobj, KOBJ_OFFLINE); 172 173 log_debug(ls, "%s the lockspace group...", in ? "joining" : "leaving"); 174 175 /* dlm_controld will see the uevent, do the necessary group management 176 and then write to sysfs to wake us */ 177 178 error = wait_event_interruptible(ls->ls_uevent_wait, 179 test_and_clear_bit(LSFL_UEVENT_WAIT, &ls->ls_flags)); 180 181 log_debug(ls, "group event done %d %d", error, ls->ls_uevent_result); 182 183 if (error) 184 goto out; 185 186 error = ls->ls_uevent_result; 187 out: 188 if (error) 189 log_error(ls, "group %s failed %d %d", in ? "join" : "leave", 190 error, ls->ls_uevent_result); 191 return error; 192 } 193 194 static int dlm_uevent(struct kset *kset, struct kobject *kobj, 195 struct kobj_uevent_env *env) 196 { 197 struct dlm_ls *ls = container_of(kobj, struct dlm_ls, ls_kobj); 198 199 add_uevent_var(env, "LOCKSPACE=%s", ls->ls_name); 200 return 0; 201 } 202 203 static struct kset_uevent_ops dlm_uevent_ops = { 204 .uevent = dlm_uevent, 205 }; 206 207 int __init dlm_lockspace_init(void) 208 { 209 ls_count = 0; 210 mutex_init(&ls_lock); 211 INIT_LIST_HEAD(&lslist); 212 spin_lock_init(&lslist_lock); 213 214 dlm_kset = kset_create_and_add("dlm", &dlm_uevent_ops, kernel_kobj); 215 if (!dlm_kset) { 216 printk(KERN_WARNING "%s: can not create kset\n", __func__); 217 return -ENOMEM; 218 } 219 return 0; 220 } 221 222 void dlm_lockspace_exit(void) 223 { 224 kset_unregister(dlm_kset); 225 } 226 227 static struct dlm_ls *find_ls_to_scan(void) 228 { 229 struct dlm_ls *ls; 230 231 spin_lock(&lslist_lock); 232 list_for_each_entry(ls, &lslist, ls_list) { 233 if (time_after_eq(jiffies, ls->ls_scan_time + 234 dlm_config.ci_scan_secs * HZ)) { 235 spin_unlock(&lslist_lock); 236 return ls; 237 } 238 } 239 spin_unlock(&lslist_lock); 240 return NULL; 241 } 242 243 static int dlm_scand(void *data) 244 { 245 struct dlm_ls *ls; 246 int timeout_jiffies = dlm_config.ci_scan_secs * HZ; 247 248 while (!kthread_should_stop()) { 249 ls = find_ls_to_scan(); 250 if (ls) { 251 if (dlm_lock_recovery_try(ls)) { 252 ls->ls_scan_time = jiffies; 253 dlm_scan_rsbs(ls); 254 dlm_scan_timeout(ls); 255 dlm_unlock_recovery(ls); 256 } else { 257 ls->ls_scan_time += HZ; 258 } 259 } else { 260 schedule_timeout_interruptible(timeout_jiffies); 261 } 262 } 263 return 0; 264 } 265 266 static int dlm_scand_start(void) 267 { 268 struct task_struct *p; 269 int error = 0; 270 271 p = kthread_run(dlm_scand, NULL, "dlm_scand"); 272 if (IS_ERR(p)) 273 error = PTR_ERR(p); 274 else 275 scand_task = p; 276 return error; 277 } 278 279 static void dlm_scand_stop(void) 280 { 281 kthread_stop(scand_task); 282 } 283 284 struct dlm_ls *dlm_find_lockspace_global(uint32_t id) 285 { 286 struct dlm_ls *ls; 287 288 spin_lock(&lslist_lock); 289 290 list_for_each_entry(ls, &lslist, ls_list) { 291 if (ls->ls_global_id == id) { 292 ls->ls_count++; 293 goto out; 294 } 295 } 296 ls = NULL; 297 out: 298 spin_unlock(&lslist_lock); 299 return ls; 300 } 301 302 struct dlm_ls *dlm_find_lockspace_local(dlm_lockspace_t *lockspace) 303 { 304 struct dlm_ls *ls; 305 306 spin_lock(&lslist_lock); 307 list_for_each_entry(ls, &lslist, ls_list) { 308 if (ls->ls_local_handle == lockspace) { 309 ls->ls_count++; 310 goto out; 311 } 312 } 313 ls = NULL; 314 out: 315 spin_unlock(&lslist_lock); 316 return ls; 317 } 318 319 struct dlm_ls *dlm_find_lockspace_device(int minor) 320 { 321 struct dlm_ls *ls; 322 323 spin_lock(&lslist_lock); 324 list_for_each_entry(ls, &lslist, ls_list) { 325 if (ls->ls_device.minor == minor) { 326 ls->ls_count++; 327 goto out; 328 } 329 } 330 ls = NULL; 331 out: 332 spin_unlock(&lslist_lock); 333 return ls; 334 } 335 336 void dlm_put_lockspace(struct dlm_ls *ls) 337 { 338 spin_lock(&lslist_lock); 339 ls->ls_count--; 340 spin_unlock(&lslist_lock); 341 } 342 343 static void remove_lockspace(struct dlm_ls *ls) 344 { 345 for (;;) { 346 spin_lock(&lslist_lock); 347 if (ls->ls_count == 0) { 348 WARN_ON(ls->ls_create_count != 0); 349 list_del(&ls->ls_list); 350 spin_unlock(&lslist_lock); 351 return; 352 } 353 spin_unlock(&lslist_lock); 354 ssleep(1); 355 } 356 } 357 358 static int threads_start(void) 359 { 360 int error; 361 362 /* Thread which process lock requests for all lockspace's */ 363 error = dlm_astd_start(); 364 if (error) { 365 log_print("cannot start dlm_astd thread %d", error); 366 goto fail; 367 } 368 369 error = dlm_scand_start(); 370 if (error) { 371 log_print("cannot start dlm_scand thread %d", error); 372 goto astd_fail; 373 } 374 375 /* Thread for sending/receiving messages for all lockspace's */ 376 error = dlm_lowcomms_start(); 377 if (error) { 378 log_print("cannot start dlm lowcomms %d", error); 379 goto scand_fail; 380 } 381 382 return 0; 383 384 scand_fail: 385 dlm_scand_stop(); 386 astd_fail: 387 dlm_astd_stop(); 388 fail: 389 return error; 390 } 391 392 static void threads_stop(void) 393 { 394 dlm_scand_stop(); 395 dlm_lowcomms_stop(); 396 dlm_astd_stop(); 397 } 398 399 static int new_lockspace(const char *name, int namelen, void **lockspace, 400 uint32_t flags, int lvblen) 401 { 402 struct dlm_ls *ls; 403 int i, size, error; 404 int do_unreg = 0; 405 406 if (namelen > DLM_LOCKSPACE_LEN) 407 return -EINVAL; 408 409 if (!lvblen || (lvblen % 8)) 410 return -EINVAL; 411 412 if (!try_module_get(THIS_MODULE)) 413 return -EINVAL; 414 415 if (!dlm_user_daemon_available()) { 416 module_put(THIS_MODULE); 417 return -EUNATCH; 418 } 419 420 error = 0; 421 422 spin_lock(&lslist_lock); 423 list_for_each_entry(ls, &lslist, ls_list) { 424 WARN_ON(ls->ls_create_count <= 0); 425 if (ls->ls_namelen != namelen) 426 continue; 427 if (memcmp(ls->ls_name, name, namelen)) 428 continue; 429 if (flags & DLM_LSFL_NEWEXCL) { 430 error = -EEXIST; 431 break; 432 } 433 ls->ls_create_count++; 434 *lockspace = ls; 435 error = 1; 436 break; 437 } 438 spin_unlock(&lslist_lock); 439 440 if (error) 441 goto out; 442 443 error = -ENOMEM; 444 445 ls = kzalloc(sizeof(struct dlm_ls) + namelen, GFP_NOFS); 446 if (!ls) 447 goto out; 448 memcpy(ls->ls_name, name, namelen); 449 ls->ls_namelen = namelen; 450 ls->ls_lvblen = lvblen; 451 ls->ls_count = 0; 452 ls->ls_flags = 0; 453 ls->ls_scan_time = jiffies; 454 455 if (flags & DLM_LSFL_TIMEWARN) 456 set_bit(LSFL_TIMEWARN, &ls->ls_flags); 457 458 /* ls_exflags are forced to match among nodes, and we don't 459 need to require all nodes to have some flags set */ 460 ls->ls_exflags = (flags & ~(DLM_LSFL_TIMEWARN | DLM_LSFL_FS | 461 DLM_LSFL_NEWEXCL)); 462 463 size = dlm_config.ci_rsbtbl_size; 464 ls->ls_rsbtbl_size = size; 465 466 ls->ls_rsbtbl = kmalloc(sizeof(struct dlm_rsbtable) * size, GFP_NOFS); 467 if (!ls->ls_rsbtbl) 468 goto out_lsfree; 469 for (i = 0; i < size; i++) { 470 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].list); 471 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].toss); 472 spin_lock_init(&ls->ls_rsbtbl[i].lock); 473 } 474 475 size = dlm_config.ci_lkbtbl_size; 476 ls->ls_lkbtbl_size = size; 477 478 ls->ls_lkbtbl = kmalloc(sizeof(struct dlm_lkbtable) * size, GFP_NOFS); 479 if (!ls->ls_lkbtbl) 480 goto out_rsbfree; 481 for (i = 0; i < size; i++) { 482 INIT_LIST_HEAD(&ls->ls_lkbtbl[i].list); 483 rwlock_init(&ls->ls_lkbtbl[i].lock); 484 ls->ls_lkbtbl[i].counter = 1; 485 } 486 487 size = dlm_config.ci_dirtbl_size; 488 ls->ls_dirtbl_size = size; 489 490 ls->ls_dirtbl = kmalloc(sizeof(struct dlm_dirtable) * size, GFP_NOFS); 491 if (!ls->ls_dirtbl) 492 goto out_lkbfree; 493 for (i = 0; i < size; i++) { 494 INIT_LIST_HEAD(&ls->ls_dirtbl[i].list); 495 spin_lock_init(&ls->ls_dirtbl[i].lock); 496 } 497 498 INIT_LIST_HEAD(&ls->ls_waiters); 499 mutex_init(&ls->ls_waiters_mutex); 500 INIT_LIST_HEAD(&ls->ls_orphans); 501 mutex_init(&ls->ls_orphans_mutex); 502 INIT_LIST_HEAD(&ls->ls_timeout); 503 mutex_init(&ls->ls_timeout_mutex); 504 505 INIT_LIST_HEAD(&ls->ls_nodes); 506 INIT_LIST_HEAD(&ls->ls_nodes_gone); 507 ls->ls_num_nodes = 0; 508 ls->ls_low_nodeid = 0; 509 ls->ls_total_weight = 0; 510 ls->ls_node_array = NULL; 511 512 memset(&ls->ls_stub_rsb, 0, sizeof(struct dlm_rsb)); 513 ls->ls_stub_rsb.res_ls = ls; 514 515 ls->ls_debug_rsb_dentry = NULL; 516 ls->ls_debug_waiters_dentry = NULL; 517 518 init_waitqueue_head(&ls->ls_uevent_wait); 519 ls->ls_uevent_result = 0; 520 init_completion(&ls->ls_members_done); 521 ls->ls_members_result = -1; 522 523 ls->ls_recoverd_task = NULL; 524 mutex_init(&ls->ls_recoverd_active); 525 spin_lock_init(&ls->ls_recover_lock); 526 spin_lock_init(&ls->ls_rcom_spin); 527 get_random_bytes(&ls->ls_rcom_seq, sizeof(uint64_t)); 528 ls->ls_recover_status = 0; 529 ls->ls_recover_seq = 0; 530 ls->ls_recover_args = NULL; 531 init_rwsem(&ls->ls_in_recovery); 532 init_rwsem(&ls->ls_recv_active); 533 INIT_LIST_HEAD(&ls->ls_requestqueue); 534 mutex_init(&ls->ls_requestqueue_mutex); 535 mutex_init(&ls->ls_clear_proc_locks); 536 537 ls->ls_recover_buf = kmalloc(dlm_config.ci_buffer_size, GFP_NOFS); 538 if (!ls->ls_recover_buf) 539 goto out_dirfree; 540 541 INIT_LIST_HEAD(&ls->ls_recover_list); 542 spin_lock_init(&ls->ls_recover_list_lock); 543 ls->ls_recover_list_count = 0; 544 ls->ls_local_handle = ls; 545 init_waitqueue_head(&ls->ls_wait_general); 546 INIT_LIST_HEAD(&ls->ls_root_list); 547 init_rwsem(&ls->ls_root_sem); 548 549 down_write(&ls->ls_in_recovery); 550 551 spin_lock(&lslist_lock); 552 ls->ls_create_count = 1; 553 list_add(&ls->ls_list, &lslist); 554 spin_unlock(&lslist_lock); 555 556 /* needs to find ls in lslist */ 557 error = dlm_recoverd_start(ls); 558 if (error) { 559 log_error(ls, "can't start dlm_recoverd %d", error); 560 goto out_delist; 561 } 562 563 ls->ls_kobj.kset = dlm_kset; 564 error = kobject_init_and_add(&ls->ls_kobj, &dlm_ktype, NULL, 565 "%s", ls->ls_name); 566 if (error) 567 goto out_stop; 568 kobject_uevent(&ls->ls_kobj, KOBJ_ADD); 569 570 /* let kobject handle freeing of ls if there's an error */ 571 do_unreg = 1; 572 573 /* This uevent triggers dlm_controld in userspace to add us to the 574 group of nodes that are members of this lockspace (managed by the 575 cluster infrastructure.) Once it's done that, it tells us who the 576 current lockspace members are (via configfs) and then tells the 577 lockspace to start running (via sysfs) in dlm_ls_start(). */ 578 579 error = do_uevent(ls, 1); 580 if (error) 581 goto out_stop; 582 583 wait_for_completion(&ls->ls_members_done); 584 error = ls->ls_members_result; 585 if (error) 586 goto out_members; 587 588 dlm_create_debug_file(ls); 589 590 log_debug(ls, "join complete"); 591 *lockspace = ls; 592 return 0; 593 594 out_members: 595 do_uevent(ls, 0); 596 dlm_clear_members(ls); 597 kfree(ls->ls_node_array); 598 out_stop: 599 dlm_recoverd_stop(ls); 600 out_delist: 601 spin_lock(&lslist_lock); 602 list_del(&ls->ls_list); 603 spin_unlock(&lslist_lock); 604 kfree(ls->ls_recover_buf); 605 out_dirfree: 606 kfree(ls->ls_dirtbl); 607 out_lkbfree: 608 kfree(ls->ls_lkbtbl); 609 out_rsbfree: 610 kfree(ls->ls_rsbtbl); 611 out_lsfree: 612 if (do_unreg) 613 kobject_put(&ls->ls_kobj); 614 else 615 kfree(ls); 616 out: 617 module_put(THIS_MODULE); 618 return error; 619 } 620 621 int dlm_new_lockspace(const char *name, int namelen, void **lockspace, 622 uint32_t flags, int lvblen) 623 { 624 int error = 0; 625 626 mutex_lock(&ls_lock); 627 if (!ls_count) 628 error = threads_start(); 629 if (error) 630 goto out; 631 632 error = new_lockspace(name, namelen, lockspace, flags, lvblen); 633 if (!error) 634 ls_count++; 635 if (error > 0) 636 error = 0; 637 if (!ls_count) 638 threads_stop(); 639 out: 640 mutex_unlock(&ls_lock); 641 return error; 642 } 643 644 /* Return 1 if the lockspace still has active remote locks, 645 * 2 if the lockspace still has active local locks. 646 */ 647 static int lockspace_busy(struct dlm_ls *ls) 648 { 649 int i, lkb_found = 0; 650 struct dlm_lkb *lkb; 651 652 /* NOTE: We check the lockidtbl here rather than the resource table. 653 This is because there may be LKBs queued as ASTs that have been 654 unlinked from their RSBs and are pending deletion once the AST has 655 been delivered */ 656 657 for (i = 0; i < ls->ls_lkbtbl_size; i++) { 658 read_lock(&ls->ls_lkbtbl[i].lock); 659 if (!list_empty(&ls->ls_lkbtbl[i].list)) { 660 lkb_found = 1; 661 list_for_each_entry(lkb, &ls->ls_lkbtbl[i].list, 662 lkb_idtbl_list) { 663 if (!lkb->lkb_nodeid) { 664 read_unlock(&ls->ls_lkbtbl[i].lock); 665 return 2; 666 } 667 } 668 } 669 read_unlock(&ls->ls_lkbtbl[i].lock); 670 } 671 return lkb_found; 672 } 673 674 static int release_lockspace(struct dlm_ls *ls, int force) 675 { 676 struct dlm_lkb *lkb; 677 struct dlm_rsb *rsb; 678 struct list_head *head; 679 int i, busy, rv; 680 681 busy = lockspace_busy(ls); 682 683 spin_lock(&lslist_lock); 684 if (ls->ls_create_count == 1) { 685 if (busy > force) 686 rv = -EBUSY; 687 else { 688 /* remove_lockspace takes ls off lslist */ 689 ls->ls_create_count = 0; 690 rv = 0; 691 } 692 } else if (ls->ls_create_count > 1) { 693 rv = --ls->ls_create_count; 694 } else { 695 rv = -EINVAL; 696 } 697 spin_unlock(&lslist_lock); 698 699 if (rv) { 700 log_debug(ls, "release_lockspace no remove %d", rv); 701 return rv; 702 } 703 704 dlm_device_deregister(ls); 705 706 if (force < 3 && dlm_user_daemon_available()) 707 do_uevent(ls, 0); 708 709 dlm_recoverd_stop(ls); 710 711 remove_lockspace(ls); 712 713 dlm_delete_debug_file(ls); 714 715 dlm_astd_suspend(); 716 717 kfree(ls->ls_recover_buf); 718 719 /* 720 * Free direntry structs. 721 */ 722 723 dlm_dir_clear(ls); 724 kfree(ls->ls_dirtbl); 725 726 /* 727 * Free all lkb's on lkbtbl[] lists. 728 */ 729 730 for (i = 0; i < ls->ls_lkbtbl_size; i++) { 731 head = &ls->ls_lkbtbl[i].list; 732 while (!list_empty(head)) { 733 lkb = list_entry(head->next, struct dlm_lkb, 734 lkb_idtbl_list); 735 736 list_del(&lkb->lkb_idtbl_list); 737 738 dlm_del_ast(lkb); 739 740 if (lkb->lkb_lvbptr && lkb->lkb_flags & DLM_IFL_MSTCPY) 741 dlm_free_lvb(lkb->lkb_lvbptr); 742 743 dlm_free_lkb(lkb); 744 } 745 } 746 dlm_astd_resume(); 747 748 kfree(ls->ls_lkbtbl); 749 750 /* 751 * Free all rsb's on rsbtbl[] lists 752 */ 753 754 for (i = 0; i < ls->ls_rsbtbl_size; i++) { 755 head = &ls->ls_rsbtbl[i].list; 756 while (!list_empty(head)) { 757 rsb = list_entry(head->next, struct dlm_rsb, 758 res_hashchain); 759 760 list_del(&rsb->res_hashchain); 761 dlm_free_rsb(rsb); 762 } 763 764 head = &ls->ls_rsbtbl[i].toss; 765 while (!list_empty(head)) { 766 rsb = list_entry(head->next, struct dlm_rsb, 767 res_hashchain); 768 list_del(&rsb->res_hashchain); 769 dlm_free_rsb(rsb); 770 } 771 } 772 773 kfree(ls->ls_rsbtbl); 774 775 /* 776 * Free structures on any other lists 777 */ 778 779 dlm_purge_requestqueue(ls); 780 kfree(ls->ls_recover_args); 781 dlm_clear_free_entries(ls); 782 dlm_clear_members(ls); 783 dlm_clear_members_gone(ls); 784 kfree(ls->ls_node_array); 785 log_debug(ls, "release_lockspace final free"); 786 kobject_put(&ls->ls_kobj); 787 /* The ls structure will be freed when the kobject is done with */ 788 789 module_put(THIS_MODULE); 790 return 0; 791 } 792 793 /* 794 * Called when a system has released all its locks and is not going to use the 795 * lockspace any longer. We free everything we're managing for this lockspace. 796 * Remaining nodes will go through the recovery process as if we'd died. The 797 * lockspace must continue to function as usual, participating in recoveries, 798 * until this returns. 799 * 800 * Force has 4 possible values: 801 * 0 - don't destroy locksapce if it has any LKBs 802 * 1 - destroy lockspace if it has remote LKBs but not if it has local LKBs 803 * 2 - destroy lockspace regardless of LKBs 804 * 3 - destroy lockspace as part of a forced shutdown 805 */ 806 807 int dlm_release_lockspace(void *lockspace, int force) 808 { 809 struct dlm_ls *ls; 810 int error; 811 812 ls = dlm_find_lockspace_local(lockspace); 813 if (!ls) 814 return -EINVAL; 815 dlm_put_lockspace(ls); 816 817 mutex_lock(&ls_lock); 818 error = release_lockspace(ls, force); 819 if (!error) 820 ls_count--; 821 if (!ls_count) 822 threads_stop(); 823 mutex_unlock(&ls_lock); 824 825 return error; 826 } 827 828 void dlm_stop_lockspaces(void) 829 { 830 struct dlm_ls *ls; 831 832 restart: 833 spin_lock(&lslist_lock); 834 list_for_each_entry(ls, &lslist, ls_list) { 835 if (!test_bit(LSFL_RUNNING, &ls->ls_flags)) 836 continue; 837 spin_unlock(&lslist_lock); 838 log_error(ls, "no userland control daemon, stopping lockspace"); 839 dlm_ls_stop(ls); 840 goto restart; 841 } 842 spin_unlock(&lslist_lock); 843 } 844 845