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