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/module.h>
13 #include <linux/file.h>
15 #include <linux/poll.h>
16 #include <linux/signal.h>
17 #include <linux/spinlock.h>
18 #include <linux/dlm.h>
19 #include <linux/dlm_device.h>
20 #include <linux/slab.h>
22 #include "dlm_internal.h"
23 #include "lockspace.h"
25 #include "lvb_table.h"
30 static const char name_prefix[] = "dlm";
31 static const struct file_operations device_fops;
32 static atomic_t dlm_monitor_opened;
33 static int dlm_monitor_unused = 1;
37 struct dlm_lock_params32 {
51 char lvb[DLM_USER_LVB_LEN];
55 struct dlm_write_request32 {
62 struct dlm_lock_params32 lock;
63 struct dlm_lspace_params lspace;
64 struct dlm_purge_params purge;
75 struct dlm_lock_result32 {
81 struct dlm_lksb32 lksb;
84 /* Offsets may be zero if no data is present */
88 static void compat_input(struct dlm_write_request *kb,
89 struct dlm_write_request32 *kb32,
92 kb->version[0] = kb32->version[0];
93 kb->version[1] = kb32->version[1];
94 kb->version[2] = kb32->version[2];
97 kb->is64bit = kb32->is64bit;
98 if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
99 kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
100 kb->i.lspace.flags = kb32->i.lspace.flags;
101 kb->i.lspace.minor = kb32->i.lspace.minor;
102 memcpy(kb->i.lspace.name, kb32->i.lspace.name, namelen);
103 } else if (kb->cmd == DLM_USER_PURGE) {
104 kb->i.purge.nodeid = kb32->i.purge.nodeid;
105 kb->i.purge.pid = kb32->i.purge.pid;
107 kb->i.lock.mode = kb32->i.lock.mode;
108 kb->i.lock.namelen = kb32->i.lock.namelen;
109 kb->i.lock.flags = kb32->i.lock.flags;
110 kb->i.lock.lkid = kb32->i.lock.lkid;
111 kb->i.lock.parent = kb32->i.lock.parent;
112 kb->i.lock.xid = kb32->i.lock.xid;
113 kb->i.lock.timeout = kb32->i.lock.timeout;
114 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
115 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
116 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
117 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
118 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
119 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
120 memcpy(kb->i.lock.name, kb32->i.lock.name, namelen);
124 static void compat_output(struct dlm_lock_result *res,
125 struct dlm_lock_result32 *res32)
127 res32->version[0] = res->version[0];
128 res32->version[1] = res->version[1];
129 res32->version[2] = res->version[2];
131 res32->user_astaddr = (__u32)(long)res->user_astaddr;
132 res32->user_astparam = (__u32)(long)res->user_astparam;
133 res32->user_lksb = (__u32)(long)res->user_lksb;
134 res32->bast_mode = res->bast_mode;
136 res32->lvb_offset = res->lvb_offset;
137 res32->length = res->length;
139 res32->lksb.sb_status = res->lksb.sb_status;
140 res32->lksb.sb_flags = res->lksb.sb_flags;
141 res32->lksb.sb_lkid = res->lksb.sb_lkid;
142 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
146 /* Figure out if this lock is at the end of its life and no longer
147 available for the application to use. The lkb still exists until
148 the final ast is read. A lock becomes EOL in three situations:
149 1. a noqueue request fails with EAGAIN
150 2. an unlock completes with EUNLOCK
151 3. a cancel of a waiting request completes with ECANCEL/EDEADLK
152 An EOL lock needs to be removed from the process's list of locks.
153 And we can't allow any new operation on an EOL lock. This is
154 not related to the lifetime of the lkb struct which is managed
155 entirely by refcount. */
157 static int lkb_is_endoflife(int mode, int status)
166 if (mode == DLM_LOCK_IV)
173 /* we could possibly check if the cancel of an orphan has resulted in the lkb
174 being removed and then remove that lkb from the orphans list and free it */
176 void dlm_user_add_ast(struct dlm_lkb *lkb, uint32_t flags, int mode,
177 int status, uint32_t sbflags, uint64_t seq)
180 struct dlm_user_args *ua;
181 struct dlm_user_proc *proc;
184 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
187 ls = lkb->lkb_resource->res_ls;
188 mutex_lock(&ls->ls_clear_proc_locks);
190 /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
191 can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed
192 lkb->ua so we can't try to use it. This second check is necessary
193 for cases where a completion ast is received for an operation that
194 began before clear_proc_locks did its cancel/unlock. */
196 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
199 DLM_ASSERT(lkb->lkb_ua, dlm_print_lkb(lkb););
203 if ((flags & DLM_CB_BAST) && ua->bastaddr == NULL)
206 if ((flags & DLM_CB_CAST) && lkb_is_endoflife(mode, status))
207 lkb->lkb_flags |= DLM_IFL_ENDOFLIFE;
209 spin_lock(&proc->asts_spin);
211 rv = dlm_add_lkb_callback(lkb, flags, mode, status, sbflags, seq);
213 spin_unlock(&proc->asts_spin);
217 if (list_empty(&lkb->lkb_cb_list)) {
218 kref_get(&lkb->lkb_ref);
219 list_add_tail(&lkb->lkb_cb_list, &proc->asts);
220 wake_up_interruptible(&proc->wait);
222 spin_unlock(&proc->asts_spin);
224 if (lkb->lkb_flags & DLM_IFL_ENDOFLIFE) {
225 /* N.B. spin_lock locks_spin, not asts_spin */
226 spin_lock(&proc->locks_spin);
227 if (!list_empty(&lkb->lkb_ownqueue)) {
228 list_del_init(&lkb->lkb_ownqueue);
231 spin_unlock(&proc->locks_spin);
234 mutex_unlock(&ls->ls_clear_proc_locks);
237 static int device_user_lock(struct dlm_user_proc *proc,
238 struct dlm_lock_params *params)
241 struct dlm_user_args *ua;
245 ls = dlm_find_lockspace_local(proc->lockspace);
249 if (!params->castaddr || !params->lksb) {
254 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
258 ua->user_lksb = params->lksb;
259 ua->castparam = params->castparam;
260 ua->castaddr = params->castaddr;
261 ua->bastparam = params->bastparam;
262 ua->bastaddr = params->bastaddr;
263 ua->xid = params->xid;
265 if (params->flags & DLM_LKF_CONVERT) {
266 error = dlm_user_convert(ls, ua,
267 params->mode, params->flags,
268 params->lkid, params->lvb,
269 (unsigned long) params->timeout);
270 } else if (params->flags & DLM_LKF_ORPHAN) {
271 error = dlm_user_adopt_orphan(ls, ua,
272 params->mode, params->flags,
273 params->name, params->namelen,
274 (unsigned long) params->timeout,
279 error = dlm_user_request(ls, ua,
280 params->mode, params->flags,
281 params->name, params->namelen,
282 (unsigned long) params->timeout);
284 error = ua->lksb.sb_lkid;
287 dlm_put_lockspace(ls);
291 static int device_user_unlock(struct dlm_user_proc *proc,
292 struct dlm_lock_params *params)
295 struct dlm_user_args *ua;
298 ls = dlm_find_lockspace_local(proc->lockspace);
302 ua = kzalloc(sizeof(struct dlm_user_args), GFP_NOFS);
306 ua->user_lksb = params->lksb;
307 ua->castparam = params->castparam;
308 ua->castaddr = params->castaddr;
310 if (params->flags & DLM_LKF_CANCEL)
311 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
313 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
316 dlm_put_lockspace(ls);
320 static int device_user_deadlock(struct dlm_user_proc *proc,
321 struct dlm_lock_params *params)
326 ls = dlm_find_lockspace_local(proc->lockspace);
330 error = dlm_user_deadlock(ls, params->flags, params->lkid);
332 dlm_put_lockspace(ls);
336 static int dlm_device_register(struct dlm_ls *ls, char *name)
340 /* The device is already registered. This happens when the
341 lockspace is created multiple times from userspace. */
342 if (ls->ls_device.name)
346 len = strlen(name) + strlen(name_prefix) + 2;
347 ls->ls_device.name = kzalloc(len, GFP_NOFS);
348 if (!ls->ls_device.name)
351 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
353 ls->ls_device.fops = &device_fops;
354 ls->ls_device.minor = MISC_DYNAMIC_MINOR;
356 error = misc_register(&ls->ls_device);
358 kfree(ls->ls_device.name);
359 /* this has to be set to NULL
360 * to avoid a double-free in dlm_device_deregister
362 ls->ls_device.name = NULL;
368 int dlm_device_deregister(struct dlm_ls *ls)
370 /* The device is not registered. This happens when the lockspace
371 was never used from userspace, or when device_create_lockspace()
372 calls dlm_release_lockspace() after the register fails. */
373 if (!ls->ls_device.name)
376 misc_deregister(&ls->ls_device);
377 kfree(ls->ls_device.name);
381 static int device_user_purge(struct dlm_user_proc *proc,
382 struct dlm_purge_params *params)
387 ls = dlm_find_lockspace_local(proc->lockspace);
391 error = dlm_user_purge(ls, proc, params->nodeid, params->pid);
393 dlm_put_lockspace(ls);
397 static int device_create_lockspace(struct dlm_lspace_params *params)
399 dlm_lockspace_t *lockspace;
403 if (!capable(CAP_SYS_ADMIN))
406 error = dlm_new_lockspace(params->name, dlm_config.ci_cluster_name, params->flags,
407 DLM_USER_LVB_LEN, NULL, NULL, NULL,
412 ls = dlm_find_lockspace_local(lockspace);
416 error = dlm_device_register(ls, params->name);
417 dlm_put_lockspace(ls);
420 dlm_release_lockspace(lockspace, 0);
422 error = ls->ls_device.minor;
427 static int device_remove_lockspace(struct dlm_lspace_params *params)
429 dlm_lockspace_t *lockspace;
431 int error, force = 0;
433 if (!capable(CAP_SYS_ADMIN))
436 ls = dlm_find_lockspace_device(params->minor);
440 if (params->flags & DLM_USER_LSFLG_FORCEFREE)
443 lockspace = ls->ls_local_handle;
444 dlm_put_lockspace(ls);
446 /* The final dlm_release_lockspace waits for references to go to
447 zero, so all processes will need to close their device for the
448 ls before the release will proceed. release also calls the
449 device_deregister above. Converting a positive return value
450 from release to zero means that userspace won't know when its
451 release was the final one, but it shouldn't need to know. */
453 error = dlm_release_lockspace(lockspace, force);
459 /* Check the user's version matches ours */
460 static int check_version(struct dlm_write_request *req)
462 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
463 (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
464 req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
466 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
467 "user (%d.%d.%d) kernel (%d.%d.%d)\n",
469 task_pid_nr(current),
473 DLM_DEVICE_VERSION_MAJOR,
474 DLM_DEVICE_VERSION_MINOR,
475 DLM_DEVICE_VERSION_PATCH);
485 * dlm_user_request -> request_lock
486 * dlm_user_convert -> convert_lock
489 * dlm_user_unlock -> unlock_lock
490 * dlm_user_cancel -> cancel_lock
492 * device_create_lockspace
495 * device_remove_lockspace
496 * dlm_release_lockspace
499 /* a write to a lockspace device is a lock or unlock request, a write
500 to the control device is to create/remove a lockspace */
502 static ssize_t device_write(struct file *file, const char __user *buf,
503 size_t count, loff_t *ppos)
505 struct dlm_user_proc *proc = file->private_data;
506 struct dlm_write_request *kbuf;
510 if (count < sizeof(struct dlm_write_request32))
512 if (count < sizeof(struct dlm_write_request))
517 * can't compare against COMPAT/dlm_write_request32 because
518 * we don't yet know if is64bit is zero
520 if (count > sizeof(struct dlm_write_request) + DLM_RESNAME_MAXLEN)
523 kbuf = kzalloc(count + 1, GFP_NOFS);
527 if (copy_from_user(kbuf, buf, count)) {
532 if (check_version(kbuf)) {
538 if (!kbuf->is64bit) {
539 struct dlm_write_request32 *k32buf;
542 if (count > sizeof(struct dlm_write_request32))
543 namelen = count - sizeof(struct dlm_write_request32);
545 k32buf = (struct dlm_write_request32 *)kbuf;
547 /* add 1 after namelen so that the name string is terminated */
548 kbuf = kzalloc(sizeof(struct dlm_write_request) + namelen + 1,
556 set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
558 compat_input(kbuf, k32buf, namelen);
563 /* do we really need this? can a write happen after a close? */
564 if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
565 (proc && test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))) {
576 log_print("no locking on control device");
579 error = device_user_lock(proc, &kbuf->i.lock);
582 case DLM_USER_UNLOCK:
584 log_print("no locking on control device");
587 error = device_user_unlock(proc, &kbuf->i.lock);
590 case DLM_USER_DEADLOCK:
592 log_print("no locking on control device");
595 error = device_user_deadlock(proc, &kbuf->i.lock);
598 case DLM_USER_CREATE_LOCKSPACE:
600 log_print("create/remove only on control device");
603 error = device_create_lockspace(&kbuf->i.lspace);
606 case DLM_USER_REMOVE_LOCKSPACE:
608 log_print("create/remove only on control device");
611 error = device_remove_lockspace(&kbuf->i.lspace);
616 log_print("no locking on control device");
619 error = device_user_purge(proc, &kbuf->i.purge);
623 log_print("Unknown command passed to DLM device : %d\n",
632 /* Every process that opens the lockspace device has its own "proc" structure
633 hanging off the open file that's used to keep track of locks owned by the
634 process and asts that need to be delivered to the process. */
636 static int device_open(struct inode *inode, struct file *file)
638 struct dlm_user_proc *proc;
641 ls = dlm_find_lockspace_device(iminor(inode));
645 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_NOFS);
647 dlm_put_lockspace(ls);
651 proc->lockspace = ls->ls_local_handle;
652 INIT_LIST_HEAD(&proc->asts);
653 INIT_LIST_HEAD(&proc->locks);
654 INIT_LIST_HEAD(&proc->unlocking);
655 spin_lock_init(&proc->asts_spin);
656 spin_lock_init(&proc->locks_spin);
657 init_waitqueue_head(&proc->wait);
658 file->private_data = proc;
663 static int device_close(struct inode *inode, struct file *file)
665 struct dlm_user_proc *proc = file->private_data;
668 ls = dlm_find_lockspace_local(proc->lockspace);
672 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
674 dlm_clear_proc_locks(ls, proc);
676 /* at this point no more lkb's should exist for this lockspace,
677 so there's no chance of dlm_user_add_ast() being called and
678 looking for lkb->ua->proc */
681 file->private_data = NULL;
683 dlm_put_lockspace(ls);
684 dlm_put_lockspace(ls); /* for the find in device_open() */
686 /* FIXME: AUTOFREE: if this ls is no longer used do
687 device_remove_lockspace() */
692 static int copy_result_to_user(struct dlm_user_args *ua, int compat,
693 uint32_t flags, int mode, int copy_lvb,
694 char __user *buf, size_t count)
697 struct dlm_lock_result32 result32;
699 struct dlm_lock_result result;
705 memset(&result, 0, sizeof(struct dlm_lock_result));
706 result.version[0] = DLM_DEVICE_VERSION_MAJOR;
707 result.version[1] = DLM_DEVICE_VERSION_MINOR;
708 result.version[2] = DLM_DEVICE_VERSION_PATCH;
709 memcpy(&result.lksb, &ua->lksb, offsetof(struct dlm_lksb, sb_lvbptr));
710 result.user_lksb = ua->user_lksb;
712 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
713 in a conversion unless the conversion is successful. See code
714 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though,
715 notes that a new blocking AST address and parameter are set even if
716 the conversion fails, so maybe we should just do that. */
718 if (flags & DLM_CB_BAST) {
719 result.user_astaddr = ua->bastaddr;
720 result.user_astparam = ua->bastparam;
721 result.bast_mode = mode;
723 result.user_astaddr = ua->castaddr;
724 result.user_astparam = ua->castparam;
729 len = sizeof(struct dlm_lock_result32);
732 len = sizeof(struct dlm_lock_result);
735 /* copy lvb to userspace if there is one, it's been updated, and
736 the user buffer has space for it */
738 if (copy_lvb && ua->lksb.sb_lvbptr && count >= len + DLM_USER_LVB_LEN) {
739 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
745 result.lvb_offset = len;
746 len += DLM_USER_LVB_LEN;
753 compat_output(&result, &result32);
754 resultptr = &result32;
758 if (copy_to_user(buf, resultptr, struct_len))
766 static int copy_version_to_user(char __user *buf, size_t count)
768 struct dlm_device_version ver;
770 memset(&ver, 0, sizeof(struct dlm_device_version));
771 ver.version[0] = DLM_DEVICE_VERSION_MAJOR;
772 ver.version[1] = DLM_DEVICE_VERSION_MINOR;
773 ver.version[2] = DLM_DEVICE_VERSION_PATCH;
775 if (copy_to_user(buf, &ver, sizeof(struct dlm_device_version)))
777 return sizeof(struct dlm_device_version);
780 /* a read returns a single ast described in a struct dlm_lock_result */
782 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
785 struct dlm_user_proc *proc = file->private_data;
787 DECLARE_WAITQUEUE(wait, current);
788 struct dlm_callback cb;
789 int rv, resid, copy_lvb = 0;
790 int old_mode, new_mode;
792 if (count == sizeof(struct dlm_device_version)) {
793 rv = copy_version_to_user(buf, count);
798 log_print("non-version read from control device %zu", count);
803 if (count < sizeof(struct dlm_lock_result32))
805 if (count < sizeof(struct dlm_lock_result))
811 /* do we really need this? can a read happen after a close? */
812 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
815 spin_lock(&proc->asts_spin);
816 if (list_empty(&proc->asts)) {
817 if (file->f_flags & O_NONBLOCK) {
818 spin_unlock(&proc->asts_spin);
822 add_wait_queue(&proc->wait, &wait);
825 set_current_state(TASK_INTERRUPTIBLE);
826 if (list_empty(&proc->asts) && !signal_pending(current)) {
827 spin_unlock(&proc->asts_spin);
829 spin_lock(&proc->asts_spin);
832 set_current_state(TASK_RUNNING);
833 remove_wait_queue(&proc->wait, &wait);
835 if (signal_pending(current)) {
836 spin_unlock(&proc->asts_spin);
841 /* if we empty lkb_callbacks, we don't want to unlock the spinlock
842 without removing lkb_cb_list; so empty lkb_cb_list is always
843 consistent with empty lkb_callbacks */
845 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_cb_list);
847 /* rem_lkb_callback sets a new lkb_last_cast */
848 old_mode = lkb->lkb_last_cast.mode;
850 rv = dlm_rem_lkb_callback(lkb->lkb_resource->res_ls, lkb, &cb, &resid);
852 /* this shouldn't happen; lkb should have been removed from
853 list when resid was zero */
854 log_print("dlm_rem_lkb_callback empty %x", lkb->lkb_id);
855 list_del_init(&lkb->lkb_cb_list);
856 spin_unlock(&proc->asts_spin);
857 /* removes ref for proc->asts, may cause lkb to be freed */
862 list_del_init(&lkb->lkb_cb_list);
863 spin_unlock(&proc->asts_spin);
865 if (cb.flags & DLM_CB_SKIP) {
866 /* removes ref for proc->asts, may cause lkb to be freed */
872 if (cb.flags & DLM_CB_CAST) {
875 if (!cb.sb_status && lkb->lkb_lksb->sb_lvbptr &&
876 dlm_lvb_operations[old_mode + 1][new_mode + 1])
879 lkb->lkb_lksb->sb_status = cb.sb_status;
880 lkb->lkb_lksb->sb_flags = cb.sb_flags;
883 rv = copy_result_to_user(lkb->lkb_ua,
884 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
885 cb.flags, cb.mode, copy_lvb, buf, count);
887 /* removes ref for proc->asts, may cause lkb to be freed */
894 static unsigned int device_poll(struct file *file, poll_table *wait)
896 struct dlm_user_proc *proc = file->private_data;
898 poll_wait(file, &proc->wait, wait);
900 spin_lock(&proc->asts_spin);
901 if (!list_empty(&proc->asts)) {
902 spin_unlock(&proc->asts_spin);
903 return POLLIN | POLLRDNORM;
905 spin_unlock(&proc->asts_spin);
909 int dlm_user_daemon_available(void)
911 /* dlm_controld hasn't started (or, has started, but not
912 properly populated configfs) */
914 if (!dlm_our_nodeid())
917 /* This is to deal with versions of dlm_controld that don't
918 know about the monitor device. We assume that if the
919 dlm_controld was started (above), but the monitor device
920 was never opened, that it's an old version. dlm_controld
921 should open the monitor device before populating configfs. */
923 if (dlm_monitor_unused)
926 return atomic_read(&dlm_monitor_opened) ? 1 : 0;
929 static int ctl_device_open(struct inode *inode, struct file *file)
931 file->private_data = NULL;
935 static int ctl_device_close(struct inode *inode, struct file *file)
940 static int monitor_device_open(struct inode *inode, struct file *file)
942 atomic_inc(&dlm_monitor_opened);
943 dlm_monitor_unused = 0;
947 static int monitor_device_close(struct inode *inode, struct file *file)
949 if (atomic_dec_and_test(&dlm_monitor_opened))
950 dlm_stop_lockspaces();
954 static const struct file_operations device_fops = {
956 .release = device_close,
958 .write = device_write,
960 .owner = THIS_MODULE,
961 .llseek = noop_llseek,
964 static const struct file_operations ctl_device_fops = {
965 .open = ctl_device_open,
966 .release = ctl_device_close,
968 .write = device_write,
969 .owner = THIS_MODULE,
970 .llseek = noop_llseek,
973 static struct miscdevice ctl_device = {
974 .name = "dlm-control",
975 .fops = &ctl_device_fops,
976 .minor = MISC_DYNAMIC_MINOR,
979 static const struct file_operations monitor_device_fops = {
980 .open = monitor_device_open,
981 .release = monitor_device_close,
982 .owner = THIS_MODULE,
983 .llseek = noop_llseek,
986 static struct miscdevice monitor_device = {
987 .name = "dlm-monitor",
988 .fops = &monitor_device_fops,
989 .minor = MISC_DYNAMIC_MINOR,
992 int __init dlm_user_init(void)
996 atomic_set(&dlm_monitor_opened, 0);
998 error = misc_register(&ctl_device);
1000 log_print("misc_register failed for control device");
1004 error = misc_register(&monitor_device);
1006 log_print("misc_register failed for monitor device");
1007 misc_deregister(&ctl_device);
1013 void dlm_user_exit(void)
1015 misc_deregister(&ctl_device);
1016 misc_deregister(&monitor_device);