1 /******************************************************************************
2 *******************************************************************************
4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
5 ** Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
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.
11 *******************************************************************************
12 ******************************************************************************/
14 #include "dlm_internal.h"
15 #include "lockspace.h"
25 #include "requestqueue.h"
27 #ifdef CONFIG_DLM_DEBUG
28 int dlm_create_debug_file(struct dlm_ls *ls);
29 void dlm_delete_debug_file(struct dlm_ls *ls);
31 static inline int dlm_create_debug_file(struct dlm_ls *ls) { return 0; }
32 static inline void dlm_delete_debug_file(struct dlm_ls *ls) { }
36 static struct mutex ls_lock;
37 static struct list_head lslist;
38 static spinlock_t lslist_lock;
39 static struct task_struct * scand_task;
42 static ssize_t dlm_control_store(struct dlm_ls *ls, const char *buf, size_t len)
45 int n = simple_strtol(buf, NULL, 0);
47 ls = dlm_find_lockspace_local(ls->ls_local_handle);
61 dlm_put_lockspace(ls);
65 static ssize_t dlm_event_store(struct dlm_ls *ls, const char *buf, size_t len)
67 ls->ls_uevent_result = simple_strtol(buf, NULL, 0);
68 set_bit(LSFL_UEVENT_WAIT, &ls->ls_flags);
69 wake_up(&ls->ls_uevent_wait);
73 static ssize_t dlm_id_show(struct dlm_ls *ls, char *buf)
75 return snprintf(buf, PAGE_SIZE, "%u\n", ls->ls_global_id);
78 static ssize_t dlm_id_store(struct dlm_ls *ls, const char *buf, size_t len)
80 ls->ls_global_id = simple_strtoul(buf, NULL, 0);
84 static ssize_t dlm_recover_status_show(struct dlm_ls *ls, char *buf)
86 uint32_t status = dlm_recover_status(ls);
87 return snprintf(buf, PAGE_SIZE, "%x\n", status);
90 static ssize_t dlm_recover_nodeid_show(struct dlm_ls *ls, char *buf)
92 return snprintf(buf, PAGE_SIZE, "%d\n", ls->ls_recover_nodeid);
96 struct attribute attr;
97 ssize_t (*show)(struct dlm_ls *, char *);
98 ssize_t (*store)(struct dlm_ls *, const char *, size_t);
101 static struct dlm_attr dlm_attr_control = {
102 .attr = {.name = "control", .mode = S_IWUSR},
103 .store = dlm_control_store
106 static struct dlm_attr dlm_attr_event = {
107 .attr = {.name = "event_done", .mode = S_IWUSR},
108 .store = dlm_event_store
111 static struct dlm_attr dlm_attr_id = {
112 .attr = {.name = "id", .mode = S_IRUGO | S_IWUSR},
114 .store = dlm_id_store
117 static struct dlm_attr dlm_attr_recover_status = {
118 .attr = {.name = "recover_status", .mode = S_IRUGO},
119 .show = dlm_recover_status_show
122 static struct dlm_attr dlm_attr_recover_nodeid = {
123 .attr = {.name = "recover_nodeid", .mode = S_IRUGO},
124 .show = dlm_recover_nodeid_show
127 static struct attribute *dlm_attrs[] = {
128 &dlm_attr_control.attr,
129 &dlm_attr_event.attr,
131 &dlm_attr_recover_status.attr,
132 &dlm_attr_recover_nodeid.attr,
136 static ssize_t dlm_attr_show(struct kobject *kobj, struct attribute *attr,
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->show ? a->show(ls, buf) : 0;
144 static ssize_t dlm_attr_store(struct kobject *kobj, struct attribute *attr,
145 const char *buf, size_t len)
147 struct dlm_ls *ls = container_of(kobj, struct dlm_ls, ls_kobj);
148 struct dlm_attr *a = container_of(attr, struct dlm_attr, attr);
149 return a->store ? a->store(ls, buf, len) : len;
152 static void lockspace_kobj_release(struct kobject *k)
154 struct dlm_ls *ls = container_of(k, struct dlm_ls, ls_kobj);
158 static struct sysfs_ops dlm_attr_ops = {
159 .show = dlm_attr_show,
160 .store = dlm_attr_store,
163 static struct kobj_type dlm_ktype = {
164 .default_attrs = dlm_attrs,
165 .sysfs_ops = &dlm_attr_ops,
166 .release = lockspace_kobj_release,
169 static struct kset dlm_kset = {
170 .kobj = {.name = "dlm",},
174 static int kobject_setup(struct dlm_ls *ls)
176 char lsname[DLM_LOCKSPACE_LEN];
179 memset(lsname, 0, DLM_LOCKSPACE_LEN);
180 snprintf(lsname, DLM_LOCKSPACE_LEN, "%s", ls->ls_name);
182 error = kobject_set_name(&ls->ls_kobj, "%s", lsname);
186 ls->ls_kobj.kset = &dlm_kset;
187 ls->ls_kobj.ktype = &dlm_ktype;
191 static int do_uevent(struct dlm_ls *ls, int in)
196 kobject_uevent(&ls->ls_kobj, KOBJ_ONLINE);
198 kobject_uevent(&ls->ls_kobj, KOBJ_OFFLINE);
200 error = wait_event_interruptible(ls->ls_uevent_wait,
201 test_and_clear_bit(LSFL_UEVENT_WAIT, &ls->ls_flags));
205 error = ls->ls_uevent_result;
211 int dlm_lockspace_init(void)
216 mutex_init(&ls_lock);
217 INIT_LIST_HEAD(&lslist);
218 spin_lock_init(&lslist_lock);
220 kobj_set_kset_s(&dlm_kset, kernel_subsys);
221 error = kset_register(&dlm_kset);
223 printk("dlm_lockspace_init: cannot register kset %d\n", error);
227 void dlm_lockspace_exit(void)
229 kset_unregister(&dlm_kset);
232 static int dlm_scand(void *data)
236 while (!kthread_should_stop()) {
237 list_for_each_entry(ls, &lslist, ls_list) {
238 if (dlm_lock_recovery_try(ls)) {
240 dlm_scan_timeout(ls);
241 dlm_unlock_recovery(ls);
244 schedule_timeout_interruptible(dlm_config.ci_scan_secs * HZ);
249 static int dlm_scand_start(void)
251 struct task_struct *p;
254 p = kthread_run(dlm_scand, NULL, "dlm_scand");
262 static void dlm_scand_stop(void)
264 kthread_stop(scand_task);
267 static struct dlm_ls *dlm_find_lockspace_name(char *name, int namelen)
271 spin_lock(&lslist_lock);
273 list_for_each_entry(ls, &lslist, ls_list) {
274 if (ls->ls_namelen == namelen &&
275 memcmp(ls->ls_name, name, namelen) == 0)
280 spin_unlock(&lslist_lock);
284 struct dlm_ls *dlm_find_lockspace_global(uint32_t id)
288 spin_lock(&lslist_lock);
290 list_for_each_entry(ls, &lslist, ls_list) {
291 if (ls->ls_global_id == id) {
298 spin_unlock(&lslist_lock);
302 struct dlm_ls *dlm_find_lockspace_local(dlm_lockspace_t *lockspace)
306 spin_lock(&lslist_lock);
307 list_for_each_entry(ls, &lslist, ls_list) {
308 if (ls->ls_local_handle == lockspace) {
315 spin_unlock(&lslist_lock);
319 struct dlm_ls *dlm_find_lockspace_device(int minor)
323 spin_lock(&lslist_lock);
324 list_for_each_entry(ls, &lslist, ls_list) {
325 if (ls->ls_device.minor == minor) {
332 spin_unlock(&lslist_lock);
336 void dlm_put_lockspace(struct dlm_ls *ls)
338 spin_lock(&lslist_lock);
340 spin_unlock(&lslist_lock);
343 static void remove_lockspace(struct dlm_ls *ls)
346 spin_lock(&lslist_lock);
347 if (ls->ls_count == 0) {
348 list_del(&ls->ls_list);
349 spin_unlock(&lslist_lock);
352 spin_unlock(&lslist_lock);
357 static int threads_start(void)
361 /* Thread which process lock requests for all lockspace's */
362 error = dlm_astd_start();
364 log_print("cannot start dlm_astd thread %d", error);
368 error = dlm_scand_start();
370 log_print("cannot start dlm_scand thread %d", error);
374 /* Thread for sending/receiving messages for all lockspace's */
375 error = dlm_lowcomms_start();
377 log_print("cannot start dlm lowcomms %d", error);
391 static void threads_stop(void)
398 static int new_lockspace(char *name, int namelen, void **lockspace,
399 uint32_t flags, int lvblen)
402 int i, size, error = -ENOMEM;
404 if (namelen > DLM_LOCKSPACE_LEN)
407 if (!lvblen || (lvblen % 8))
410 if (!try_module_get(THIS_MODULE))
413 ls = dlm_find_lockspace_name(name, namelen);
416 module_put(THIS_MODULE);
420 ls = kzalloc(sizeof(struct dlm_ls) + namelen, GFP_KERNEL);
423 memcpy(ls->ls_name, name, namelen);
424 ls->ls_namelen = namelen;
425 ls->ls_lvblen = lvblen;
429 /* ls_exflags are forced to match among nodes, and we don't
430 need to require all nodes to have TIMEWARN active */
431 if (flags & DLM_LSFL_TIMEWARN)
432 set_bit(LSFL_TIMEWARN, &ls->ls_flags);
433 ls->ls_exflags = (flags & ~DLM_LSFL_TIMEWARN);
435 size = dlm_config.ci_rsbtbl_size;
436 ls->ls_rsbtbl_size = size;
438 ls->ls_rsbtbl = kmalloc(sizeof(struct dlm_rsbtable) * size, GFP_KERNEL);
441 for (i = 0; i < size; i++) {
442 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].list);
443 INIT_LIST_HEAD(&ls->ls_rsbtbl[i].toss);
444 rwlock_init(&ls->ls_rsbtbl[i].lock);
447 size = dlm_config.ci_lkbtbl_size;
448 ls->ls_lkbtbl_size = size;
450 ls->ls_lkbtbl = kmalloc(sizeof(struct dlm_lkbtable) * size, GFP_KERNEL);
453 for (i = 0; i < size; i++) {
454 INIT_LIST_HEAD(&ls->ls_lkbtbl[i].list);
455 rwlock_init(&ls->ls_lkbtbl[i].lock);
456 ls->ls_lkbtbl[i].counter = 1;
459 size = dlm_config.ci_dirtbl_size;
460 ls->ls_dirtbl_size = size;
462 ls->ls_dirtbl = kmalloc(sizeof(struct dlm_dirtable) * size, GFP_KERNEL);
465 for (i = 0; i < size; i++) {
466 INIT_LIST_HEAD(&ls->ls_dirtbl[i].list);
467 rwlock_init(&ls->ls_dirtbl[i].lock);
470 INIT_LIST_HEAD(&ls->ls_waiters);
471 mutex_init(&ls->ls_waiters_mutex);
472 INIT_LIST_HEAD(&ls->ls_orphans);
473 mutex_init(&ls->ls_orphans_mutex);
474 INIT_LIST_HEAD(&ls->ls_timeout);
475 mutex_init(&ls->ls_timeout_mutex);
477 INIT_LIST_HEAD(&ls->ls_nodes);
478 INIT_LIST_HEAD(&ls->ls_nodes_gone);
479 ls->ls_num_nodes = 0;
480 ls->ls_low_nodeid = 0;
481 ls->ls_total_weight = 0;
482 ls->ls_node_array = NULL;
484 memset(&ls->ls_stub_rsb, 0, sizeof(struct dlm_rsb));
485 ls->ls_stub_rsb.res_ls = ls;
487 ls->ls_debug_rsb_dentry = NULL;
488 ls->ls_debug_waiters_dentry = NULL;
490 init_waitqueue_head(&ls->ls_uevent_wait);
491 ls->ls_uevent_result = 0;
493 ls->ls_recoverd_task = NULL;
494 mutex_init(&ls->ls_recoverd_active);
495 spin_lock_init(&ls->ls_recover_lock);
496 spin_lock_init(&ls->ls_rcom_spin);
497 get_random_bytes(&ls->ls_rcom_seq, sizeof(uint64_t));
498 ls->ls_recover_status = 0;
499 ls->ls_recover_seq = 0;
500 ls->ls_recover_args = NULL;
501 init_rwsem(&ls->ls_in_recovery);
502 INIT_LIST_HEAD(&ls->ls_requestqueue);
503 mutex_init(&ls->ls_requestqueue_mutex);
504 mutex_init(&ls->ls_clear_proc_locks);
506 ls->ls_recover_buf = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
507 if (!ls->ls_recover_buf)
510 INIT_LIST_HEAD(&ls->ls_recover_list);
511 spin_lock_init(&ls->ls_recover_list_lock);
512 ls->ls_recover_list_count = 0;
513 ls->ls_local_handle = ls;
514 init_waitqueue_head(&ls->ls_wait_general);
515 INIT_LIST_HEAD(&ls->ls_root_list);
516 init_rwsem(&ls->ls_root_sem);
518 down_write(&ls->ls_in_recovery);
520 spin_lock(&lslist_lock);
521 list_add(&ls->ls_list, &lslist);
522 spin_unlock(&lslist_lock);
524 /* needs to find ls in lslist */
525 error = dlm_recoverd_start(ls);
527 log_error(ls, "can't start dlm_recoverd %d", error);
531 dlm_create_debug_file(ls);
533 error = kobject_setup(ls);
537 error = kobject_register(&ls->ls_kobj);
541 error = do_uevent(ls, 1);
549 kobject_unregister(&ls->ls_kobj);
551 dlm_delete_debug_file(ls);
552 dlm_recoverd_stop(ls);
554 spin_lock(&lslist_lock);
555 list_del(&ls->ls_list);
556 spin_unlock(&lslist_lock);
557 kfree(ls->ls_recover_buf);
559 kfree(ls->ls_dirtbl);
561 kfree(ls->ls_lkbtbl);
563 kfree(ls->ls_rsbtbl);
567 module_put(THIS_MODULE);
571 int dlm_new_lockspace(char *name, int namelen, void **lockspace,
572 uint32_t flags, int lvblen)
576 mutex_lock(&ls_lock);
578 error = threads_start();
582 error = new_lockspace(name, namelen, lockspace, flags, lvblen);
586 mutex_unlock(&ls_lock);
590 /* Return 1 if the lockspace still has active remote locks,
591 * 2 if the lockspace still has active local locks.
593 static int lockspace_busy(struct dlm_ls *ls)
595 int i, lkb_found = 0;
598 /* NOTE: We check the lockidtbl here rather than the resource table.
599 This is because there may be LKBs queued as ASTs that have been
600 unlinked from their RSBs and are pending deletion once the AST has
603 for (i = 0; i < ls->ls_lkbtbl_size; i++) {
604 read_lock(&ls->ls_lkbtbl[i].lock);
605 if (!list_empty(&ls->ls_lkbtbl[i].list)) {
607 list_for_each_entry(lkb, &ls->ls_lkbtbl[i].list,
609 if (!lkb->lkb_nodeid) {
610 read_unlock(&ls->ls_lkbtbl[i].lock);
615 read_unlock(&ls->ls_lkbtbl[i].lock);
620 static int release_lockspace(struct dlm_ls *ls, int force)
624 struct list_head *head;
626 int busy = lockspace_busy(ls);
634 dlm_recoverd_stop(ls);
636 remove_lockspace(ls);
638 dlm_delete_debug_file(ls);
642 kfree(ls->ls_recover_buf);
645 * Free direntry structs.
649 kfree(ls->ls_dirtbl);
652 * Free all lkb's on lkbtbl[] lists.
655 for (i = 0; i < ls->ls_lkbtbl_size; i++) {
656 head = &ls->ls_lkbtbl[i].list;
657 while (!list_empty(head)) {
658 lkb = list_entry(head->next, struct dlm_lkb,
661 list_del(&lkb->lkb_idtbl_list);
665 if (lkb->lkb_lvbptr && lkb->lkb_flags & DLM_IFL_MSTCPY)
666 free_lvb(lkb->lkb_lvbptr);
673 kfree(ls->ls_lkbtbl);
676 * Free all rsb's on rsbtbl[] lists
679 for (i = 0; i < ls->ls_rsbtbl_size; i++) {
680 head = &ls->ls_rsbtbl[i].list;
681 while (!list_empty(head)) {
682 rsb = list_entry(head->next, struct dlm_rsb,
685 list_del(&rsb->res_hashchain);
689 head = &ls->ls_rsbtbl[i].toss;
690 while (!list_empty(head)) {
691 rsb = list_entry(head->next, struct dlm_rsb,
693 list_del(&rsb->res_hashchain);
698 kfree(ls->ls_rsbtbl);
701 * Free structures on any other lists
704 dlm_purge_requestqueue(ls);
705 kfree(ls->ls_recover_args);
706 dlm_clear_free_entries(ls);
707 dlm_clear_members(ls);
708 dlm_clear_members_gone(ls);
709 kfree(ls->ls_node_array);
710 kobject_unregister(&ls->ls_kobj);
711 /* The ls structure will be freed when the kobject is done with */
713 mutex_lock(&ls_lock);
717 mutex_unlock(&ls_lock);
719 module_put(THIS_MODULE);
724 * Called when a system has released all its locks and is not going to use the
725 * lockspace any longer. We free everything we're managing for this lockspace.
726 * Remaining nodes will go through the recovery process as if we'd died. The
727 * lockspace must continue to function as usual, participating in recoveries,
728 * until this returns.
730 * Force has 4 possible values:
731 * 0 - don't destroy locksapce if it has any LKBs
732 * 1 - destroy lockspace if it has remote LKBs but not if it has local LKBs
733 * 2 - destroy lockspace regardless of LKBs
734 * 3 - destroy lockspace as part of a forced shutdown
737 int dlm_release_lockspace(void *lockspace, int force)
741 ls = dlm_find_lockspace_local(lockspace);
744 dlm_put_lockspace(ls);
745 return release_lockspace(ls, force);