fs/dlm/lockspace.c

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