Pull altix into release branch
[linux-2.6] / fs / dlm / user.c
1 /*
2  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
3  *
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.
7  */
8
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>
14 #include <linux/fs.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
21 #include "dlm_internal.h"
22 #include "lockspace.h"
23 #include "lock.h"
24 #include "lvb_table.h"
25 #include "user.h"
26
27 static const char *name_prefix="dlm";
28 static struct miscdevice ctl_device;
29 static const struct file_operations device_fops;
30
31 #ifdef CONFIG_COMPAT
32
33 struct dlm_lock_params32 {
34         __u8 mode;
35         __u8 namelen;
36         __u16 flags;
37         __u32 lkid;
38         __u32 parent;
39
40         __u32 castparam;
41         __u32 castaddr;
42         __u32 bastparam;
43         __u32 bastaddr;
44         __u32 lksb;
45
46         char lvb[DLM_USER_LVB_LEN];
47         char name[0];
48 };
49
50 struct dlm_write_request32 {
51         __u32 version[3];
52         __u8 cmd;
53         __u8 is64bit;
54         __u8 unused[2];
55
56         union  {
57                 struct dlm_lock_params32 lock;
58                 struct dlm_lspace_params lspace;
59         } i;
60 };
61
62 struct dlm_lksb32 {
63         __u32 sb_status;
64         __u32 sb_lkid;
65         __u8 sb_flags;
66         __u32 sb_lvbptr;
67 };
68
69 struct dlm_lock_result32 {
70         __u32 length;
71         __u32 user_astaddr;
72         __u32 user_astparam;
73         __u32 user_lksb;
74         struct dlm_lksb32 lksb;
75         __u8 bast_mode;
76         __u8 unused[3];
77         /* Offsets may be zero if no data is present */
78         __u32 lvb_offset;
79 };
80
81 static void compat_input(struct dlm_write_request *kb,
82                          struct dlm_write_request32 *kb32)
83 {
84         kb->version[0] = kb32->version[0];
85         kb->version[1] = kb32->version[1];
86         kb->version[2] = kb32->version[2];
87
88         kb->cmd = kb32->cmd;
89         kb->is64bit = kb32->is64bit;
90         if (kb->cmd == DLM_USER_CREATE_LOCKSPACE ||
91             kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
92                 kb->i.lspace.flags = kb32->i.lspace.flags;
93                 kb->i.lspace.minor = kb32->i.lspace.minor;
94                 strcpy(kb->i.lspace.name, kb32->i.lspace.name);
95         } else {
96                 kb->i.lock.mode = kb32->i.lock.mode;
97                 kb->i.lock.namelen = kb32->i.lock.namelen;
98                 kb->i.lock.flags = kb32->i.lock.flags;
99                 kb->i.lock.lkid = kb32->i.lock.lkid;
100                 kb->i.lock.parent = kb32->i.lock.parent;
101                 kb->i.lock.castparam = (void *)(long)kb32->i.lock.castparam;
102                 kb->i.lock.castaddr = (void *)(long)kb32->i.lock.castaddr;
103                 kb->i.lock.bastparam = (void *)(long)kb32->i.lock.bastparam;
104                 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
105                 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
106                 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
107                 memcpy(kb->i.lock.name, kb32->i.lock.name, kb->i.lock.namelen);
108         }
109 }
110
111 static void compat_output(struct dlm_lock_result *res,
112                           struct dlm_lock_result32 *res32)
113 {
114         res32->length = res->length - (sizeof(struct dlm_lock_result) -
115                                        sizeof(struct dlm_lock_result32));
116         res32->user_astaddr = (__u32)(long)res->user_astaddr;
117         res32->user_astparam = (__u32)(long)res->user_astparam;
118         res32->user_lksb = (__u32)(long)res->user_lksb;
119         res32->bast_mode = res->bast_mode;
120
121         res32->lvb_offset = res->lvb_offset;
122         res32->length = res->length;
123
124         res32->lksb.sb_status = res->lksb.sb_status;
125         res32->lksb.sb_flags = res->lksb.sb_flags;
126         res32->lksb.sb_lkid = res->lksb.sb_lkid;
127         res32->lksb.sb_lvbptr = (__u32)(long)res->lksb.sb_lvbptr;
128 }
129 #endif
130
131
132 void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
133 {
134         struct dlm_ls *ls;
135         struct dlm_user_args *ua;
136         struct dlm_user_proc *proc;
137         int remove_ownqueue = 0;
138
139         /* dlm_clear_proc_locks() sets ORPHAN/DEAD flag on each
140            lkb before dealing with it.  We need to check this
141            flag before taking ls_clear_proc_locks mutex because if
142            it's set, dlm_clear_proc_locks() holds the mutex. */
143
144         if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) {
145                 /* log_print("user_add_ast skip1 %x", lkb->lkb_flags); */
146                 return;
147         }
148
149         ls = lkb->lkb_resource->res_ls;
150         mutex_lock(&ls->ls_clear_proc_locks);
151
152         /* If ORPHAN/DEAD flag is set, it means the process is dead so an ast
153            can't be delivered.  For ORPHAN's, dlm_clear_proc_locks() freed
154            lkb->ua so we can't try to use it. */
155
156         if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD)) {
157                 /* log_print("user_add_ast skip2 %x", lkb->lkb_flags); */
158                 goto out;
159         }
160
161         DLM_ASSERT(lkb->lkb_astparam, dlm_print_lkb(lkb););
162         ua = (struct dlm_user_args *)lkb->lkb_astparam;
163         proc = ua->proc;
164
165         if (type == AST_BAST && ua->bastaddr == NULL)
166                 goto out;
167
168         spin_lock(&proc->asts_spin);
169         if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) {
170                 kref_get(&lkb->lkb_ref);
171                 list_add_tail(&lkb->lkb_astqueue, &proc->asts);
172                 lkb->lkb_ast_type |= type;
173                 wake_up_interruptible(&proc->wait);
174         }
175
176         /* noqueue requests that fail may need to be removed from the
177            proc's locks list, there should be a better way of detecting
178            this situation than checking all these things... */
179
180         if (type == AST_COMP && lkb->lkb_grmode == DLM_LOCK_IV &&
181             ua->lksb.sb_status == -EAGAIN && !list_empty(&lkb->lkb_ownqueue))
182                 remove_ownqueue = 1;
183
184         /* unlocks or cancels of waiting requests need to be removed from the
185            proc's unlocking list, again there must be a better way...  */
186
187         if (ua->lksb.sb_status == -DLM_EUNLOCK ||
188             (ua->lksb.sb_status == -DLM_ECANCEL &&
189              lkb->lkb_grmode == DLM_LOCK_IV))
190                 remove_ownqueue = 1;
191
192         /* We want to copy the lvb to userspace when the completion
193            ast is read if the status is 0, the lock has an lvb and
194            lvb_ops says we should.  We could probably have set_lvb_lock()
195            set update_user_lvb instead and not need old_mode */
196
197         if ((lkb->lkb_ast_type & AST_COMP) &&
198             (lkb->lkb_lksb->sb_status == 0) &&
199             lkb->lkb_lksb->sb_lvbptr &&
200             dlm_lvb_operations[ua->old_mode + 1][lkb->lkb_grmode + 1])
201                 ua->update_user_lvb = 1;
202         else
203                 ua->update_user_lvb = 0;
204
205         spin_unlock(&proc->asts_spin);
206
207         if (remove_ownqueue) {
208                 spin_lock(&ua->proc->locks_spin);
209                 list_del_init(&lkb->lkb_ownqueue);
210                 spin_unlock(&ua->proc->locks_spin);
211                 dlm_put_lkb(lkb);
212         }
213  out:
214         mutex_unlock(&ls->ls_clear_proc_locks);
215 }
216
217 static int device_user_lock(struct dlm_user_proc *proc,
218                             struct dlm_lock_params *params)
219 {
220         struct dlm_ls *ls;
221         struct dlm_user_args *ua;
222         int error = -ENOMEM;
223
224         ls = dlm_find_lockspace_local(proc->lockspace);
225         if (!ls)
226                 return -ENOENT;
227
228         if (!params->castaddr || !params->lksb) {
229                 error = -EINVAL;
230                 goto out;
231         }
232
233         ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
234         if (!ua)
235                 goto out;
236         ua->proc = proc;
237         ua->user_lksb = params->lksb;
238         ua->castparam = params->castparam;
239         ua->castaddr = params->castaddr;
240         ua->bastparam = params->bastparam;
241         ua->bastaddr = params->bastaddr;
242
243         if (params->flags & DLM_LKF_CONVERT)
244                 error = dlm_user_convert(ls, ua,
245                                          params->mode, params->flags,
246                                          params->lkid, params->lvb);
247         else {
248                 error = dlm_user_request(ls, ua,
249                                          params->mode, params->flags,
250                                          params->name, params->namelen,
251                                          params->parent);
252                 if (!error)
253                         error = ua->lksb.sb_lkid;
254         }
255  out:
256         dlm_put_lockspace(ls);
257         return error;
258 }
259
260 static int device_user_unlock(struct dlm_user_proc *proc,
261                               struct dlm_lock_params *params)
262 {
263         struct dlm_ls *ls;
264         struct dlm_user_args *ua;
265         int error = -ENOMEM;
266
267         ls = dlm_find_lockspace_local(proc->lockspace);
268         if (!ls)
269                 return -ENOENT;
270
271         ua = kzalloc(sizeof(struct dlm_user_args), GFP_KERNEL);
272         if (!ua)
273                 goto out;
274         ua->proc = proc;
275         ua->user_lksb = params->lksb;
276         ua->castparam = params->castparam;
277         ua->castaddr = params->castaddr;
278
279         if (params->flags & DLM_LKF_CANCEL)
280                 error = dlm_user_cancel(ls, ua, params->flags, params->lkid);
281         else
282                 error = dlm_user_unlock(ls, ua, params->flags, params->lkid,
283                                         params->lvb);
284  out:
285         dlm_put_lockspace(ls);
286         return error;
287 }
288
289 static int device_create_lockspace(struct dlm_lspace_params *params)
290 {
291         dlm_lockspace_t *lockspace;
292         struct dlm_ls *ls;
293         int error, len;
294
295         if (!capable(CAP_SYS_ADMIN))
296                 return -EPERM;
297
298         error = dlm_new_lockspace(params->name, strlen(params->name),
299                                   &lockspace, 0, DLM_USER_LVB_LEN);
300         if (error)
301                 return error;
302
303         ls = dlm_find_lockspace_local(lockspace);
304         if (!ls)
305                 return -ENOENT;
306
307         error = -ENOMEM;
308         len = strlen(params->name) + strlen(name_prefix) + 2;
309         ls->ls_device.name = kzalloc(len, GFP_KERNEL);
310         if (!ls->ls_device.name)
311                 goto fail;
312         snprintf((char *)ls->ls_device.name, len, "%s_%s", name_prefix,
313                  params->name);
314         ls->ls_device.fops = &device_fops;
315         ls->ls_device.minor = MISC_DYNAMIC_MINOR;
316
317         error = misc_register(&ls->ls_device);
318         if (error) {
319                 kfree(ls->ls_device.name);
320                 goto fail;
321         }
322
323         error = ls->ls_device.minor;
324         dlm_put_lockspace(ls);
325         return error;
326
327  fail:
328         dlm_put_lockspace(ls);
329         dlm_release_lockspace(lockspace, 0);
330         return error;
331 }
332
333 static int device_remove_lockspace(struct dlm_lspace_params *params)
334 {
335         dlm_lockspace_t *lockspace;
336         struct dlm_ls *ls;
337         int error, force = 0;
338
339         if (!capable(CAP_SYS_ADMIN))
340                 return -EPERM;
341
342         ls = dlm_find_lockspace_device(params->minor);
343         if (!ls)
344                 return -ENOENT;
345
346         error = misc_deregister(&ls->ls_device);
347         if (error) {
348                 dlm_put_lockspace(ls);
349                 goto out;
350         }
351         kfree(ls->ls_device.name);
352
353         if (params->flags & DLM_USER_LSFLG_FORCEFREE)
354                 force = 2;
355
356         lockspace = ls->ls_local_handle;
357
358         /* dlm_release_lockspace waits for references to go to zero,
359            so all processes will need to close their device for the ls
360            before the release will procede */
361
362         dlm_put_lockspace(ls);
363         error = dlm_release_lockspace(lockspace, force);
364  out:
365         return error;
366 }
367
368 /* Check the user's version matches ours */
369 static int check_version(struct dlm_write_request *req)
370 {
371         if (req->version[0] != DLM_DEVICE_VERSION_MAJOR ||
372             (req->version[0] == DLM_DEVICE_VERSION_MAJOR &&
373              req->version[1] > DLM_DEVICE_VERSION_MINOR)) {
374
375                 printk(KERN_DEBUG "dlm: process %s (%d) version mismatch "
376                        "user (%d.%d.%d) kernel (%d.%d.%d)\n",
377                        current->comm,
378                        current->pid,
379                        req->version[0],
380                        req->version[1],
381                        req->version[2],
382                        DLM_DEVICE_VERSION_MAJOR,
383                        DLM_DEVICE_VERSION_MINOR,
384                        DLM_DEVICE_VERSION_PATCH);
385                 return -EINVAL;
386         }
387         return 0;
388 }
389
390 /*
391  * device_write
392  *
393  *   device_user_lock
394  *     dlm_user_request -> request_lock
395  *     dlm_user_convert -> convert_lock
396  *
397  *   device_user_unlock
398  *     dlm_user_unlock -> unlock_lock
399  *     dlm_user_cancel -> cancel_lock
400  *
401  *   device_create_lockspace
402  *     dlm_new_lockspace
403  *
404  *   device_remove_lockspace
405  *     dlm_release_lockspace
406  */
407
408 /* a write to a lockspace device is a lock or unlock request, a write
409    to the control device is to create/remove a lockspace */
410
411 static ssize_t device_write(struct file *file, const char __user *buf,
412                             size_t count, loff_t *ppos)
413 {
414         struct dlm_user_proc *proc = file->private_data;
415         struct dlm_write_request *kbuf;
416         sigset_t tmpsig, allsigs;
417         int error;
418
419 #ifdef CONFIG_COMPAT
420         if (count < sizeof(struct dlm_write_request32))
421 #else
422         if (count < sizeof(struct dlm_write_request))
423 #endif
424                 return -EINVAL;
425
426         kbuf = kmalloc(count, GFP_KERNEL);
427         if (!kbuf)
428                 return -ENOMEM;
429
430         if (copy_from_user(kbuf, buf, count)) {
431                 error = -EFAULT;
432                 goto out_free;
433         }
434
435         if (check_version(kbuf)) {
436                 error = -EBADE;
437                 goto out_free;
438         }
439
440 #ifdef CONFIG_COMPAT
441         if (!kbuf->is64bit) {
442                 struct dlm_write_request32 *k32buf;
443                 k32buf = (struct dlm_write_request32 *)kbuf;
444                 kbuf = kmalloc(count + (sizeof(struct dlm_write_request) -
445                                sizeof(struct dlm_write_request32)), GFP_KERNEL);
446                 if (!kbuf)
447                         return -ENOMEM;
448
449                 if (proc)
450                         set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
451                 compat_input(kbuf, k32buf);
452                 kfree(k32buf);
453         }
454 #endif
455
456         /* do we really need this? can a write happen after a close? */
457         if ((kbuf->cmd == DLM_USER_LOCK || kbuf->cmd == DLM_USER_UNLOCK) &&
458             test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
459                 return -EINVAL;
460
461         sigfillset(&allsigs);
462         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
463
464         error = -EINVAL;
465
466         switch (kbuf->cmd)
467         {
468         case DLM_USER_LOCK:
469                 if (!proc) {
470                         log_print("no locking on control device");
471                         goto out_sig;
472                 }
473                 error = device_user_lock(proc, &kbuf->i.lock);
474                 break;
475
476         case DLM_USER_UNLOCK:
477                 if (!proc) {
478                         log_print("no locking on control device");
479                         goto out_sig;
480                 }
481                 error = device_user_unlock(proc, &kbuf->i.lock);
482                 break;
483
484         case DLM_USER_CREATE_LOCKSPACE:
485                 if (proc) {
486                         log_print("create/remove only on control device");
487                         goto out_sig;
488                 }
489                 error = device_create_lockspace(&kbuf->i.lspace);
490                 break;
491
492         case DLM_USER_REMOVE_LOCKSPACE:
493                 if (proc) {
494                         log_print("create/remove only on control device");
495                         goto out_sig;
496                 }
497                 error = device_remove_lockspace(&kbuf->i.lspace);
498                 break;
499
500         default:
501                 log_print("Unknown command passed to DLM device : %d\n",
502                           kbuf->cmd);
503         }
504
505  out_sig:
506         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
507         recalc_sigpending();
508  out_free:
509         kfree(kbuf);
510         return error;
511 }
512
513 /* Every process that opens the lockspace device has its own "proc" structure
514    hanging off the open file that's used to keep track of locks owned by the
515    process and asts that need to be delivered to the process. */
516
517 static int device_open(struct inode *inode, struct file *file)
518 {
519         struct dlm_user_proc *proc;
520         struct dlm_ls *ls;
521
522         ls = dlm_find_lockspace_device(iminor(inode));
523         if (!ls)
524                 return -ENOENT;
525
526         proc = kzalloc(sizeof(struct dlm_user_proc), GFP_KERNEL);
527         if (!proc) {
528                 dlm_put_lockspace(ls);
529                 return -ENOMEM;
530         }
531
532         proc->lockspace = ls->ls_local_handle;
533         INIT_LIST_HEAD(&proc->asts);
534         INIT_LIST_HEAD(&proc->locks);
535         INIT_LIST_HEAD(&proc->unlocking);
536         spin_lock_init(&proc->asts_spin);
537         spin_lock_init(&proc->locks_spin);
538         init_waitqueue_head(&proc->wait);
539         file->private_data = proc;
540
541         return 0;
542 }
543
544 static int device_close(struct inode *inode, struct file *file)
545 {
546         struct dlm_user_proc *proc = file->private_data;
547         struct dlm_ls *ls;
548         sigset_t tmpsig, allsigs;
549
550         ls = dlm_find_lockspace_local(proc->lockspace);
551         if (!ls)
552                 return -ENOENT;
553
554         sigfillset(&allsigs);
555         sigprocmask(SIG_BLOCK, &allsigs, &tmpsig);
556
557         set_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags);
558
559         dlm_clear_proc_locks(ls, proc);
560
561         /* at this point no more lkb's should exist for this lockspace,
562            so there's no chance of dlm_user_add_ast() being called and
563            looking for lkb->ua->proc */
564
565         kfree(proc);
566         file->private_data = NULL;
567
568         dlm_put_lockspace(ls);
569         dlm_put_lockspace(ls);  /* for the find in device_open() */
570
571         /* FIXME: AUTOFREE: if this ls is no longer used do
572            device_remove_lockspace() */
573
574         sigprocmask(SIG_SETMASK, &tmpsig, NULL);
575         recalc_sigpending();
576
577         return 0;
578 }
579
580 static int copy_result_to_user(struct dlm_user_args *ua, int compat, int type,
581                                int bmode, char __user *buf, size_t count)
582 {
583 #ifdef CONFIG_COMPAT
584         struct dlm_lock_result32 result32;
585 #endif
586         struct dlm_lock_result result;
587         void *resultptr;
588         int error=0;
589         int len;
590         int struct_len;
591
592         memset(&result, 0, sizeof(struct dlm_lock_result));
593         memcpy(&result.lksb, &ua->lksb, sizeof(struct dlm_lksb));
594         result.user_lksb = ua->user_lksb;
595
596         /* FIXME: dlm1 provides for the user's bastparam/addr to not be updated
597            in a conversion unless the conversion is successful.  See code
598            in dlm_user_convert() for updating ua from ua_tmp.  OpenVMS, though,
599            notes that a new blocking AST address and parameter are set even if
600            the conversion fails, so maybe we should just do that. */
601
602         if (type == AST_BAST) {
603                 result.user_astaddr = ua->bastaddr;
604                 result.user_astparam = ua->bastparam;
605                 result.bast_mode = bmode;
606         } else {
607                 result.user_astaddr = ua->castaddr;
608                 result.user_astparam = ua->castparam;
609         }
610
611 #ifdef CONFIG_COMPAT
612         if (compat)
613                 len = sizeof(struct dlm_lock_result32);
614         else
615 #endif
616                 len = sizeof(struct dlm_lock_result);
617         struct_len = len;
618
619         /* copy lvb to userspace if there is one, it's been updated, and
620            the user buffer has space for it */
621
622         if (ua->update_user_lvb && ua->lksb.sb_lvbptr &&
623             count >= len + DLM_USER_LVB_LEN) {
624                 if (copy_to_user(buf+len, ua->lksb.sb_lvbptr,
625                                  DLM_USER_LVB_LEN)) {
626                         error = -EFAULT;
627                         goto out;
628                 }
629
630                 result.lvb_offset = len;
631                 len += DLM_USER_LVB_LEN;
632         }
633
634         result.length = len;
635         resultptr = &result;
636 #ifdef CONFIG_COMPAT
637         if (compat) {
638                 compat_output(&result, &result32);
639                 resultptr = &result32;
640         }
641 #endif
642
643         if (copy_to_user(buf, resultptr, struct_len))
644                 error = -EFAULT;
645         else
646                 error = len;
647  out:
648         return error;
649 }
650
651 /* a read returns a single ast described in a struct dlm_lock_result */
652
653 static ssize_t device_read(struct file *file, char __user *buf, size_t count,
654                            loff_t *ppos)
655 {
656         struct dlm_user_proc *proc = file->private_data;
657         struct dlm_lkb *lkb;
658         struct dlm_user_args *ua;
659         DECLARE_WAITQUEUE(wait, current);
660         int error, type=0, bmode=0, removed = 0;
661
662 #ifdef CONFIG_COMPAT
663         if (count < sizeof(struct dlm_lock_result32))
664 #else
665         if (count < sizeof(struct dlm_lock_result))
666 #endif
667                 return -EINVAL;
668
669         /* do we really need this? can a read happen after a close? */
670         if (test_bit(DLM_PROC_FLAGS_CLOSING, &proc->flags))
671                 return -EINVAL;
672
673         spin_lock(&proc->asts_spin);
674         if (list_empty(&proc->asts)) {
675                 if (file->f_flags & O_NONBLOCK) {
676                         spin_unlock(&proc->asts_spin);
677                         return -EAGAIN;
678                 }
679
680                 add_wait_queue(&proc->wait, &wait);
681
682         repeat:
683                 set_current_state(TASK_INTERRUPTIBLE);
684                 if (list_empty(&proc->asts) && !signal_pending(current)) {
685                         spin_unlock(&proc->asts_spin);
686                         schedule();
687                         spin_lock(&proc->asts_spin);
688                         goto repeat;
689                 }
690                 set_current_state(TASK_RUNNING);
691                 remove_wait_queue(&proc->wait, &wait);
692
693                 if (signal_pending(current)) {
694                         spin_unlock(&proc->asts_spin);
695                         return -ERESTARTSYS;
696                 }
697         }
698
699         if (list_empty(&proc->asts)) {
700                 spin_unlock(&proc->asts_spin);
701                 return -EAGAIN;
702         }
703
704         /* there may be both completion and blocking asts to return for
705            the lkb, don't remove lkb from asts list unless no asts remain */
706
707         lkb = list_entry(proc->asts.next, struct dlm_lkb, lkb_astqueue);
708
709         if (lkb->lkb_ast_type & AST_COMP) {
710                 lkb->lkb_ast_type &= ~AST_COMP;
711                 type = AST_COMP;
712         } else if (lkb->lkb_ast_type & AST_BAST) {
713                 lkb->lkb_ast_type &= ~AST_BAST;
714                 type = AST_BAST;
715                 bmode = lkb->lkb_bastmode;
716         }
717
718         if (!lkb->lkb_ast_type) {
719                 list_del(&lkb->lkb_astqueue);
720                 removed = 1;
721         }
722         spin_unlock(&proc->asts_spin);
723
724         ua = (struct dlm_user_args *)lkb->lkb_astparam;
725         error = copy_result_to_user(ua,
726                                 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
727                                 type, bmode, buf, count);
728
729         /* removes reference for the proc->asts lists added by
730            dlm_user_add_ast() and may result in the lkb being freed */
731         if (removed)
732                 dlm_put_lkb(lkb);
733
734         return error;
735 }
736
737 static unsigned int device_poll(struct file *file, poll_table *wait)
738 {
739         struct dlm_user_proc *proc = file->private_data;
740
741         poll_wait(file, &proc->wait, wait);
742
743         spin_lock(&proc->asts_spin);
744         if (!list_empty(&proc->asts)) {
745                 spin_unlock(&proc->asts_spin);
746                 return POLLIN | POLLRDNORM;
747         }
748         spin_unlock(&proc->asts_spin);
749         return 0;
750 }
751
752 static int ctl_device_open(struct inode *inode, struct file *file)
753 {
754         file->private_data = NULL;
755         return 0;
756 }
757
758 static int ctl_device_close(struct inode *inode, struct file *file)
759 {
760         return 0;
761 }
762
763 static const struct file_operations device_fops = {
764         .open    = device_open,
765         .release = device_close,
766         .read    = device_read,
767         .write   = device_write,
768         .poll    = device_poll,
769         .owner   = THIS_MODULE,
770 };
771
772 static const struct file_operations ctl_device_fops = {
773         .open    = ctl_device_open,
774         .release = ctl_device_close,
775         .write   = device_write,
776         .owner   = THIS_MODULE,
777 };
778
779 int dlm_user_init(void)
780 {
781         int error;
782
783         ctl_device.name = "dlm-control";
784         ctl_device.fops = &ctl_device_fops;
785         ctl_device.minor = MISC_DYNAMIC_MINOR;
786
787         error = misc_register(&ctl_device);
788         if (error)
789                 log_print("misc_register failed for control device");
790
791         return error;
792 }
793
794 void dlm_user_exit(void)
795 {
796         misc_deregister(&ctl_device);
797 }
798