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