2 * Copyright (C) 2006-2010 Red Hat, Inc. All rights reserved.
4 * This copyrighted material is made available to anyone wishing to use,
5 * modify, copy, or redistribute it subject to the terms and conditions
6 * of the GNU General Public License v.2.
9 #include <linux/miscdevice.h>
10 #include <linux/init.h>
11 #include <linux/wait.h>
12 #include <linux/file.h>
14 #include <linux/poll.h>
15 #include <linux/signal.h>
16 #include <linux/spinlock.h>
17 #include <linux/dlm.h>
18 #include <linux/dlm_device.h>
19 #include <linux/slab.h>
21 #include "dlm_internal.h"
22 #include "lockspace.h"
24 #include "lvb_table.h"
28 static const char name_prefix[] = "dlm";
29 static const struct file_operations device_fops;
30 static atomic_t dlm_monitor_opened;
31 static int dlm_monitor_unused = 1;
35 struct dlm_lock_params32 {
49 char lvb[DLM_USER_LVB_LEN];
53 struct dlm_write_request32 {
60 struct dlm_lock_params32 lock;
61 struct dlm_lspace_params lspace;
62 struct dlm_purge_params purge;
73 struct dlm_lock_result32 {
79 struct dlm_lksb32 lksb;
82 /* Offsets may be zero if no data is present */
86 static void compat_input(struct dlm_write_request *kb,
87 struct dlm_write_request32 *kb32,
90 kb->version[0] = kb32->version[0];
91 kb->version[1] = kb32->version[1];
92 kb->version[2] = kb32->version[2];
95 kb->is64bit = kb32->is64bit;
96 if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
97 kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
98 kb->i.lspace.flags = kb32->i.lspace.flags;
99 kb->i.lspace.minor = kb32->i.lspace.minor;
100 memcpy(kb->i.lspace.name, kb32->i.lspace.name, namelen);
101 } else if (kb->cmd == DLM_USER_PURGE) {
102 kb->i.purge.nodeid = kb32->i.purge.nodeid;
103 kb->i.purge.pid = kb32->i.purge.pid;
105 kb->i.lock.mode = kb32->i.lock.mode;
106 kb->i.lock.namelen = kb32->i.lock.namelen;
107 kb->i.lock.flags = kb32->i.lock.flags;
108 kb->i.lock.lkid = kb32->i.lock.lkid;
109 kb->i.lock.parent = kb32->i.lock.parent;
110 kb->i.lock.xid = kb32->i.lock.xid;
111 kb->i.lock.timeout = kb32->i.lock.timeout;
112 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
113 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
114 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
115 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
116 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
117 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
118 memcpy(kb->i.lock.name, kb32->i.lock.name, namelen);
122 static void compat_output(struct dlm_lock_result *res,
123 struct dlm_lock_result32 *res32)
125 res32->version[0] = res->version[0];
126 res32->version[1] = res->version[1];
127 res32->version[2] = res->version[2];
129 res32->user_astaddr = (__u32)(long)res->user_astaddr;
130 res32->user_astparam = (__u32)(long)res->user_astparam;
131 res32->user_lksb = (__u32)(long)res->user_lksb;
132 res32->bast_mode = res->bast_mode;
134 res32->lvb_offset = res->lvb_offset;
135 res32->length = res->length;
137 res32->lksb.sb_status = res->lksb.sb_status;
138 res32->lksb.sb_flags = res->lksb.sb_flags;
139 res32->lksb.sb_lkid = res->lksb.sb_lkid;
140 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
144 /* Figure out if this lock is at the end of its life and no longer
145 available for the application to use. The lkb still exists until
146 the final ast is read. A lock becomes EOL in three situations:
147 1. a noqueue request fails with EAGAIN
148 2. an unlock completes with EUNLOCK
149 3. a cancel of a waiting request completes with ECANCEL/EDEADLK
150 An EOL lock needs to be removed from the process's list of locks.
151 And we can't allow any new operation on an EOL lock. This is
152 not related to the lifetime of the lkb struct which is managed
153 entirely by refcount. */
155 static int lkb_is_endoflife(int mode, int status)
164 if (mode == DLM_LOCK_IV)
171 /* we could possibly check if the cancel of an orphan has resulted in the lkb
172 being removed and then remove that lkb from the orphans list and free it */
174 void dlm_user_add_ast(struct dlm_lkb *lkb, uint32_t flags, int mode,
175 int status, uint32_t sbflags, uint64_t seq)
178 struct dlm_user_args *ua;
179 struct dlm_user_proc *proc;
182 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
185 ls = lkb->lkb_resource->res_ls;
186 mutex_lock(&ls->ls_clear_proc_locks);
188 /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
189 can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed
190 lkb->ua so we can't try to use it. This second check is necessary
191 for cases where a completion ast is received for an operation that
192 began before clear_proc_locks did its cancel/unlock. */
194 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
197 DLM_ASSERT(lkb->lkb_ua, dlm_print_lkb(lkb););
201 if ((flags & DLM_CB_BAST) && ua->bastaddr == NULL)
204 if ((flags & DLM_CB_CAST) && lkb_is_endoflife(mode, status))
205 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE;
207 spin_lock(&proc->asts_spin);
209 rv = dlm_add_lkb_callback(lkb, flags, mode, status, sbflags, seq);
211 spin_unlock(&proc->asts_spin);
215 if (list_empty(&lkb->lkb_cb_list)) {
216 kref_get(&lkb->lkb_ref);
217 list_add_tail(&lkb->lkb_cb_list, &proc->asts);
218 wake_up_interruptible(&proc->wait);
220 spin_unlock(&proc->asts_spin);
222 if (lkb->lkb_flags & DLM_IFL_ENDOFLIFE) {
223 /* N.B. spin_lock locks_spin, not asts_spin */
224 spin_lock(&proc->locks_spin);
225 if (!list_empty(&lkb->lkb_ownqueue)) {
226 list_del_init(&lkb->lkb_ownqueue);
229 spin_unlock(&proc->locks_spin);
232 mutex_unlock(&ls->ls_clear_proc_locks);
235 static int device_user_lock(struct dlm_user_proc *proc,
236 struct dlm_lock_params *params)
239 struct dlm_user_args *ua;
243 ls = dlm_find_lockspace_local(proc->lockspace);
247 if (!params->castaddr || !params->lksb) {
252 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
256 ua->user_lksb = params->lksb;
257 ua->castparam = params->castparam;
258 ua->castaddr = params->castaddr;
259 ua->bastparam = params->bastparam;
260 ua->bastaddr = params->bastaddr;
261 ua->xid = params->xid;
263 if (params->flags & DLM_LKF_CONVERT) {
264 error = dlm_user_convert(ls, ua,
265 params->mode, params->flags,
266 params->lkid, params->lvb,
267 (unsigned long) params->timeout);
268 } else if (params->flags & DLM_LKF_ORPHAN) {
269 error = dlm_user_adopt_orphan(ls, ua,
270 params->mode, params->flags,
271 params->name, params->namelen,
272 (unsigned long) params->timeout,
277 error = dlm_user_request(ls, ua,
278 params->mode, params->flags,
279 params->name, params->namelen,
280 (unsigned long) params->timeout);
282 error = ua->lksb.sb_lkid;
285 dlm_put_lockspace(ls);
289 static int device_user_unlock(struct dlm_user_proc *proc,
290 struct dlm_lock_params *params)
293 struct dlm_user_args *ua;
296 ls = dlm_find_lockspace_local(proc->lockspace);
300 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
304 ua->user_lksb = params->lksb;
305 ua->castparam = params->castparam;
306 ua->castaddr = params->castaddr;
308 if (params->flags & DLM_LKF_CANCEL)
309 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
311 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
314 dlm_put_lockspace(ls);
318 static int device_user_deadlock(struct dlm_user_proc *proc,
319 struct dlm_lock_params *params)
324 ls = dlm_find_lockspace_local(proc->lockspace);
328 error = dlm_user_deadlock(ls, params->flags, params->lkid);
330 dlm_put_lockspace(ls);
334 static int dlm_device_register(struct dlm_ls *ls, char *name)
338 /* The device is already registered. This happens when the
339 lockspace is created multiple times from userspace. */
340 if (ls->ls_device.name)
344 len = strlen(name) + strlen(name_prefix) + 2;
345 ls->ls_device.name = kzalloc(len, GFP_NOFS);
346 if (!ls->ls_device.name)
349 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
351 ls->ls_device.fops = &device_fops;
352 ls->ls_device.minor = MISC_DYNAMIC_MINOR;
354 error = misc_register(&ls->ls_device);
356 kfree(ls->ls_device.name);
362 int dlm_device_deregister(struct dlm_ls *ls)
364 /* The device is not registered. This happens when the lockspace
365 was never used from userspace, or when device_create_lockspace()
366 calls dlm_release_lockspace() after the register fails. */
367 if (!ls->ls_device.name)
370 misc_deregister(&ls->ls_device);
371 kfree(ls->ls_device.name);
375 static int device_user_purge(struct dlm_user_proc *proc,
376 struct dlm_purge_params *params)
381 ls = dlm_find_lockspace_local(proc->lockspace);
385 error = dlm_user_purge(ls, proc, params->nodeid, params->pid);
387 dlm_put_lockspace(ls);
391 static int device_create_lockspace(struct dlm_lspace_params *params)
393 dlm_lockspace_t *lockspace;
397 if (!capable(CAP_SYS_ADMIN))
400 error = dlm_new_lockspace(params->name, NULL, params->flags,
401 DLM_USER_LVB_LEN, NULL, NULL, NULL,
406 ls = dlm_find_lockspace_local(lockspace);
410 error = dlm_device_register(ls, params->name);
411 dlm_put_lockspace(ls);
414 dlm_release_lockspace(lockspace, 0);
416 error = ls->ls_device.minor;
421 static int device_remove_lockspace(struct dlm_lspace_params *params)
423 dlm_lockspace_t *lockspace;
425 int error, force = 0;
427 if (!capable(CAP_SYS_ADMIN))
430 ls = dlm_find_lockspace_device(params->minor);
434 if (params->flags & DLM_USER_LSFLG_FORCEFREE)
437 lockspace = ls->ls_local_handle;
438 dlm_put_lockspace(ls);
440 /* The final dlm_release_lockspace waits for references to go to
441 zero, so all processes will need to close their device for the
442 ls before the release will proceed. release also calls the
443 device_deregister above. Converting a positive return value
444 from release to zero means that userspace won't know when its
445 release was the final one, but it shouldn't need to know. */
447 error = dlm_release_lockspace(lockspace, force);
453 /* Check the user's version matches ours */
454 static int check_version(struct dlm_write_request *req)
456 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
457 (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
458 req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
460 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
461 "user (%d.%d.%d) kernel (%d.%d.%d)\n",
463 task_pid_nr(current),
467 DLM_DEVICE_VERSION_MAJOR,
468 DLM_DEVICE_VERSION_MINOR,
469 DLM_DEVICE_VERSION_PATCH);
479 * dlm_user_request -> request_lock
480 * dlm_user_convert -> convert_lock
483 * dlm_user_unlock -> unlock_lock
484 * dlm_user_cancel -> cancel_lock
486 * device_create_lockspace
489 * device_remove_lockspace
490 * dlm_release_lockspace
493 /* a write to a lockspace device is a lock or unlock request, a write
494 to the control device is to create/remove a lockspace */
496 static ssize_t device_write(struct file *file, const char __user *buf,
497 size_t count, loff_t *ppos)
499 struct dlm_user_proc *proc = file->private_data;
500 struct dlm_write_request *kbuf;
504 if (count < sizeof(struct dlm_write_request32))
506 if (count < sizeof(struct dlm_write_request))
511 * can't compare against COMPAT/dlm_write_request32 because
512 * we don't yet know if is64bit is zero
514 if (count > sizeof(struct dlm_write_request) + DLM_RESNAME_MAXLEN)
517 kbuf = memdup_user_nul(buf, count);
519 return PTR_ERR(kbuf);
521 if (check_version(kbuf)) {
527 if (!kbuf->is64bit) {
528 struct dlm_write_request32 *k32buf;
531 if (count > sizeof(struct dlm_write_request32))
532 namelen = count - sizeof(struct dlm_write_request32);
534 k32buf = (struct dlm_write_request32 *)kbuf;
536 /* add 1 after namelen so that the name string is terminated */
537 kbuf = kzalloc(sizeof(struct dlm_write_request) + namelen + 1,
545 set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
547 compat_input(kbuf, k32buf, namelen);
552 /* do we really need this? can a write happen after a close? */
553 if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
554 (proc && test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))) {
565 log_print("no locking on control device");
568 error = device_user_lock(proc, &kbuf->i.lock);
571 case DLM_USER_UNLOCK:
573 log_print("no locking on control device");
576 error = device_user_unlock(proc, &kbuf->i.lock);
579 case DLM_USER_DEADLOCK:
581 log_print("no locking on control device");
584 error = device_user_deadlock(proc, &kbuf->i.lock);
587 case DLM_USER_CREATE_LOCKSPACE:
589 log_print("create/remove only on control device");
592 error = device_create_lockspace(&kbuf->i.lspace);
595 case DLM_USER_REMOVE_LOCKSPACE:
597 log_print("create/remove only on control device");
600 error = device_remove_lockspace(&kbuf->i.lspace);
605 log_print("no locking on control device");
608 error = device_user_purge(proc, &kbuf->i.purge);
612 log_print("Unknown command passed to DLM device : %d\n",
621 /* Every process that opens the lockspace device has its own "proc" structure
622 hanging off the open file that's used to keep track of locks owned by the
623 process and asts that need to be delivered to the process. */
625 static int device_open(struct inode *inode, struct file *file)
627 struct dlm_user_proc *proc;
630 ls = dlm_find_lockspace_device(iminor(inode));
634 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS);
636 dlm_put_lockspace(ls);
640 proc->lockspace = ls->ls_local_handle;
641 INIT_LIST_HEAD(&proc->asts);
642 INIT_LIST_HEAD(&proc->locks);
643 INIT_LIST_HEAD(&proc->unlocking);
644 spin_lock_init(&proc->asts_spin);
645 spin_lock_init(&proc->locks_spin);
646 init_waitqueue_head(&proc->wait);
647 file->private_data = proc;
652 static int device_close(struct inode *inode, struct file *file)
654 struct dlm_user_proc *proc = file->private_data;
657 ls = dlm_find_lockspace_local(proc->lockspace);
661 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
663 dlm_clear_proc_locks(ls, proc);
665 /* at this point no more lkb's should exist for this lockspace,
666 so there's no chance of dlm_user_add_ast() being called and
667 looking for lkb->ua->proc */
670 file->private_data = NULL;
672 dlm_put_lockspace(ls);
673 dlm_put_lockspace(ls); /* for the find in device_open() */
675 /* FIXME: AUTOFREE: if this ls is no longer used do
676 device_remove_lockspace() */
681 static int copy_result_to_user(struct dlm_user_args *ua, int compat,
682 uint32_t flags, int mode, int copy_lvb,
683 char __user *buf, size_t count)
686 struct dlm_lock_result32 result32;
688 struct dlm_lock_result result;
694 memset(&result, 0, sizeof(struct dlm_lock_result));
695 result.version[0] = DLM_DEVICE_VERSION_MAJOR;
696 result.version[1] = DLM_DEVICE_VERSION_MINOR;
697 result.version[2] = DLM_DEVICE_VERSION_PATCH;
698 memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
699 result.user_lksb = ua->user_lksb;
701 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
702 in a conversion unless the conversion is successful. See code
703 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though,
704 notes that a new blocking AST address and parameter are set even if
705 the conversion fails, so maybe we should just do that. */
707 if (flags & DLM_CB_BAST) {
708 result.user_astaddr = ua->bastaddr;
709 result.user_astparam = ua->bastparam;
710 result.bast_mode = mode;
712 result.user_astaddr = ua->castaddr;
713 result.user_astparam = ua->castparam;
718 len = sizeof(struct dlm_lock_result32);
721 len = sizeof(struct dlm_lock_result);
724 /* copy lvb to userspace if there is one, it's been updated, and
725 the user buffer has space for it */
727 if (copy_lvb && ua->lksb.sb_lvbptr && count >= len + DLM_USER_LVB_LEN) {
728 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
734 result.lvb_offset = len;
735 len += DLM_USER_LVB_LEN;
742 compat_output(&result, &result32);
743 resultptr = &result32;
747 if (copy_to_user(buf, resultptr, struct_len))
755 static int copy_version_to_user(char __user *buf, size_t count)
757 struct dlm_device_version ver;
759 memset(&ver, 0, sizeof(struct dlm_device_version));
760 ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
761 ver.version[1] = DLM_DEVICE_VERSION_MINOR;
762 ver.version[2] = DLM_DEVICE_VERSION_PATCH;
764 if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
766 return sizeof(struct dlm_device_version);
769 /* a read returns a single ast described in a struct dlm_lock_result */
771 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
774 struct dlm_user_proc *proc = file->private_data;
776 DECLARE_WAITQUEUE(wait, current);
777 struct dlm_callback cb;
778 int rv, resid, copy_lvb = 0;
779 int old_mode, new_mode;
781 if (count == sizeof(struct dlm_device_version)) {
782 rv = copy_version_to_user(buf, count);
787 log_print("non-version read from control device %zu", count);
792 if (count < sizeof(struct dlm_lock_result32))
794 if (count < sizeof(struct dlm_lock_result))
800 /* do we really need this? can a read happen after a close? */
801 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
804 spin_lock(&proc->asts_spin);
805 if (list_empty(&proc->asts)) {
806 if (file->f_flags & O_NONBLOCK) {
807 spin_unlock(&proc->asts_spin);
811 add_wait_queue(&proc->wait, &wait);
814 set_current_state(TASK_INTERRUPTIBLE);
815 if (list_empty(&proc->asts) && !signal_pending(current)) {
816 spin_unlock(&proc->asts_spin);
818 spin_lock(&proc->asts_spin);
821 set_current_state(TASK_RUNNING);
822 remove_wait_queue(&proc->wait, &wait);
824 if (signal_pending(current)) {
825 spin_unlock(&proc->asts_spin);
830 /* if we empty lkb_callbacks, we don't want to unlock the spinlock
831 without removing lkb_cb_list; so empty lkb_cb_list is always
832 consistent with empty lkb_callbacks */
834 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_cb_list);
836 /* rem_lkb_callback sets a new lkb_last_cast */
837 old_mode = lkb->lkb_last_cast.mode;
839 rv = dlm_rem_lkb_callback(lkb->lkb_resource->res_ls, lkb, &cb, &resid);
841 /* this shouldn't happen; lkb should have been removed from
842 list when resid was zero */
843 log_print("dlm_rem_lkb_callback empty %x", lkb->lkb_id);
844 list_del_init(&lkb->lkb_cb_list);
845 spin_unlock(&proc->asts_spin);
846 /* removes ref for proc->asts, may cause lkb to be freed */
851 list_del_init(&lkb->lkb_cb_list);
852 spin_unlock(&proc->asts_spin);
854 if (cb.flags & DLM_CB_SKIP) {
855 /* removes ref for proc->asts, may cause lkb to be freed */
861 if (cb.flags & DLM_CB_CAST) {
864 if (!cb.sb_status && lkb->lkb_lksb->sb_lvbptr &&
865 dlm_lvb_operations[old_mode + 1][new_mode + 1])
868 lkb->lkb_lksb->sb_status = cb.sb_status;
869 lkb->lkb_lksb->sb_flags = cb.sb_flags;
872 rv = copy_result_to_user(lkb->lkb_ua,
873 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
874 cb.flags, cb.mode, copy_lvb, buf, count);
876 /* removes ref for proc->asts, may cause lkb to be freed */
883 static unsigned int device_poll(struct file *file, poll_table *wait)
885 struct dlm_user_proc *proc = file->private_data;
887 poll_wait(file, &proc->wait, wait);
889 spin_lock(&proc->asts_spin);
890 if (!list_empty(&proc->asts)) {
891 spin_unlock(&proc->asts_spin);
892 return POLLIN | POLLRDNORM;
894 spin_unlock(&proc->asts_spin);
898 int dlm_user_daemon_available(void)
900 /* dlm_controld hasn't started (or, has started, but not
901 properly populated configfs) */
903 if (!dlm_our_nodeid())
906 /* This is to deal with versions of dlm_controld that don't
907 know about the monitor device. We assume that if the
908 dlm_controld was started (above), but the monitor device
909 was never opened, that it's an old version. dlm_controld
910 should open the monitor device before populating configfs. */
912 if (dlm_monitor_unused)
915 return atomic_read(&dlm_monitor_opened) ? 1 : 0;
918 static int ctl_device_open(struct inode *inode, struct file *file)
920 file->private_data = NULL;
924 static int ctl_device_close(struct inode *inode, struct file *file)
929 static int monitor_device_open(struct inode *inode, struct file *file)
931 atomic_inc(&dlm_monitor_opened);
932 dlm_monitor_unused = 0;
936 static int monitor_device_close(struct inode *inode, struct file *file)
938 if (atomic_dec_and_test(&dlm_monitor_opened))
939 dlm_stop_lockspaces();
943 static const struct file_operations device_fops = {
945 .release = device_close,
947 .write = device_write,
949 .owner = THIS_MODULE,
950 .llseek = noop_llseek,
953 static const struct file_operations ctl_device_fops = {
954 .open = ctl_device_open,
955 .release = ctl_device_close,
957 .write = device_write,
958 .owner = THIS_MODULE,
959 .llseek = noop_llseek,
962 static struct miscdevice ctl_device = {
963 .name = "dlm-control",
964 .fops = &ctl_device_fops,
965 .minor = MISC_DYNAMIC_MINOR,
968 static const struct file_operations monitor_device_fops = {
969 .open = monitor_device_open,
970 .release = monitor_device_close,
971 .owner = THIS_MODULE,
972 .llseek = noop_llseek,
975 static struct miscdevice monitor_device = {
976 .name = "dlm-monitor",
977 .fops = &monitor_device_fops,
978 .minor = MISC_DYNAMIC_MINOR,
981 int __init dlm_user_init(void)
985 atomic_set(&dlm_monitor_opened, 0);
987 error = misc_register(&ctl_device);
989 log_print("misc_register failed for control device");
993 error = misc_register(&monitor_device);
995 log_print("misc_register failed for monitor device");
996 misc_deregister(&ctl_device);
1002 void dlm_user_exit(void)
1004 misc_deregister(&ctl_device);
1005 misc_deregister(&monitor_device);