blob: aa32e5f02493656ef461099a024337793437e245 [file] [log] [blame]
David Teiglande7fd4172006-01-18 09:30:29 +00001/******************************************************************************
2*******************************************************************************
3**
4** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
David Teigland0f8e0d92008-08-06 13:30:24 -05005** Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
David Teiglande7fd4172006-01-18 09:30:29 +00006**
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"
David Teiglandc56b39c2006-04-28 10:51:53 -040024#include "recover.h"
David Teigland2896ee32006-11-27 11:31:22 -060025#include "requestqueue.h"
David Teigland0f8e0d92008-08-06 13:30:24 -050026#include "user.h"
David Teiglande7fd4172006-01-18 09:30:29 +000027
David Teiglande7fd4172006-01-18 09:30:29 +000028static int ls_count;
David Teigland90135922006-01-20 08:47:07 +000029static struct mutex ls_lock;
David Teiglande7fd4172006-01-18 09:30:29 +000030static struct list_head lslist;
31static spinlock_t lslist_lock;
32static struct task_struct * scand_task;
33
34
35static 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
Patrick Caulfielde2de7f52006-11-06 08:53:28 +000040 ls = dlm_find_lockspace_local(ls->ls_local_handle);
41 if (!ls)
42 return -EINVAL;
43
David Teiglande7fd4172006-01-18 09:30:29 +000044 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 }
Patrick Caulfielde2de7f52006-11-06 08:53:28 +000054 dlm_put_lockspace(ls);
David Teiglande7fd4172006-01-18 09:30:29 +000055 return ret;
56}
57
58static 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
66static ssize_t dlm_id_show(struct dlm_ls *ls, char *buf)
67{
David Teiglanda1d144c2006-09-06 17:01:40 -050068 return snprintf(buf, PAGE_SIZE, "%u\n", ls->ls_global_id);
David Teiglande7fd4172006-01-18 09:30:29 +000069}
70
71static 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
David Teiglandc56b39c2006-04-28 10:51:53 -040077static ssize_t dlm_recover_status_show(struct dlm_ls *ls, char *buf)
78{
79 uint32_t status = dlm_recover_status(ls);
David Teiglanda1d144c2006-09-06 17:01:40 -050080 return snprintf(buf, PAGE_SIZE, "%x\n", status);
David Teiglandc56b39c2006-04-28 10:51:53 -040081}
82
David Teiglandfaa0f262006-08-08 17:08:42 -050083static ssize_t dlm_recover_nodeid_show(struct dlm_ls *ls, char *buf)
84{
David Teiglanda1d144c2006-09-06 17:01:40 -050085 return snprintf(buf, PAGE_SIZE, "%d\n", ls->ls_recover_nodeid);
David Teiglandfaa0f262006-08-08 17:08:42 -050086}
87
David Teiglande7fd4172006-01-18 09:30:29 +000088struct 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
94static struct dlm_attr dlm_attr_control = {
95 .attr = {.name = "control", .mode = S_IWUSR},
96 .store = dlm_control_store
97};
98
99static struct dlm_attr dlm_attr_event = {
100 .attr = {.name = "event_done", .mode = S_IWUSR},
101 .store = dlm_event_store
102};
103
104static 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
David Teiglandc56b39c2006-04-28 10:51:53 -0400110static struct dlm_attr dlm_attr_recover_status = {
111 .attr = {.name = "recover_status", .mode = S_IRUGO},
112 .show = dlm_recover_status_show
113};
114
David Teiglandfaa0f262006-08-08 17:08:42 -0500115static struct dlm_attr dlm_attr_recover_nodeid = {
116 .attr = {.name = "recover_nodeid", .mode = S_IRUGO},
117 .show = dlm_recover_nodeid_show
118};
119
David Teiglande7fd4172006-01-18 09:30:29 +0000120static struct attribute *dlm_attrs[] = {
121 &dlm_attr_control.attr,
122 &dlm_attr_event.attr,
123 &dlm_attr_id.attr,
David Teiglandc56b39c2006-04-28 10:51:53 -0400124 &dlm_attr_recover_status.attr,
David Teiglandfaa0f262006-08-08 17:08:42 -0500125 &dlm_attr_recover_nodeid.attr,
David Teiglande7fd4172006-01-18 09:30:29 +0000126 NULL,
127};
128
129static 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
137static 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
Patrick Caulfieldba542e32006-11-02 14:41:23 +0000145static 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
David Teiglande7fd4172006-01-18 09:30:29 +0000151static struct sysfs_ops dlm_attr_ops = {
152 .show = dlm_attr_show,
153 .store = dlm_attr_store,
154};
155
156static struct kobj_type dlm_ktype = {
157 .default_attrs = dlm_attrs,
158 .sysfs_ops = &dlm_attr_ops,
Patrick Caulfieldba542e32006-11-02 14:41:23 +0000159 .release = lockspace_kobj_release,
David Teiglande7fd4172006-01-18 09:30:29 +0000160};
161
Greg Kroah-Hartmand4059362007-10-29 20:13:17 +0100162static struct kset *dlm_kset;
David Teiglande7fd4172006-01-18 09:30:29 +0000163
David Teiglande7fd4172006-01-18 09:30:29 +0000164static 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
David Teigland8b0e7b22007-05-18 09:03:35 -0500173 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
David Teiglande7fd4172006-01-18 09:30:29 +0000178 error = wait_event_interruptible(ls->ls_uevent_wait,
179 test_and_clear_bit(LSFL_UEVENT_WAIT, &ls->ls_flags));
David Teigland8b0e7b22007-05-18 09:03:35 -0500180
181 log_debug(ls, "group event done %d %d", error, ls->ls_uevent_result);
182
David Teiglande7fd4172006-01-18 09:30:29 +0000183 if (error)
184 goto out;
185
186 error = ls->ls_uevent_result;
187 out:
David Teigland8b0e7b22007-05-18 09:03:35 -0500188 if (error)
189 log_error(ls, "group %s failed %d %d", in ? "join" : "leave",
190 error, ls->ls_uevent_result);
David Teiglande7fd4172006-01-18 09:30:29 +0000191 return error;
192}
193
194
Denis Cheng30727172008-02-02 01:53:46 +0800195int __init dlm_lockspace_init(void)
David Teiglande7fd4172006-01-18 09:30:29 +0000196{
David Teiglande7fd4172006-01-18 09:30:29 +0000197 ls_count = 0;
David Teigland90135922006-01-20 08:47:07 +0000198 mutex_init(&ls_lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000199 INIT_LIST_HEAD(&lslist);
200 spin_lock_init(&lslist_lock);
201
Greg Kroah-Hartman0ff21e42007-11-06 10:36:58 -0800202 dlm_kset = kset_create_and_add("dlm", NULL, kernel_kobj);
Greg Kroah-Hartmand4059362007-10-29 20:13:17 +0100203 if (!dlm_kset) {
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700204 printk(KERN_WARNING "%s: can not create kset\n", __func__);
Greg Kroah-Hartmand4059362007-10-29 20:13:17 +0100205 return -ENOMEM;
206 }
207 return 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000208}
209
210void dlm_lockspace_exit(void)
211{
Greg Kroah-Hartmand4059362007-10-29 20:13:17 +0100212 kset_unregister(dlm_kset);
David Teiglande7fd4172006-01-18 09:30:29 +0000213}
214
David Teiglandc1dcf652008-08-18 14:03:25 -0500215static struct dlm_ls *find_ls_to_scan(void)
David Teiglande7fd4172006-01-18 09:30:29 +0000216{
217 struct dlm_ls *ls;
218
David Teiglandc1dcf652008-08-18 14:03:25 -0500219 spin_lock(&lslist_lock);
220 list_for_each_entry(ls, &lslist, ls_list) {
221 if (time_after_eq(jiffies, ls->ls_scan_time +
222 dlm_config.ci_scan_secs * HZ)) {
223 spin_unlock(&lslist_lock);
224 return ls;
225 }
226 }
227 spin_unlock(&lslist_lock);
228 return NULL;
229}
230
231static int dlm_scand(void *data)
232{
233 struct dlm_ls *ls;
234 int timeout_jiffies = dlm_config.ci_scan_secs * HZ;
235
David Teiglande7fd4172006-01-18 09:30:29 +0000236 while (!kthread_should_stop()) {
David Teiglandc1dcf652008-08-18 14:03:25 -0500237 ls = find_ls_to_scan();
238 if (ls) {
David Teigland85e86ed2007-05-18 08:58:15 -0500239 if (dlm_lock_recovery_try(ls)) {
David Teiglandc1dcf652008-08-18 14:03:25 -0500240 ls->ls_scan_time = jiffies;
David Teigland85e86ed2007-05-18 08:58:15 -0500241 dlm_scan_rsbs(ls);
David Teigland3ae1acf2007-05-18 08:59:31 -0500242 dlm_scan_timeout(ls);
David Teigland85e86ed2007-05-18 08:58:15 -0500243 dlm_unlock_recovery(ls);
David Teiglandc1dcf652008-08-18 14:03:25 -0500244 } else {
245 ls->ls_scan_time += HZ;
David Teigland85e86ed2007-05-18 08:58:15 -0500246 }
David Teiglandc1dcf652008-08-18 14:03:25 -0500247 } else {
248 schedule_timeout_interruptible(timeout_jiffies);
David Teigland85e86ed2007-05-18 08:58:15 -0500249 }
David Teiglande7fd4172006-01-18 09:30:29 +0000250 }
251 return 0;
252}
253
254static int dlm_scand_start(void)
255{
256 struct task_struct *p;
257 int error = 0;
258
259 p = kthread_run(dlm_scand, NULL, "dlm_scand");
260 if (IS_ERR(p))
261 error = PTR_ERR(p);
262 else
263 scand_task = p;
264 return error;
265}
266
267static void dlm_scand_stop(void)
268{
269 kthread_stop(scand_task);
270}
271
David Teiglande7fd4172006-01-18 09:30:29 +0000272struct dlm_ls *dlm_find_lockspace_global(uint32_t id)
273{
274 struct dlm_ls *ls;
275
276 spin_lock(&lslist_lock);
277
278 list_for_each_entry(ls, &lslist, ls_list) {
279 if (ls->ls_global_id == id) {
280 ls->ls_count++;
281 goto out;
282 }
283 }
284 ls = NULL;
285 out:
286 spin_unlock(&lslist_lock);
287 return ls;
288}
289
David Teigland597d0ca2006-07-12 16:44:04 -0500290struct dlm_ls *dlm_find_lockspace_local(dlm_lockspace_t *lockspace)
David Teiglande7fd4172006-01-18 09:30:29 +0000291{
David Teigland597d0ca2006-07-12 16:44:04 -0500292 struct dlm_ls *ls;
David Teiglande7fd4172006-01-18 09:30:29 +0000293
294 spin_lock(&lslist_lock);
David Teigland597d0ca2006-07-12 16:44:04 -0500295 list_for_each_entry(ls, &lslist, ls_list) {
296 if (ls->ls_local_handle == lockspace) {
297 ls->ls_count++;
298 goto out;
299 }
300 }
301 ls = NULL;
302 out:
303 spin_unlock(&lslist_lock);
304 return ls;
305}
306
307struct dlm_ls *dlm_find_lockspace_device(int minor)
308{
309 struct dlm_ls *ls;
310
311 spin_lock(&lslist_lock);
312 list_for_each_entry(ls, &lslist, ls_list) {
313 if (ls->ls_device.minor == minor) {
314 ls->ls_count++;
315 goto out;
316 }
317 }
318 ls = NULL;
319 out:
David Teiglande7fd4172006-01-18 09:30:29 +0000320 spin_unlock(&lslist_lock);
321 return ls;
322}
323
324void dlm_put_lockspace(struct dlm_ls *ls)
325{
326 spin_lock(&lslist_lock);
327 ls->ls_count--;
328 spin_unlock(&lslist_lock);
329}
330
331static void remove_lockspace(struct dlm_ls *ls)
332{
333 for (;;) {
334 spin_lock(&lslist_lock);
335 if (ls->ls_count == 0) {
David Teigland0f8e0d92008-08-06 13:30:24 -0500336 WARN_ON(ls->ls_create_count != 0);
David Teiglande7fd4172006-01-18 09:30:29 +0000337 list_del(&ls->ls_list);
338 spin_unlock(&lslist_lock);
339 return;
340 }
341 spin_unlock(&lslist_lock);
342 ssleep(1);
343 }
344}
345
346static int threads_start(void)
347{
348 int error;
349
350 /* Thread which process lock requests for all lockspace's */
351 error = dlm_astd_start();
352 if (error) {
353 log_print("cannot start dlm_astd thread %d", error);
354 goto fail;
355 }
356
357 error = dlm_scand_start();
358 if (error) {
359 log_print("cannot start dlm_scand thread %d", error);
360 goto astd_fail;
361 }
362
363 /* Thread for sending/receiving messages for all lockspace's */
364 error = dlm_lowcomms_start();
365 if (error) {
366 log_print("cannot start dlm lowcomms %d", error);
367 goto scand_fail;
368 }
369
370 return 0;
371
372 scand_fail:
373 dlm_scand_stop();
374 astd_fail:
375 dlm_astd_stop();
376 fail:
377 return error;
378}
379
380static void threads_stop(void)
381{
382 dlm_scand_stop();
383 dlm_lowcomms_stop();
384 dlm_astd_stop();
385}
386
387static int new_lockspace(char *name, int namelen, void **lockspace,
388 uint32_t flags, int lvblen)
389{
390 struct dlm_ls *ls;
David Teigland0f8e0d92008-08-06 13:30:24 -0500391 int i, size, error;
David Teigland79d72b52007-05-18 09:02:20 -0500392 int do_unreg = 0;
David Teiglande7fd4172006-01-18 09:30:29 +0000393
394 if (namelen > DLM_LOCKSPACE_LEN)
395 return -EINVAL;
396
397 if (!lvblen || (lvblen % 8))
398 return -EINVAL;
399
400 if (!try_module_get(THIS_MODULE))
401 return -EINVAL;
402
David Teiglanddc68c7e2008-08-18 11:43:30 -0500403 if (!dlm_user_daemon_available()) {
404 module_put(THIS_MODULE);
405 return -EUNATCH;
406 }
407
David Teigland0f8e0d92008-08-06 13:30:24 -0500408 error = 0;
409
410 spin_lock(&lslist_lock);
411 list_for_each_entry(ls, &lslist, ls_list) {
412 WARN_ON(ls->ls_create_count <= 0);
413 if (ls->ls_namelen != namelen)
414 continue;
415 if (memcmp(ls->ls_name, name, namelen))
416 continue;
417 if (flags & DLM_LSFL_NEWEXCL) {
418 error = -EEXIST;
419 break;
420 }
421 ls->ls_create_count++;
David Teiglande7fd4172006-01-18 09:30:29 +0000422 module_put(THIS_MODULE);
David Teigland0f8e0d92008-08-06 13:30:24 -0500423 error = 1; /* not an error, return 0 */
424 break;
David Teiglande7fd4172006-01-18 09:30:29 +0000425 }
David Teigland0f8e0d92008-08-06 13:30:24 -0500426 spin_unlock(&lslist_lock);
427
428 if (error < 0)
429 goto out;
430 if (error)
431 goto ret_zero;
432
433 error = -ENOMEM;
David Teiglande7fd4172006-01-18 09:30:29 +0000434
David Teigland90135922006-01-20 08:47:07 +0000435 ls = kzalloc(sizeof(struct dlm_ls) + namelen, GFP_KERNEL);
David Teiglande7fd4172006-01-18 09:30:29 +0000436 if (!ls)
437 goto out;
David Teiglande7fd4172006-01-18 09:30:29 +0000438 memcpy(ls->ls_name, name, namelen);
439 ls->ls_namelen = namelen;
David Teiglande7fd4172006-01-18 09:30:29 +0000440 ls->ls_lvblen = lvblen;
441 ls->ls_count = 0;
442 ls->ls_flags = 0;
David Teiglandc1dcf652008-08-18 14:03:25 -0500443 ls->ls_scan_time = jiffies;
David Teiglande7fd4172006-01-18 09:30:29 +0000444
David Teigland3ae1acf2007-05-18 08:59:31 -0500445 if (flags & DLM_LSFL_TIMEWARN)
446 set_bit(LSFL_TIMEWARN, &ls->ls_flags);
David Teigland3ae1acf2007-05-18 08:59:31 -0500447
Patrick Caulfield44f487a2007-06-06 09:21:22 -0500448 if (flags & DLM_LSFL_FS)
449 ls->ls_allocation = GFP_NOFS;
450 else
451 ls->ls_allocation = GFP_KERNEL;
452
David Teiglandfad59c12007-06-11 10:47:18 -0500453 /* ls_exflags are forced to match among nodes, and we don't
David Teigland0f8e0d92008-08-06 13:30:24 -0500454 need to require all nodes to have some flags set */
455 ls->ls_exflags = (flags & ~(DLM_LSFL_TIMEWARN | DLM_LSFL_FS |
456 DLM_LSFL_NEWEXCL));
David Teiglandfad59c12007-06-11 10:47:18 -0500457
David Teigland68c817a2007-01-09 09:41:48 -0600458 size = dlm_config.ci_rsbtbl_size;
David Teiglande7fd4172006-01-18 09:30:29 +0000459 ls->ls_rsbtbl_size = size;
460
461 ls->ls_rsbtbl = kmalloc(sizeof(struct dlm_rsbtable) * size, GFP_KERNEL);
462 if (!ls->ls_rsbtbl)
463 goto out_lsfree;
464 for (i = 0; i < size; i++) {
465 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].list);
466 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].toss);
David Teiglandc7be7612009-01-07 16:50:41 -0600467 spin_lock_init(&ls->ls_rsbtbl[i].lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000468 }
469
David Teigland68c817a2007-01-09 09:41:48 -0600470 size = dlm_config.ci_lkbtbl_size;
David Teiglande7fd4172006-01-18 09:30:29 +0000471 ls->ls_lkbtbl_size = size;
472
473 ls->ls_lkbtbl = kmalloc(sizeof(struct dlm_lkbtable) * size, GFP_KERNEL);
474 if (!ls->ls_lkbtbl)
475 goto out_rsbfree;
476 for (i = 0; i < size; i++) {
477 INIT_LIST_HEAD(&ls->ls_lkbtbl[i].list);
478 rwlock_init(&ls->ls_lkbtbl[i].lock);
479 ls->ls_lkbtbl[i].counter = 1;
480 }
481
David Teigland68c817a2007-01-09 09:41:48 -0600482 size = dlm_config.ci_dirtbl_size;
David Teiglande7fd4172006-01-18 09:30:29 +0000483 ls->ls_dirtbl_size = size;
484
485 ls->ls_dirtbl = kmalloc(sizeof(struct dlm_dirtable) * size, GFP_KERNEL);
486 if (!ls->ls_dirtbl)
487 goto out_lkbfree;
488 for (i = 0; i < size; i++) {
489 INIT_LIST_HEAD(&ls->ls_dirtbl[i].list);
490 rwlock_init(&ls->ls_dirtbl[i].lock);
491 }
492
493 INIT_LIST_HEAD(&ls->ls_waiters);
David Teigland90135922006-01-20 08:47:07 +0000494 mutex_init(&ls->ls_waiters_mutex);
David Teiglandef0c2bb2007-03-28 09:56:46 -0500495 INIT_LIST_HEAD(&ls->ls_orphans);
496 mutex_init(&ls->ls_orphans_mutex);
David Teigland3ae1acf2007-05-18 08:59:31 -0500497 INIT_LIST_HEAD(&ls->ls_timeout);
498 mutex_init(&ls->ls_timeout_mutex);
David Teiglande7fd4172006-01-18 09:30:29 +0000499
500 INIT_LIST_HEAD(&ls->ls_nodes);
501 INIT_LIST_HEAD(&ls->ls_nodes_gone);
502 ls->ls_num_nodes = 0;
503 ls->ls_low_nodeid = 0;
504 ls->ls_total_weight = 0;
505 ls->ls_node_array = NULL;
506
507 memset(&ls->ls_stub_rsb, 0, sizeof(struct dlm_rsb));
508 ls->ls_stub_rsb.res_ls = ls;
509
David Teigland5de63192006-07-25 13:44:31 -0500510 ls->ls_debug_rsb_dentry = NULL;
511 ls->ls_debug_waiters_dentry = NULL;
David Teiglande7fd4172006-01-18 09:30:29 +0000512
513 init_waitqueue_head(&ls->ls_uevent_wait);
514 ls->ls_uevent_result = 0;
David Teigland8b0e7b22007-05-18 09:03:35 -0500515 init_completion(&ls->ls_members_done);
516 ls->ls_members_result = -1;
David Teiglande7fd4172006-01-18 09:30:29 +0000517
518 ls->ls_recoverd_task = NULL;
David Teigland90135922006-01-20 08:47:07 +0000519 mutex_init(&ls->ls_recoverd_active);
David Teiglande7fd4172006-01-18 09:30:29 +0000520 spin_lock_init(&ls->ls_recover_lock);
David Teigland98f176f2006-11-27 13:19:28 -0600521 spin_lock_init(&ls->ls_rcom_spin);
522 get_random_bytes(&ls->ls_rcom_seq, sizeof(uint64_t));
David Teiglande7fd4172006-01-18 09:30:29 +0000523 ls->ls_recover_status = 0;
524 ls->ls_recover_seq = 0;
525 ls->ls_recover_args = NULL;
526 init_rwsem(&ls->ls_in_recovery);
David Teiglandc36258b2007-09-27 15:53:38 -0500527 init_rwsem(&ls->ls_recv_active);
David Teiglande7fd4172006-01-18 09:30:29 +0000528 INIT_LIST_HEAD(&ls->ls_requestqueue);
David Teigland90135922006-01-20 08:47:07 +0000529 mutex_init(&ls->ls_requestqueue_mutex);
David Teigland597d0ca2006-07-12 16:44:04 -0500530 mutex_init(&ls->ls_clear_proc_locks);
David Teiglande7fd4172006-01-18 09:30:29 +0000531
David Teigland68c817a2007-01-09 09:41:48 -0600532 ls->ls_recover_buf = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
David Teiglande7fd4172006-01-18 09:30:29 +0000533 if (!ls->ls_recover_buf)
534 goto out_dirfree;
535
536 INIT_LIST_HEAD(&ls->ls_recover_list);
537 spin_lock_init(&ls->ls_recover_list_lock);
538 ls->ls_recover_list_count = 0;
David Teigland597d0ca2006-07-12 16:44:04 -0500539 ls->ls_local_handle = ls;
David Teiglande7fd4172006-01-18 09:30:29 +0000540 init_waitqueue_head(&ls->ls_wait_general);
541 INIT_LIST_HEAD(&ls->ls_root_list);
542 init_rwsem(&ls->ls_root_sem);
543
544 down_write(&ls->ls_in_recovery);
545
David Teigland5f88f1e2006-08-24 14:47:20 -0500546 spin_lock(&lslist_lock);
David Teigland0f8e0d92008-08-06 13:30:24 -0500547 ls->ls_create_count = 1;
David Teigland5f88f1e2006-08-24 14:47:20 -0500548 list_add(&ls->ls_list, &lslist);
549 spin_unlock(&lslist_lock);
550
551 /* needs to find ls in lslist */
David Teiglande7fd4172006-01-18 09:30:29 +0000552 error = dlm_recoverd_start(ls);
553 if (error) {
554 log_error(ls, "can't start dlm_recoverd %d", error);
David Teigland79d72b52007-05-18 09:02:20 -0500555 goto out_delist;
David Teiglande7fd4172006-01-18 09:30:29 +0000556 }
557
Greg Kroah-Hartman901195e2007-12-17 15:54:39 -0400558 ls->ls_kobj.kset = dlm_kset;
559 error = kobject_init_and_add(&ls->ls_kobj, &dlm_ktype, NULL,
560 "%s", ls->ls_name);
David Teiglande7fd4172006-01-18 09:30:29 +0000561 if (error)
David Teigland79d72b52007-05-18 09:02:20 -0500562 goto out_stop;
Greg Kroah-Hartman901195e2007-12-17 15:54:39 -0400563 kobject_uevent(&ls->ls_kobj, KOBJ_ADD);
David Teigland79d72b52007-05-18 09:02:20 -0500564
565 /* let kobject handle freeing of ls if there's an error */
566 do_unreg = 1;
David Teiglande7fd4172006-01-18 09:30:29 +0000567
David Teigland8b0e7b22007-05-18 09:03:35 -0500568 /* This uevent triggers dlm_controld in userspace to add us to the
569 group of nodes that are members of this lockspace (managed by the
570 cluster infrastructure.) Once it's done that, it tells us who the
571 current lockspace members are (via configfs) and then tells the
572 lockspace to start running (via sysfs) in dlm_ls_start(). */
573
David Teiglande7fd4172006-01-18 09:30:29 +0000574 error = do_uevent(ls, 1);
575 if (error)
David Teigland79d72b52007-05-18 09:02:20 -0500576 goto out_stop;
577
David Teigland8b0e7b22007-05-18 09:03:35 -0500578 wait_for_completion(&ls->ls_members_done);
579 error = ls->ls_members_result;
580 if (error)
581 goto out_members;
582
David Teigland79d72b52007-05-18 09:02:20 -0500583 dlm_create_debug_file(ls);
584
585 log_debug(ls, "join complete");
David Teigland0f8e0d92008-08-06 13:30:24 -0500586 ret_zero:
David Teiglande7fd4172006-01-18 09:30:29 +0000587 *lockspace = ls;
588 return 0;
589
David Teigland8b0e7b22007-05-18 09:03:35 -0500590 out_members:
591 do_uevent(ls, 0);
592 dlm_clear_members(ls);
593 kfree(ls->ls_node_array);
David Teigland79d72b52007-05-18 09:02:20 -0500594 out_stop:
David Teigland5f88f1e2006-08-24 14:47:20 -0500595 dlm_recoverd_stop(ls);
David Teigland79d72b52007-05-18 09:02:20 -0500596 out_delist:
David Teiglande7fd4172006-01-18 09:30:29 +0000597 spin_lock(&lslist_lock);
598 list_del(&ls->ls_list);
599 spin_unlock(&lslist_lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000600 kfree(ls->ls_recover_buf);
601 out_dirfree:
602 kfree(ls->ls_dirtbl);
603 out_lkbfree:
604 kfree(ls->ls_lkbtbl);
605 out_rsbfree:
606 kfree(ls->ls_rsbtbl);
607 out_lsfree:
David Teigland79d72b52007-05-18 09:02:20 -0500608 if (do_unreg)
Greg Kroah-Hartman197b12d2007-12-20 08:13:05 -0800609 kobject_put(&ls->ls_kobj);
David Teigland79d72b52007-05-18 09:02:20 -0500610 else
611 kfree(ls);
David Teiglande7fd4172006-01-18 09:30:29 +0000612 out:
613 module_put(THIS_MODULE);
614 return error;
615}
616
617int dlm_new_lockspace(char *name, int namelen, void **lockspace,
618 uint32_t flags, int lvblen)
619{
620 int error = 0;
621
David Teigland90135922006-01-20 08:47:07 +0000622 mutex_lock(&ls_lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000623 if (!ls_count)
624 error = threads_start();
625 if (error)
626 goto out;
627
628 error = new_lockspace(name, namelen, lockspace, flags, lvblen);
629 if (!error)
630 ls_count++;
David Teigland8b0e7b22007-05-18 09:03:35 -0500631 else if (!ls_count)
632 threads_stop();
David Teiglande7fd4172006-01-18 09:30:29 +0000633 out:
David Teigland90135922006-01-20 08:47:07 +0000634 mutex_unlock(&ls_lock);
David Teiglande7fd4172006-01-18 09:30:29 +0000635 return error;
636}
637
638/* Return 1 if the lockspace still has active remote locks,
639 * 2 if the lockspace still has active local locks.
640 */
641static int lockspace_busy(struct dlm_ls *ls)
642{
643 int i, lkb_found = 0;
644 struct dlm_lkb *lkb;
645
646 /* NOTE: We check the lockidtbl here rather than the resource table.
647 This is because there may be LKBs queued as ASTs that have been
648 unlinked from their RSBs and are pending deletion once the AST has
649 been delivered */
650
651 for (i = 0; i < ls->ls_lkbtbl_size; i++) {
652 read_lock(&ls->ls_lkbtbl[i].lock);
653 if (!list_empty(&ls->ls_lkbtbl[i].list)) {
654 lkb_found = 1;
655 list_for_each_entry(lkb, &ls->ls_lkbtbl[i].list,
656 lkb_idtbl_list) {
657 if (!lkb->lkb_nodeid) {
658 read_unlock(&ls->ls_lkbtbl[i].lock);
659 return 2;
660 }
661 }
662 }
663 read_unlock(&ls->ls_lkbtbl[i].lock);
664 }
665 return lkb_found;
666}
667
668static int release_lockspace(struct dlm_ls *ls, int force)
669{
670 struct dlm_lkb *lkb;
671 struct dlm_rsb *rsb;
672 struct list_head *head;
David Teigland0f8e0d92008-08-06 13:30:24 -0500673 int i, busy, rv;
David Teiglande7fd4172006-01-18 09:30:29 +0000674
David Teigland0f8e0d92008-08-06 13:30:24 -0500675 busy = lockspace_busy(ls);
676
677 spin_lock(&lslist_lock);
678 if (ls->ls_create_count == 1) {
679 if (busy > force)
680 rv = -EBUSY;
681 else {
682 /* remove_lockspace takes ls off lslist */
683 ls->ls_create_count = 0;
684 rv = 0;
685 }
686 } else if (ls->ls_create_count > 1) {
687 rv = --ls->ls_create_count;
688 } else {
689 rv = -EINVAL;
690 }
691 spin_unlock(&lslist_lock);
692
693 if (rv) {
694 log_debug(ls, "release_lockspace no remove %d", rv);
695 return rv;
696 }
697
698 dlm_device_deregister(ls);
David Teiglande7fd4172006-01-18 09:30:29 +0000699
David Teiglanddc68c7e2008-08-18 11:43:30 -0500700 if (force < 3 && dlm_user_daemon_available())
David Teiglande7fd4172006-01-18 09:30:29 +0000701 do_uevent(ls, 0);
702
703 dlm_recoverd_stop(ls);
704
705 remove_lockspace(ls);
706
707 dlm_delete_debug_file(ls);
708
709 dlm_astd_suspend();
710
711 kfree(ls->ls_recover_buf);
712
713 /*
714 * Free direntry structs.
715 */
716
717 dlm_dir_clear(ls);
718 kfree(ls->ls_dirtbl);
719
720 /*
721 * Free all lkb's on lkbtbl[] lists.
722 */
723
724 for (i = 0; i < ls->ls_lkbtbl_size; i++) {
725 head = &ls->ls_lkbtbl[i].list;
726 while (!list_empty(head)) {
727 lkb = list_entry(head->next, struct dlm_lkb,
728 lkb_idtbl_list);
729
730 list_del(&lkb->lkb_idtbl_list);
731
732 dlm_del_ast(lkb);
733
734 if (lkb->lkb_lvbptr && lkb->lkb_flags & DLM_IFL_MSTCPY)
David Teigland52bda2b2007-11-07 09:06:49 -0600735 dlm_free_lvb(lkb->lkb_lvbptr);
David Teiglande7fd4172006-01-18 09:30:29 +0000736
David Teigland52bda2b2007-11-07 09:06:49 -0600737 dlm_free_lkb(lkb);
David Teiglande7fd4172006-01-18 09:30:29 +0000738 }
739 }
740 dlm_astd_resume();
741
742 kfree(ls->ls_lkbtbl);
743
744 /*
745 * Free all rsb's on rsbtbl[] lists
746 */
747
748 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
749 head = &ls->ls_rsbtbl[i].list;
750 while (!list_empty(head)) {
751 rsb = list_entry(head->next, struct dlm_rsb,
752 res_hashchain);
753
754 list_del(&rsb->res_hashchain);
David Teigland52bda2b2007-11-07 09:06:49 -0600755 dlm_free_rsb(rsb);
David Teiglande7fd4172006-01-18 09:30:29 +0000756 }
757
758 head = &ls->ls_rsbtbl[i].toss;
759 while (!list_empty(head)) {
760 rsb = list_entry(head->next, struct dlm_rsb,
761 res_hashchain);
762 list_del(&rsb->res_hashchain);
David Teigland52bda2b2007-11-07 09:06:49 -0600763 dlm_free_rsb(rsb);
David Teiglande7fd4172006-01-18 09:30:29 +0000764 }
765 }
766
767 kfree(ls->ls_rsbtbl);
768
769 /*
770 * Free structures on any other lists
771 */
772
David Teigland2896ee32006-11-27 11:31:22 -0600773 dlm_purge_requestqueue(ls);
David Teiglande7fd4172006-01-18 09:30:29 +0000774 kfree(ls->ls_recover_args);
775 dlm_clear_free_entries(ls);
776 dlm_clear_members(ls);
777 dlm_clear_members_gone(ls);
778 kfree(ls->ls_node_array);
David Teigland0f8e0d92008-08-06 13:30:24 -0500779 log_debug(ls, "release_lockspace final free");
Greg Kroah-Hartman197b12d2007-12-20 08:13:05 -0800780 kobject_put(&ls->ls_kobj);
David Teigland79d72b52007-05-18 09:02:20 -0500781 /* The ls structure will be freed when the kobject is done with */
David Teiglande7fd4172006-01-18 09:30:29 +0000782
David Teiglande7fd4172006-01-18 09:30:29 +0000783 module_put(THIS_MODULE);
784 return 0;
785}
786
787/*
788 * Called when a system has released all its locks and is not going to use the
789 * lockspace any longer. We free everything we're managing for this lockspace.
790 * Remaining nodes will go through the recovery process as if we'd died. The
791 * lockspace must continue to function as usual, participating in recoveries,
792 * until this returns.
793 *
794 * Force has 4 possible values:
795 * 0 - don't destroy locksapce if it has any LKBs
796 * 1 - destroy lockspace if it has remote LKBs but not if it has local LKBs
797 * 2 - destroy lockspace regardless of LKBs
798 * 3 - destroy lockspace as part of a forced shutdown
799 */
800
801int dlm_release_lockspace(void *lockspace, int force)
802{
803 struct dlm_ls *ls;
David Teigland0f8e0d92008-08-06 13:30:24 -0500804 int error;
David Teiglande7fd4172006-01-18 09:30:29 +0000805
806 ls = dlm_find_lockspace_local(lockspace);
807 if (!ls)
808 return -EINVAL;
809 dlm_put_lockspace(ls);
David Teigland0f8e0d92008-08-06 13:30:24 -0500810
811 mutex_lock(&ls_lock);
812 error = release_lockspace(ls, force);
813 if (!error)
814 ls_count--;
David Teigland278afcb2008-11-13 13:22:34 -0600815 if (!ls_count)
David Teigland0f8e0d92008-08-06 13:30:24 -0500816 threads_stop();
817 mutex_unlock(&ls_lock);
818
819 return error;
David Teiglande7fd4172006-01-18 09:30:29 +0000820}
821
David Teiglanddc68c7e2008-08-18 11:43:30 -0500822void dlm_stop_lockspaces(void)
823{
824 struct dlm_ls *ls;
825
826 restart:
827 spin_lock(&lslist_lock);
828 list_for_each_entry(ls, &lslist, ls_list) {
829 if (!test_bit(LSFL_RUNNING, &ls->ls_flags))
830 continue;
831 spin_unlock(&lslist_lock);
832 log_error(ls, "no userland control daemon, stopping lockspace");
833 dlm_ls_stop(ls);
834 goto restart;
835 }
836 spin_unlock(&lslist_lock);
837}
838