2 * Copyright (C) 2006 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>
21 #include "dlm_internal.h"
22 #include "lockspace.h"
24 #include "lvb_table.h"
26 static const char *name_prefix="dlm";
27 static struct miscdevice ctl_device;
28 static struct file_operations device_fops;
32 struct dlm_lock_params32 {
45 char lvb[DLM_USER_LVB_LEN];
49 struct dlm_write_request32 {
56 struct dlm_lock_params32 lock;
57 struct dlm_lspace_params lspace;
68 struct dlm_lock_result32 {
73 struct dlm_lksb32 lksb;
76 /* Offsets may be zero if no data is present */
80 static void compat_input(struct dlm_write_request *kb,
81 struct dlm_write_request32 *kb32)
83 kb->version[0] = kb32->version[0];
84 kb->version[1] = kb32->version[1];
85 kb->version[2] = kb32->version[2];
88 kb->is64bit = kb32->is64bit;
89 if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
90 kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
91 kb->i.lspace.flags = kb32->i.lspace.flags;
92 kb->i.lspace.minor = kb32->i.lspace.minor;
93 strcpy(kb->i.lspace.name, kb32->i.lspace.name);
95 kb->i.lock.mode = kb32->i.lock.mode;
96 kb->i.lock.namelen = kb32->i.lock.namelen;
97 kb->i.lock.flags = kb32->i.lock.flags;
98 kb->i.lock.lkid = kb32->i.lock.lkid;
99 kb->i.lock.parent = kb32->i.lock.parent;
100 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
101 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
102 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
103 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
104 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
105 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
106 memcpy(kb->i.lock.name, kb32->i.lock.name, kb->i.lock.namelen);
110 static void compat_output(struct dlm_lock_result *res,
111 struct dlm_lock_result32 *res32)
113 res32->length = res->length - (sizeof(struct dlm_lock_result) -
114 sizeof(struct dlm_lock_result32));
115 res32->user_astaddr = (__u32)(long)res->user_astaddr;
116 res32->user_astparam = (__u32)(long)res->user_astparam;
117 res32->user_lksb = (__u32)(long)res->user_lksb;
118 res32->bast_mode = res->bast_mode;
120 res32->lvb_offset = res->lvb_offset;
121 res32->length = res->length;
123 res32->lksb.sb_status = res->lksb.sb_status;
124 res32->lksb.sb_flags = res->lksb.sb_flags;
125 res32->lksb.sb_lkid = res->lksb.sb_lkid;
126 res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
131 void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
134 struct dlm_user_args *ua;
135 struct dlm_user_proc *proc;
136 int remove_ownqueue = 0;
138 /* dlm_clear_proc_locks() sets ORPHAN/DEAD flag on each
139 lkb before dealing with it. We need to check this
140 flag before taking ls_clear_proc_locks mutex because if
141 it's set, dlm_clear_proc_locks() holds the mutex. */
143 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) {
144 /* log_print("user_add_ast skip1 %x", lkb->lkb_flags); */
148 ls = lkb->lkb_resource->res_ls;
149 mutex_lock(&ls->ls_clear_proc_locks);
151 /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
152 can't be delivered. For ORPHAN's, dlm_clear_proc_locks() freed
153 lkb->ua so we can't try to use it. */
155 if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) {
156 /* log_print("user_add_ast skip2 %x", lkb->lkb_flags); */
160 DLM_ASSERT(lkb->lkb_astparam, dlm_print_lkb(lkb););
161 ua = (struct dlm_user_args *)lkb->lkb_astparam;
164 if (type == AST_BAST && ua->bastaddr == NULL)
167 spin_lock(&proc->asts_spin);
168 if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) {
169 kref_get(&lkb->lkb_ref);
170 list_add_tail(&lkb->lkb_astqueue, &proc->asts);
171 lkb->lkb_ast_type |= type;
172 wake_up_interruptible(&proc->wait);
175 /* noqueue requests that fail may need to be removed from the
176 proc's locks list, there should be a better way of detecting
177 this situation than checking all these things... */
179 if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV &&
180 ua->lksb.sb_status == -EAGAIN && !list_empty(&lkb->lkb_ownqueue))
183 /* We want to copy the lvb to userspace when the completion
184 ast is read if the status is 0, the lock has an lvb and
185 lvb_ops says we should. We could probably have set_lvb_lock()
186 set update_user_lvb instead and not need old_mode */
188 if ((lkb->lkb_ast_type & AST_COMP) &&
189 (lkb->lkb_lksb->sb_status == 0) &&
190 lkb->lkb_lksb->sb_lvbptr &&
191 dlm_lvb_operations[ua->old_mode + 1][lkb->lkb_grmode + 1])
192 ua->update_user_lvb = 1;
194 ua->update_user_lvb = 0;
196 spin_unlock(&proc->asts_spin);
198 if (remove_ownqueue) {
199 spin_lock(&ua->proc->locks_spin);
200 list_del_init(&lkb->lkb_ownqueue);
201 spin_unlock(&ua->proc->locks_spin);
205 mutex_unlock(&ls->ls_clear_proc_locks);
208 static int device_user_lock(struct dlm_user_proc *proc,
209 struct dlm_lock_params *params)
212 struct dlm_user_args *ua;
215 ls = dlm_find_lockspace_local(proc->lockspace);
219 if (!params->castaddr || !params->lksb) {
224 ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
228 ua->user_lksb = params->lksb;
229 ua->castparam = params->castparam;
230 ua->castaddr = params->castaddr;
231 ua->bastparam = params->bastparam;
232 ua->bastaddr = params->bastaddr;
234 if (params->flags & DLM_LKF_CONVERT)
235 error = dlm_user_convert(ls, ua,
236 params->mode, params->flags,
237 params->lkid, params->lvb);
239 error = dlm_user_request(ls, ua,
240 params->mode, params->flags,
241 params->name, params->namelen,
244 error = ua->lksb.sb_lkid;
247 dlm_put_lockspace(ls);
251 static int device_user_unlock(struct dlm_user_proc *proc,
252 struct dlm_lock_params *params)
255 struct dlm_user_args *ua;
258 ls = dlm_find_lockspace_local(proc->lockspace);
262 ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
266 ua->user_lksb = params->lksb;
267 ua->castparam = params->castparam;
268 ua->castaddr = params->castaddr;
270 if (params->flags & DLM_LKF_CANCEL)
271 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
273 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
276 dlm_put_lockspace(ls);
280 static int device_create_lockspace(struct dlm_lspace_params *params)
282 dlm_lockspace_t *lockspace;
286 if (!capable(CAP_SYS_ADMIN))
289 error = dlm_new_lockspace(params->name, strlen(params->name),
290 &lockspace, 0, DLM_USER_LVB_LEN);
294 ls = dlm_find_lockspace_local(lockspace);
299 len = strlen(params->name) + strlen(name_prefix) + 2;
300 ls->ls_device.name = kzalloc(len, GFP_KERNEL);
301 if (!ls->ls_device.name)
303 snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
305 ls->ls_device.fops = &device_fops;
306 ls->ls_device.minor = MISC_DYNAMIC_MINOR;
308 error = misc_register(&ls->ls_device);
310 kfree(ls->ls_device.name);
314 error = ls->ls_device.minor;
315 dlm_put_lockspace(ls);
319 dlm_put_lockspace(ls);
320 dlm_release_lockspace(lockspace, 0);
324 static int device_remove_lockspace(struct dlm_lspace_params *params)
326 dlm_lockspace_t *lockspace;
330 if (!capable(CAP_SYS_ADMIN))
333 ls = dlm_find_lockspace_device(params->minor);
337 error = misc_deregister(&ls->ls_device);
339 dlm_put_lockspace(ls);
342 kfree(ls->ls_device.name);
344 lockspace = ls->ls_local_handle;
346 /* dlm_release_lockspace waits for references to go to zero,
347 so all processes will need to close their device for the ls
348 before the release will procede */
350 dlm_put_lockspace(ls);
351 error = dlm_release_lockspace(lockspace, 0);
356 /* Check the user's version matches ours */
357 static int check_version(struct dlm_write_request *req)
359 if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
360 (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
361 req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
363 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
364 "user (%d.%d.%d) kernel (%d.%d.%d)\n",
370 DLM_DEVICE_VERSION_MAJOR,
371 DLM_DEVICE_VERSION_MINOR,
372 DLM_DEVICE_VERSION_PATCH);
382 * dlm_user_request -> request_lock
383 * dlm_user_convert -> convert_lock
386 * dlm_user_unlock -> unlock_lock
387 * dlm_user_cancel -> cancel_lock
389 * device_create_lockspace
392 * device_remove_lockspace
393 * dlm_release_lockspace
396 /* a write to a lockspace device is a lock or unlock request, a write
397 to the control device is to create/remove a lockspace */
399 static ssize_t device_write(struct file *file, const char __user *buf,
400 size_t count, loff_t *ppos)
402 struct dlm_user_proc *proc = file->private_data;
403 struct dlm_write_request *kbuf;
404 sigset_t tmpsig, allsigs;
408 if (count < sizeof(struct dlm_write_request32))
410 if (count < sizeof(struct dlm_write_request))
414 kbuf = kmalloc(count, GFP_KERNEL);
418 if (copy_from_user(kbuf, buf, count)) {
423 if (check_version(kbuf)) {
429 if (!kbuf->is64bit) {
430 struct dlm_write_request32 *k32buf;
431 k32buf = (struct dlm_write_request32 *)kbuf;
432 kbuf = kmalloc(count + (sizeof(struct dlm_write_request) -
433 sizeof(struct dlm_write_request32)), GFP_KERNEL);
438 set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
439 compat_input(kbuf, k32buf);
444 /* do we really need this? can a write happen after a close? */
445 if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
446 test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
449 sigfillset(&allsigs);
450 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
458 log_print("no locking on control device");
461 error = device_user_lock(proc, &kbuf->i.lock);
464 case DLM_USER_UNLOCK:
466 log_print("no locking on control device");
469 error = device_user_unlock(proc, &kbuf->i.lock);
472 case DLM_USER_CREATE_LOCKSPACE:
474 log_print("create/remove only on control device");
477 error = device_create_lockspace(&kbuf->i.lspace);
480 case DLM_USER_REMOVE_LOCKSPACE:
482 log_print("create/remove only on control device");
485 error = device_remove_lockspace(&kbuf->i.lspace);
489 log_print("Unknown command passed to DLM device : %d\n",
494 sigprocmask(SIG_SETMASK, &tmpsig, NULL);
501 /* Every process that opens the lockspace device has its own "proc" structure
502 hanging off the open file that's used to keep track of locks owned by the
503 process and asts that need to be delivered to the process. */
505 static int device_open(struct inode *inode, struct file *file)
507 struct dlm_user_proc *proc;
510 ls = dlm_find_lockspace_device(iminor(inode));
514 proc = kzalloc(sizeof(struct dlm_user_proc), GFP_KERNEL);
516 dlm_put_lockspace(ls);
520 proc->lockspace = ls->ls_local_handle;
521 INIT_LIST_HEAD(&proc->asts);
522 INIT_LIST_HEAD(&proc->locks);
523 spin_lock_init(&proc->asts_spin);
524 spin_lock_init(&proc->locks_spin);
525 init_waitqueue_head(&proc->wait);
526 file->private_data = proc;
531 static int device_close(struct inode *inode, struct file *file)
533 struct dlm_user_proc *proc = file->private_data;
535 sigset_t tmpsig, allsigs;
537 ls = dlm_find_lockspace_local(proc->lockspace);
541 sigfillset(&allsigs);
542 sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
544 set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
546 dlm_clear_proc_locks(ls, proc);
548 /* at this point no more lkb's should exist for this lockspace,
549 so there's no chance of dlm_user_add_ast() being called and
550 looking for lkb->ua->proc */
553 file->private_data = NULL;
555 dlm_put_lockspace(ls);
556 dlm_put_lockspace(ls); /* for the find in device_open() */
558 /* FIXME: AUTOFREE: if this ls is no longer used do
559 device_remove_lockspace() */
561 sigprocmask(SIG_SETMASK, &tmpsig, NULL);
567 static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type,
568 int bmode, char __user *buf, size_t count)
571 struct dlm_lock_result32 result32;
573 struct dlm_lock_result result;
579 memset(&result, 0, sizeof(struct dlm_lock_result));
580 memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
581 result.user_lksb = ua->user_lksb;
583 /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
584 in a conversion unless the conversion is successful. See code
585 in dlm_user_convert() for updating ua from ua_tmp. OpenVMS, though,
586 notes that a new blocking AST address and parameter are set even if
587 the conversion fails, so maybe we should just do that. */
589 if (type == AST_BAST) {
590 result.user_astaddr = ua->bastaddr;
591 result.user_astparam = ua->bastparam;
592 result.bast_mode = bmode;
594 result.user_astaddr = ua->castaddr;
595 result.user_astparam = ua->castparam;
600 len = sizeof(struct dlm_lock_result32);
603 len = sizeof(struct dlm_lock_result);
606 /* copy lvb to userspace if there is one, it's been updated, and
607 the user buffer has space for it */
609 if (ua->update_user_lvb && ua->lksb.sb_lvbptr &&
610 count >= len + DLM_USER_LVB_LEN) {
611 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
617 result.lvb_offset = len;
618 len += DLM_USER_LVB_LEN;
625 compat_output(&result, &result32);
626 resultptr = &result32;
630 if (copy_to_user(buf, resultptr, struct_len))
638 /* a read returns a single ast described in a struct dlm_lock_result */
640 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
643 struct dlm_user_proc *proc = file->private_data;
645 struct dlm_user_args *ua;
646 DECLARE_WAITQUEUE(wait, current);
647 int error, type=0, bmode=0, removed = 0;
650 if (count < sizeof(struct dlm_lock_result32))
652 if (count < sizeof(struct dlm_lock_result))
656 /* do we really need this? can a read happen after a close? */
657 if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
660 spin_lock(&proc->asts_spin);
661 if (list_empty(&proc->asts)) {
662 if (file->f_flags & O_NONBLOCK) {
663 spin_unlock(&proc->asts_spin);
667 add_wait_queue(&proc->wait, &wait);
670 set_current_state(TASK_INTERRUPTIBLE);
671 if (list_empty(&proc->asts) && !signal_pending(current)) {
672 spin_unlock(&proc->asts_spin);
674 spin_lock(&proc->asts_spin);
677 set_current_state(TASK_RUNNING);
678 remove_wait_queue(&proc->wait, &wait);
680 if (signal_pending(current)) {
681 spin_unlock(&proc->asts_spin);
686 if (list_empty(&proc->asts)) {
687 spin_unlock(&proc->asts_spin);
691 /* there may be both completion and blocking asts to return for
692 the lkb, don't remove lkb from asts list unless no asts remain */
694 lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_astqueue);
696 if (lkb->lkb_ast_type & AST_COMP) {
697 lkb->lkb_ast_type &= ~AST_COMP;
699 } else if (lkb->lkb_ast_type & AST_BAST) {
700 lkb->lkb_ast_type &= ~AST_BAST;
702 bmode = lkb->lkb_bastmode;
705 if (!lkb->lkb_ast_type) {
706 list_del(&lkb->lkb_astqueue);
709 spin_unlock(&proc->asts_spin);
711 ua = (struct dlm_user_args *)lkb->lkb_astparam;
712 error = copy_result_to_user(ua,
713 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
714 type, bmode, buf, count);
716 /* removes reference for the proc->asts lists added by
717 dlm_user_add_ast() and may result in the lkb being freed */
724 static unsigned int device_poll(struct file *file, poll_table *wait)
726 struct dlm_user_proc *proc = file->private_data;
728 poll_wait(file, &proc->wait, wait);
730 spin_lock(&proc->asts_spin);
731 if (!list_empty(&proc->asts)) {
732 spin_unlock(&proc->asts_spin);
733 return POLLIN | POLLRDNORM;
735 spin_unlock(&proc->asts_spin);
739 static int ctl_device_open(struct inode *inode, struct file *file)
741 file->private_data = NULL;
745 static int ctl_device_close(struct inode *inode, struct file *file)
750 static struct file_operations device_fops = {
752 .release = device_close,
754 .write = device_write,
756 .owner = THIS_MODULE,
759 static struct file_operations ctl_device_fops = {
760 .open = ctl_device_open,
761 .release = ctl_device_close,
762 .write = device_write,
763 .owner = THIS_MODULE,
766 int dlm_user_init(void)
770 ctl_device.name = "dlm-control";
771 ctl_device.fops = &ctl_device_fops;
772 ctl_device.minor = MISC_DYNAMIC_MINOR;
774 error = misc_register(&ctl_device);
776 log_print("misc_register failed for control device");
781 void dlm_user_exit(void)
783 misc_deregister(&ctl_device);